airwallex 0.7.0 → 0.9.0

data/lib/airwallex/resources/account_offboarding.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Airwallex
+  # Represents an offboarding request for a Connected Account. Always
+  # accessed through its parent ConnectedAccount, since its API path is
+  # scoped by account_id.
+  #
+  # This gem currently only implements the sandbox Simulation endpoints for
+  # completing/cancelling an offboarding; it does not yet implement the live
+  # create/retrieve/list endpoints (`/api/v1/accounts/{account_id}/offboardings`).
+  # See https://www.airwallex.com/docs/api/simulation/connected-account-offboarding
+  #
+  # @example Simulate an offboarding finishing
+  #   Airwallex::AccountOffboarding.simulate_complete("acct_123", "obd_456")
+  class AccountOffboarding < APIResource
+    # @param account_id [String] the parent ConnectedAccount's id
+    # @return [String] API resource path for this account's simulated
+    #   offboarding actions
+    def self.resource_path(account_id)
+      "/api/v1/simulation/accounts/#{account_id}/offboardings"
+    end
+
+    # Simulate an offboarding completing
+    #
+    # @param account_id [String]
+    # @param offboarding_id [String]
+    # @return [AccountOffboarding]
+    def self.simulate_complete(account_id, offboarding_id)
+      response = Airwallex.client.post("#{resource_path(account_id)}/#{offboarding_id}/complete", {})
+      new(response)
+    end
+
+    # Simulate an offboarding being cancelled
+    #
+    # @param account_id [String]
+    # @param offboarding_id [String]
+    # @return [AccountOffboarding]
+    def self.simulate_cancel(account_id, offboarding_id)
+      response = Airwallex.client.post("#{resource_path(account_id)}/#{offboarding_id}/cancel", {})
+      new(response)
+    end
+  end
+end

data/lib/airwallex/resources/beneficiary.rb

@@ -64,36 +64,36 @@ module Airwallex
     # method) before attempting to create the beneficiary.
     #
     # @param params [Hash] the same shape of params you'd pass to .create
-    # @return [Hash] raw validation result
+    # @return [Hash] symbolized validation result
     def self.validate(params = {})
-      Airwallex.client.post("#{resource_path}/validate", params)
+      symbolized_post("#{resource_path}/validate", params)
     end
 
     # Verify ownership of a beneficiary's bank account via Confirmation of
     # Payee (CoP) before creation.
     #
     # @param params [Hash] beneficiary bank account details to verify
-    # @return [Hash] raw verification result (status, account_name_match_result)
+    # @return [Hash] symbolized verification result (status, account_name_match_result)
     def self.verify_account(params = {})
-      Airwallex.client.post("#{resource_path}/verify_account", params)
+      symbolized_post("#{resource_path}/verify_account", params)
     end
 
     # Retrieve the API schema (field validation rules) for beneficiary bank
     # details, keyed by beneficiary type / entity type / bank country.
     #
     # @param params [Hash] e.g. beneficiary_type:, bank_country_code:
-    # @return [Hash] raw schema response
+    # @return [Hash] symbolized schema response
     def self.api_schema(params = {})
-      Airwallex.client.post(API_SCHEMA_PATH, params)
+      symbolized_post(API_SCHEMA_PATH, params)
     end
 
     # Retrieve the dynamic form schema used to render beneficiary bank-detail
     # forms in the UI, keyed by beneficiary type / entity type / bank country.
     #
     # @param params [Hash] e.g. beneficiary_type:, bank_country_code:
-    # @return [Hash] raw schema response
+    # @return [Hash] symbolized schema response
     def self.form_schema(params = {})
-      Airwallex.client.post(FORM_SCHEMA_PATH, params)
+      symbolized_post(FORM_SCHEMA_PATH, params)
     end
 
     # Search financial institutions supported for a given country, currency,
@@ -102,9 +102,9 @@ module Airwallex
     # @param params [Hash] required: bank_country_code:, account_currency:,
     #   entity_type:, transfer_method:, keyword: (a bank-name search term,
     #   min 3 chars)
-    # @return [Hash] raw response listing supported institutions
+    # @return [Hash] symbolized response listing supported institutions
     def self.supported_financial_institutions(params = {})
-      Airwallex.client.get(SUPPORTED_FINANCIAL_INSTITUTIONS_PATH, params)
+      symbolized_get(SUPPORTED_FINANCIAL_INSTITUTIONS_PATH, params)
     end
   end
 end

data/lib/airwallex/resources/billing_customer.rb

@@ -40,9 +40,9 @@ module Airwallex
     # Retrieve the bank transfer instructions for funding this customer's
     # subscriptions (e.g. for a BT-funded instalment plan).
     #
-    # @return [Hash] raw bank transfer instructions
+    # @return [Hash] symbolized bank transfer instructions
     def bank_transfer_instructions
-      Airwallex.client.get("#{self.class.resource_path}/#{id}/bank_transfer_instructions")
+      self.class.symbolized_get("#{self.class.resource_path}/#{id}/bank_transfer_instructions")
     end
   end
 end

data/lib/airwallex/resources/cardholder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Airwallex
+  # Represents an Issuing Cardholder.
+  #
+  # This gem currently only implements the sandbox Simulation endpoint for
+  # bypassing a cardholder's RFI review stage; it does not yet implement the
+  # live create/retrieve/list endpoints.
+  # See https://www.airwallex.com/docs/api/simulation/issuing-cardholders
+  #
+  # @example Bypass a cardholder's pending review
+  #   Airwallex::Cardholder.simulate_pass_review("chd_123")
+  class Cardholder < APIResource
+    # @return [String] API resource path for simulated cardholder actions
+    def self.resource_path
+      "/api/v1/simulation/issuing/cardholders"
+    end
+
+    # Simulate bypassing this cardholder's RFI review stage
+    #
+    # @param cardholder_id [String]
+    # @return [Cardholder]
+    def self.simulate_pass_review(cardholder_id)
+      response = Airwallex.client.post("#{resource_path}/#{cardholder_id}/pass_review", {})
+      new(response)
+    end
+  end
+end

data/lib/airwallex/resources/connected_account.rb

@@ -57,11 +57,29 @@ module Airwallex
     CURRENT_ACCOUNT_PATH = "/api/v1/account"
     WALLET_INFO_PATH = "/api/v1/account/wallet_info"
 
+    # Sandbox-only — see https://www.airwallex.com/docs/api/simulation/connected-accounts
+    SIMULATION_PATH = "/api/v1/simulation/accounts"
+
     # @return [String] API resource path for connected accounts
     def self.resource_path
       "/api/v1/accounts"
     end
 
+    # Simulate this account's status transitioning. The account must
+    # currently be SUBMITTED.
+    #
+    # @param account_id [String]
+    # @param next_status [String] one of "ACTIVE", "SUSPENDED",
+    #   "ACTION_REQUIRED"
+    # @param force [Boolean] defaults to true
+    # @return [ConnectedAccount]
+    def self.simulate_update_status(account_id, next_status:, force: true)
+      response = Airwallex.client.post(
+        "#{SIMULATION_PATH}/#{account_id}/update_status", next_status: next_status, force: force
+      )
+      new(response)
+    end
+
     # Retrieve whichever account the current request is authenticated as
     #
     # @param params [Hash] additional params
@@ -75,9 +93,9 @@ module Airwallex
     # authenticated as
     #
     # @param params [Hash] additional params
-    # @return [Hash] raw wallet info response
+    # @return [Hash] symbolized wallet info response
     def self.wallet_info(params = {})
-      Airwallex.client.get(WALLET_INFO_PATH, params)
+      symbolized_get(WALLET_INFO_PATH, params)
     end
 
     # The legal_entity_id needed by BillingCustomer.create's
@@ -132,5 +150,36 @@ module Airwallex
       refresh_from(response)
       self
     end
+
+    # Simulate this account's status transitioning. The account must
+    # currently be SUBMITTED.
+    #
+    # @param next_status [String] one of "ACTIVE", "SUSPENDED",
+    #   "ACTION_REQUIRED"
+    # @param force [Boolean] defaults to true
+    # @return [ConnectedAccount] self
+    def simulate_update_status(next_status:, force: true)
+      response = Airwallex.client.post(
+        "#{self.class::SIMULATION_PATH}/#{id}/update_status", next_status: next_status, force: force
+      )
+      refresh_from(response)
+      self
+    end
+
+    # Simulate a pending offboarding on this account completing
+    #
+    # @param offboarding_id [String]
+    # @return [AccountOffboarding]
+    def simulate_complete_offboarding(offboarding_id)
+      AccountOffboarding.simulate_complete(id, offboarding_id)
+    end
+
+    # Simulate a pending offboarding on this account being cancelled
+    #
+    # @param offboarding_id [String]
+    # @return [AccountOffboarding]
+    def simulate_cancel_offboarding(offboarding_id)
+      AccountOffboarding.simulate_cancel(id, offboarding_id)
+    end
   end
 end

data/lib/airwallex/resources/deposit.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Airwallex
+  # Represents a Deposit — funds arriving in your Airwallex account, either
+  # as an inbound bank transfer into a Global Account (type: BANK_TRANSFER)
+  # or a Direct Debit pull from a verified LinkedAccount (type:
+  # DIRECT_DEBIT, made via .create).
+  #
+  # The sandbox Simulation actions split cleanly along that same line:
+  # .simulate_create simulates a BANK_TRANSFER deposit landing, and it
+  # auto-settles on its own within a few seconds — same as a real bank
+  # transfer, there's no PENDING state to force through. .simulate_settle/
+  # .simulate_reject/.simulate_reverse only operate on DIRECT_DEBIT
+  # deposits made via .create, since a real direct debit pull takes days
+  # to clear and the sandbox has no other way to resolve it. Calling
+  # settle/reject/reverse on a BANK_TRANSFER deposit's id returns a 404
+  # "Deposit does not exist" — confirmed against the real sandbox.
+  # See https://www.airwallex.com/docs/api/simulation/deposits
+  #
+  # @example Simulate an inbound bank transfer landing (settles on its own)
+  #   Airwallex::Deposit.simulate_create(amount: 100.00, global_account_id: "gacc_123")
+  #
+  # @example Pull via Direct Debit, then force it through the sandbox lifecycle
+  #   deposit = Airwallex::Deposit.create(
+  #     funding_source_id: "la_123", # a verified LinkedAccount id
+  #     amount: 50.00,
+  #     currency: "AUD"
+  #   )
+  #   deposit.simulate_settle
+  class Deposit < APIResource
+    extend APIOperations::Create
+    extend APIOperations::Retrieve
+    extend APIOperations::List
+
+    # Airwallex's own API is inconsistent here: simulating a bank-transfer
+    # deposit landing uses the singular "deposit", while every other
+    # simulation action on an existing deposit uses the plural "deposits".
+    SIMULATE_CREATE_PATH = "/api/v1/simulation/deposit/create"
+    SIMULATION_PATH = "/api/v1/simulation/deposits"
+
+    # @return [String] API resource path for deposits
+    def self.resource_path
+      "/api/v1/deposits"
+    end
+
+    # Simulate an inbound bank-transfer deposit landing in a Global
+    # Account
+    #
+    # @param params [Hash] amount:, global_account_id: (required);
+    #   payer_bankname:, payer_country:, payer_name:, reference:,
+    #   statement_ref:, status: ("PENDING", "REJECTED", or "SETTLED",
+    #   defaults to "SETTLED") (optional)
+    # @return [Deposit]
+    def self.simulate_create(params = {})
+      response = Airwallex.client.post(SIMULATE_CREATE_PATH, params)
+      new(response)
+    end
+
+    # Simulate a PENDING Direct Debit deposit (made via .create) settling
+    #
+    # @param deposit_id [String]
+    # @return [Deposit]
+    def self.simulate_settle(deposit_id)
+      response = Airwallex.client.post("#{SIMULATION_PATH}/#{deposit_id}/settle", {})
+      new(response)
+    end
+
+    # Simulate a PENDING Direct Debit deposit (made via .create) being
+    # rejected
+    #
+    # @param deposit_id [String]
+    # @return [Deposit]
+    def self.simulate_reject(deposit_id)
+      response = Airwallex.client.post("#{SIMULATION_PATH}/#{deposit_id}/reject", {})
+      new(response)
+    end
+
+    # Simulate reversing a SETTLED Direct Debit deposit (creates an
+    # offsetting settled deposit and deactivates the LinkedAccount)
+    #
+    # @param deposit_id [String]
+    # @return [Deposit]
+    def self.simulate_reverse(deposit_id)
+      response = Airwallex.client.post("#{SIMULATION_PATH}/#{deposit_id}/reverse", {})
+      new(response)
+    end
+
+    # Simulate this Direct Debit deposit settling
+    #
+    # @return [Deposit] self
+    def simulate_settle
+      response = Airwallex.client.post("#{self.class::SIMULATION_PATH}/#{id}/settle", {})
+      refresh_from(response)
+      self
+    end
+
+    # Simulate this Direct Debit deposit being rejected
+    #
+    # @return [Deposit] self
+    def simulate_reject
+      response = Airwallex.client.post("#{self.class::SIMULATION_PATH}/#{id}/reject", {})
+      refresh_from(response)
+      self
+    end
+
+    # Simulate reversing this Direct Debit deposit
+    #
+    # @return [Deposit] self
+    def simulate_reverse
+      response = Airwallex.client.post("#{self.class::SIMULATION_PATH}/#{id}/reverse", {})
+      refresh_from(response)
+      self
+    end
+  end
+end

data/lib/airwallex/resources/dispute.rb

@@ -5,7 +5,11 @@ module Airwallex
   #
   # Disputes represent chargebacks or payment disputes initiated by cardholders.
   # Merchants can view disputes, challenge them with evidence, or accept them.
-  # There is no create — disputes originate from card networks/issuing banks.
+  # There is no live create — real disputes originate from card
+  # networks/issuing banks. In the sandbox, `.simulate_create` (and
+  # `#simulate_escalate`/`#simulate_resolve`) stand in for the card
+  # network/issuing bank to drive the full dispute lifecycle for testing.
+  # See https://www.airwallex.com/docs/api/simulation/payment-disputes
   #
   # @example List open disputes
   #   disputes = Airwallex::Dispute.list(status: 'OPEN')
@@ -18,15 +22,70 @@ module Airwallex
   #
   # @example Challenge a dispute
   #   dispute.challenge(...)
+  #
+  # @example Simulate the full sandbox lifecycle
+  #   dispute = Airwallex::Dispute.simulate_create(
+  #     payment_intent_id: "int_123",
+  #     reason_code: "4853",
+  #     stage: "CHARGEBACK",
+  #     due_at: "2026-12-01T23:59:59Z"
+  #   )
+  #   dispute.challenge(customer_communication: "Email thread")
+  #   dispute.simulate_resolve(in_favor_of: "MERCHANT")
   class Dispute < APIResource
     extend APIOperations::Retrieve
     extend APIOperations::List
     include APIOperations::Update
 
+    # Sandbox-only — see https://www.airwallex.com/docs/api/simulation/payment-disputes
+    SIMULATION_PATH = "/api/v1/simulation/pa/payment_disputes"
+
     def self.resource_path
       "/api/v1/pa/payment_disputes"
     end
 
+    # Simulate a card network/issuing bank raising a dispute against a
+    # PaymentIntent
+    #
+    # @param params [Hash] payment_intent_id:, reason_code: (card-brand
+    #   specific, e.g. Mastercard "4853", Visa "10.4"), stage: (one of
+    #   "RFI", "PRE_CHARGEBACK", "CHARGEBACK", "PRE_ARBITRATION",
+    #   "ARBITRATION"), due_at: (required); amount:, comment:, documents:
+    #   (optional)
+    # @return [Dispute]
+    def self.simulate_create(params = {})
+      response = Airwallex.client.post("#{SIMULATION_PATH}/create", params)
+      new(response)
+    end
+
+    # Simulate the issuing bank rejecting the merchant's challenge evidence
+    # and advancing the dispute to the next stage (e.g. Chargeback ->
+    # Pre-arbitration). Not valid while status is REQUIRES_RESPONSE — the
+    # merchant must #accept or #challenge first.
+    #
+    # @param dispute_id [String]
+    # @param params [Hash] due_at: (required); amount:, comment:,
+    #   documents: (optional)
+    # @return [Dispute]
+    def self.simulate_escalate(dispute_id, params = {})
+      response = Airwallex.client.post("#{SIMULATION_PATH}/#{dispute_id}/escalate", params)
+      new(response)
+    end
+
+    # Simulate the issuing bank's final decision on a dispute.
+    # in_favor_of: "MERCHANT" resolves it WON/REVERSED; "CUSTOMER" resolves
+    # it LOST. Not valid while status is REQUIRES_RESPONSE — the merchant
+    # must #accept or #challenge first.
+    #
+    # @param dispute_id [String]
+    # @param params [Hash] in_favor_of: ("MERCHANT" or "CUSTOMER",
+    #   required); amount: (optional, defaults to the full disputed amount)
+    # @return [Dispute]
+    def self.simulate_resolve(dispute_id, params = {})
+      response = Airwallex.client.post("#{SIMULATION_PATH}/#{dispute_id}/resolve", params)
+      new(response)
+    end
+
     # Accept a dispute without challenging it
     #
     # @return [Airwallex::Dispute] self
@@ -47,6 +106,29 @@ module Airwallex
       self
     end
 
+    # Simulate the issuing bank rejecting this dispute's challenge evidence
+    # and advancing it to the next stage
+    #
+    # @param params [Hash] due_at: (required); amount:, comment:,
+    #   documents: (optional)
+    # @return [Airwallex::Dispute] self
+    def simulate_escalate(params = {})
+      response = Airwallex.client.post("#{self.class::SIMULATION_PATH}/#{id}/escalate", params)
+      refresh_from(response)
+      self
+    end
+
+    # Simulate the issuing bank's final decision on this dispute
+    #
+    # @param params [Hash] in_favor_of: ("MERCHANT" or "CUSTOMER",
+    #   required); amount: (optional)
+    # @return [Airwallex::Dispute] self
+    def simulate_resolve(params = {})
+      response = Airwallex.client.post("#{self.class::SIMULATION_PATH}/#{id}/resolve", params)
+      refresh_from(response)
+      self
+    end
+
     # List payment intents related to this dispute
     #
     # @param params [Hash] additional query params (e.g. pagination)

data/lib/airwallex/resources/global_account.rb

@@ -45,9 +45,9 @@ module Airwallex
     # @param params [Hash] account_statement_type: (e.g. "AMAZON"),
     #   registration_info: { agreement:, registered_name:, registered_email:,
     #   registered_address: { address:, city:, state:, postcode:, country: } }
-    # @return [Hash] raw response (the generated letter/document reference)
+    # @return [Hash] symbolized response (the generated letter/document reference)
     def generate_statement_letter(params = {})
-      Airwallex.client.post("#{self.class.resource_path}/#{id}/generate_statement_letter", params)
+      self.class.symbolized_post("#{self.class.resource_path}/#{id}/generate_statement_letter", params)
     end
 
     # List inbound transactions (deposits) received into this account

data/lib/airwallex/resources/issuing_transaction.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Airwallex
+  # Represents a card (Issuing) transaction event.
+  #
+  # This gem currently only implements the sandbox Simulation endpoints for
+  # issuing transactions — creating an authorization, capturing/reversing a
+  # PENDING one, refunding a CAPTURED one, and delivering a 3DS delegation
+  # notification. It does not yet implement the live Issuing resources
+  # (Card, Cardholder) or the live transaction retrieve/list endpoints.
+  # See https://www.airwallex.com/docs/api/simulation/issuing-transactions
+  #
+  # @example Authorize, then capture in full
+  #   txn = Airwallex::IssuingTransaction.simulate_create(
+  #     card_id: "card_123",
+  #     transaction_amount: 25.00,
+  #     transaction_currency: "USD"
+  #   )
+  #   Airwallex::IssuingTransaction.simulate_capture(txn.transaction_id)
+  #
+  # @example Authorize and clear in a single step
+  #   Airwallex::IssuingTransaction.simulate_create(
+  #     card_id: "card_123",
+  #     transaction_amount: 25.00,
+  #     transaction_currency: "USD",
+  #     single_phase: true
+  #   )
+  class IssuingTransaction < APIResource
+    # @return [String] API resource path for simulated issuing transactions
+    def self.resource_path
+      "/api/v1/simulation/issuing"
+    end
+
+    # Simulate a card authorization (or, with single_phase: true, an
+    # authorization cleared in one step)
+    #
+    # @param params [Hash] card_id: (or card_number:), transaction_amount:,
+    #   transaction_currency: (required); single_phase:, auth_code:,
+    #   merchant_category_code:, merchant_info:, transaction_failure_reason:
+    #   (optional)
+    # @return [IssuingTransaction] the resulting transaction — read its
+    #   `transaction_id` to pass to .simulate_capture/.simulate_reverse
+    def self.simulate_create(params = {})
+      response = Airwallex.client.post("#{resource_path}/create", params)
+      new(response)
+    end
+
+    # Simulate capturing a PENDING transaction
+    #
+    # @param transaction_id [String] the `transaction_id` from
+    #   .simulate_create's response
+    # @param params [Hash] merchant_info:, transaction_amount: (optional —
+    #   a partial capture if less than the authorized amount, full amount
+    #   if omitted)
+    # @return [IssuingTransaction]
+    def self.simulate_capture(transaction_id, params = {})
+      response = Airwallex.client.post(
+        "#{resource_path}/card_transaction_lifecycles/#{transaction_id}/capture", params
+      )
+      new(response)
+    end
+
+    # Simulate reversing a PENDING transaction
+    #
+    # @param transaction_id [String] the `transaction_id` from
+    #   .simulate_create's response
+    # @param params [Hash] transaction_amount: (optional — a partial
+    #   reversal if less than the authorized amount, full reversal if
+    #   omitted)
+    # @return [IssuingTransaction]
+    def self.simulate_reverse(transaction_id, params = {})
+      response = Airwallex.client.post(
+        "#{resource_path}/card_transaction_lifecycles/#{transaction_id}/reverse", params
+      )
+      new(response)
+    end
+
+    # Simulate refunding a CAPTURED, not-fully-refunded transaction back to
+    # the card
+    #
+    # @param params [Hash] card_id: (or card_number:), transaction_amount:,
+    #   transaction_currency: (required); merchant_category_code:,
+    #   merchant_info: (optional)
+    # @return [IssuingTransaction]
+    def self.simulate_refund(params = {})
+      response = Airwallex.client.post("#{resource_path}/refund", params)
+      new(response)
+    end
+
+    # Simulate a 3DS delegation-mode notification for a card
+    #
+    # @param params [Hash] card_number: (required); merchant_info: (object,
+    #   optional: acquirer_id:, merchant_category_code:,
+    #   merchant_country_code:, merchant_id:, merchant_name:, merchant_url:)
+    # @return [Hash] raw response
+    def self.simulate_notify_three_ds(params = {})
+      Airwallex.client.post("#{resource_path}/threeds/notify", params)
+    end
+  end
+end

data/lib/airwallex/resources/linked_account.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Airwallex
+  # Represents a Linked Account — a customer's external bank account
+  # authorized for Direct Debit pulls.
+  #
+  # This gem currently only implements the sandbox Simulation endpoints for
+  # the mandate and micro-deposit lifecycle; it does not yet implement the
+  # live create/retrieve/list endpoints. All four actions below return
+  # HTTP 200 with an empty body on success, so they return `true` rather
+  # than a resource instance.
+  # See https://www.airwallex.com/docs/api/simulation/linked-accounts
+  #
+  # MANDATE STATUS LIFECYCLE:
+  #   PROCESSING -> ACTIVE   (simulate_accept_mandate)
+  #   PROCESSING -> INACTIVE (simulate_reject_mandate)
+  #   PROCESSING or ACTIVE -> INACTIVE (simulate_cancel_mandate)
+  #
+  # @example Approve a mandate that's awaiting the customer's bank
+  #   Airwallex::LinkedAccount.simulate_accept_mandate("la_123")
+  class LinkedAccount < APIResource
+    # @return [String] API resource path for simulated linked account actions
+    def self.resource_path
+      "/api/v1/simulation/linked_accounts"
+    end
+
+    # Simulate the mandate transitioning PROCESSING -> ACTIVE
+    #
+    # @param linked_account_id [String]
+    # @return [true]
+    def self.simulate_accept_mandate(linked_account_id)
+      Airwallex.client.post("#{resource_path}/#{linked_account_id}/mandate/accept", {})
+      true
+    end
+
+    # Simulate the mandate transitioning PROCESSING -> INACTIVE
+    #
+    # @param linked_account_id [String]
+    # @return [true]
+    def self.simulate_reject_mandate(linked_account_id)
+      Airwallex.client.post("#{resource_path}/#{linked_account_id}/mandate/reject", {})
+      true
+    end
+
+    # Simulate the mandate transitioning PROCESSING or ACTIVE -> INACTIVE
+    #
+    # @param linked_account_id [String]
+    # @return [true]
+    def self.simulate_cancel_mandate(linked_account_id)
+      Airwallex.client.post("#{resource_path}/#{linked_account_id}/mandate/cancel", {})
+      true
+    end
+
+    # Simulate a failed micro-deposit verification, transitioning the
+    # linked account itself from REQUIRES_ACTION to FAILED
+    #
+    # @param linked_account_id [String]
+    # @return [true]
+    def self.simulate_fail_microdeposits(linked_account_id)
+      Airwallex.client.post("#{resource_path}/#{linked_account_id}/fail_microdeposits", {})
+      true
+    end
+  end
+end

data/lib/airwallex/resources/payment_consent.rb

@@ -33,6 +33,9 @@ module Airwallex
       "/api/v1/pa/payment_consents"
     end
 
+    # Sandbox-only — see https://www.airwallex.com/docs/api/simulation/shopper-actions
+    SIMULATION_SHOPPER_ACTION_PATH = "/api/v1/simulation/pa/shopper_actions"
+
     # Verify this consent (e.g. via a zero/low-value authorization) before
     # it can be used for off-session charges
     #
@@ -64,5 +67,17 @@ module Airwallex
       refresh_from(response)
       self
     end
+
+    # Simulate the shopper completing a redirect/3DS challenge raised
+    # during #verify, using the `url` from the verify response's
+    # next_action
+    #
+    # @param url [String] the redirect URL from #verify's next_action
+    # @return [PaymentConsent] self
+    def simulate_shopper_verify(url:)
+      response = Airwallex.client.post("#{SIMULATION_SHOPPER_ACTION_PATH}/verify", url: url)
+      refresh_from(response)
+      self
+    end
   end
 end