airwallex 0.8.0 → 0.9.0

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/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

data/lib/airwallex/resources/payment_intent.rb

@@ -7,6 +7,9 @@ module Airwallex
     extend APIOperations::List
     include APIOperations::Update
 
+    # Sandbox-only — see https://www.airwallex.com/docs/api/simulation/shopper-actions
+    SIMULATION_SHOPPER_ACTION_PATH = "/api/v1/simulation/pa/shopper_actions"
+
     def self.resource_path
       "/api/v1/pa/payment_intents"
     end
@@ -40,5 +43,28 @@ module Airwallex
       refresh_from(response)
       self
     end
+
+    # Simulate the shopper completing a redirect/3DS challenge raised during
+    # #confirm, using the `url` from the confirm response's next_action
+    #
+    # @param url [String] the redirect URL from #confirm's next_action
+    # @return [PaymentIntent] self
+    def simulate_shopper_pay(url:)
+      response = Airwallex.client.post("#{SIMULATION_SHOPPER_ACTION_PATH}/pay", url: url)
+      refresh_from(response)
+      self
+    end
+
+    # Simulate the shopper abandoning/rejecting a redirect/3DS challenge
+    # raised during #confirm, using the `url` from the confirm response's
+    # next_action
+    #
+    # @param url [String] the redirect URL from #confirm's next_action
+    # @return [PaymentIntent] self
+    def simulate_shopper_reject(url:)
+      response = Airwallex.client.post("#{SIMULATION_SHOPPER_ACTION_PATH}/reject", url: url)
+      refresh_from(response)
+      self
+    end
   end
 end

data/lib/airwallex/resources/pos_terminal.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Airwallex
+  # Represents an in-person (POS) Terminal used for card-present payments.
+  #
+  # This gem currently only implements the sandbox Simulation endpoints for
+  # driving a terminal through a test payment; it does not yet implement the
+  # live terminal create/retrieve/list endpoints.
+  # See https://www.airwallex.com/docs/api/simulation/pos-terminals
+  #
+  # @example Simulate a terminal completing a PaymentIntent
+  #   Airwallex::POSTerminal.simulate_turn_on(terminal_id: "term_123")
+  #   Airwallex::POSTerminal.simulate_confirm_payment_intent(
+  #     terminal_id: "term_123",
+  #     payment_scenario_name: "approve"
+  #   )
+  class POSTerminal < APIResource
+    # @return [String] API resource path for simulated POS terminal actions
+    def self.resource_path
+      "/api/v1/simulation/pa/pos/terminals"
+    end
+
+    # Simulate turning a terminal on
+    #
+    # @param terminal_id [String]
+    # @return [POSTerminal]
+    def self.simulate_turn_on(terminal_id:)
+      response = Airwallex.client.post("#{resource_path}/turn_on", terminal_id: terminal_id)
+      new(response)
+    end
+
+    # Simulate turning a terminal off
+    #
+    # @param terminal_id [String]
+    # @return [POSTerminal]
+    def self.simulate_turn_off(terminal_id:)
+      response = Airwallex.client.post("#{resource_path}/turn_off", terminal_id: terminal_id)
+      new(response)
+    end
+
+    # Simulate generating a terminal activation code
+    #
+    # @param request_id [String]
+    # @return [Hash] raw response (contains the generated activation code)
+    def self.simulate_generate_activation_code(request_id:)
+      Airwallex.client.post("#{resource_path}/generate_activation_code", request_id: request_id)
+    end
+
+    # Simulate a terminal confirming a PaymentIntent under a named test
+    # scenario (see .simulate_payment_scenarios for valid names)
+    #
+    # @param terminal_id [String]
+    # @param payment_scenario_name [String]
+    # @return [POSTerminal]
+    def self.simulate_confirm_payment_intent(terminal_id:, payment_scenario_name:)
+      response = Airwallex.client.post(
+        "#{resource_path}/confirm_payment_intent",
+        terminal_id: terminal_id,
+        payment_scenario_name: payment_scenario_name
+      )
+      new(response)
+    end
+
+    # List the test scenario names available to .simulate_confirm_payment_intent
+    #
+    # @return [Array, Hash] raw response
+    def self.simulate_payment_scenarios
+      Airwallex.client.get("#{resource_path}/payment_scenarios")
+    end
+  end
+end

data/lib/airwallex/resources/rfi.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Airwallex
+  # Represents a Request for Information (RFI) — a compliance question
+  # Airwallex raises against your account (KYC, an ongoing KYC review, a
+  # cardholder, a transaction, payment enablement, or merchant risk).
+  #
+  # This gem currently only implements the sandbox Simulation endpoints
+  # (there is no live create — real RFIs originate from Airwallex's own
+  # compliance review, same as Dispute). See
+  # https://www.airwallex.com/docs/api/simulation/request-for-information
+  #
+  # @example Raise a KYC RFI, then close it
+  #   rfi = Airwallex::RFI.simulate_create(
+  #     type: "KYC",
+  #     questions: [{ answer: { type: "TEXT" } }]
+  #   )
+  #   rfi.simulate_close
+  class RFI < APIResource
+    # @return [String] API resource path for simulated RFI actions
+    def self.resource_path
+      "/api/v1/simulation/rfis"
+    end
+
+    # Simulate Airwallex raising an RFI
+    #
+    # @param params [Hash] type: (required, one of "KYC", "KYC_ONGOING",
+    #   "CARDHOLDER", "TRANSACTION", "PAYMENT_ENABLEMENT",
+    #   "MERCHANT_RISK"); questions: (required, array of
+    #   { answer: { type: }, sources: [] })
+    # @return [RFI]
+    def self.simulate_create(params = {})
+      response = Airwallex.client.post("#{resource_path}/create", params)
+      new(response)
+    end
+
+    # Simulate closing an RFI
+    #
+    # @param rfi_id [String]
+    # @return [RFI]
+    def self.simulate_close(rfi_id)
+      response = Airwallex.client.post("#{resource_path}/#{rfi_id}/close", {})
+      new(response)
+    end
+
+    # Simulate a follow-up on an RFI — reopen an existing answered question
+    # (by id) or append a new one
+    #
+    # @param rfi_id [String]
+    # @param params [Hash] questions: (required, array of
+    #   { id: } or { answer: { type: }, sources: [] })
+    # @return [RFI]
+    def self.simulate_follow_up(rfi_id, params = {})
+      response = Airwallex.client.post("#{resource_path}/#{rfi_id}/follow_up", params)
+      new(response)
+    end
+
+    # Simulate closing this RFI
+    #
+    # @return [RFI] self
+    def simulate_close
+      response = Airwallex.client.post("#{self.class.resource_path}/#{id}/close", {})
+      refresh_from(response)
+      self
+    end
+
+    # Simulate a follow-up on this RFI
+    #
+    # @param params [Hash] questions: (required)
+    # @return [RFI] self
+    def simulate_follow_up(params = {})
+      response = Airwallex.client.post("#{self.class.resource_path}/#{id}/follow_up", params)
+      refresh_from(response)
+      self
+    end
+  end
+end

data/lib/airwallex/resources/transfer.rb

@@ -6,6 +6,9 @@ module Airwallex
     extend APIOperations::Retrieve
     extend APIOperations::List
 
+    # Sandbox-only — see https://www.airwallex.com/docs/api/simulation/transfers
+    SIMULATION_PATH = "/api/v1/simulation/transfers"
+
     def self.resource_path
       "/api/v1/transfers"
     end
@@ -19,5 +22,38 @@ module Airwallex
       refresh_from(response)
       self
     end
+
+    # Simulate this transfer's status advancing one step. The standard
+    # lifecycle is SCHEDULED -> PROCESSING -> SENT -> PAID, progressed one
+    # step at a time; OVERDUE, FAILED, and CANCELLED can be jumped to
+    # directly.
+    #
+    # @param next_status [String] one of "OVERDUE", "PROCESSING", "SENT",
+    #   "PAID", "FAILED", "CANCELLED"
+    # @param failure_type [String, nil] failure reason code, only
+    #   meaningful when next_status is "FAILED"
+    # @return [Transfer] self
+    def simulate_transition(next_status:, failure_type: nil)
+      params = { next_status: next_status }
+      params[:failure_type] = failure_type if failure_type
+      response = Airwallex.client.post("#{SIMULATION_PATH}/#{id}/transition", params)
+      refresh_from(response)
+      self
+    end
+
+    # Simulate a transfer's status advancing one step
+    #
+    # @param transfer_id [String]
+    # @param next_status [String] one of "OVERDUE", "PROCESSING", "SENT",
+    #   "PAID", "FAILED", "CANCELLED"
+    # @param failure_type [String, nil] failure reason code, only
+    #   meaningful when next_status is "FAILED"
+    # @return [Transfer]
+    def self.simulate_transition(transfer_id, next_status:, failure_type: nil)
+      params = { next_status: next_status }
+      params[:failure_type] = failure_type if failure_type
+      response = Airwallex.client.post("#{SIMULATION_PATH}/#{transfer_id}/transition", params)
+      new(response)
+    end
   end
 end

data/lib/airwallex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Airwallex
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/airwallex.rb

@@ -48,6 +48,13 @@ require_relative "airwallex/resources/connected_account"
 require_relative "airwallex/resources/account_amendment"
 require_relative "airwallex/resources/funds_split"
 require_relative "airwallex/resources/charge"
+require_relative "airwallex/resources/deposit"
+require_relative "airwallex/resources/issuing_transaction"
+require_relative "airwallex/resources/cardholder"
+require_relative "airwallex/resources/linked_account"
+require_relative "airwallex/resources/account_offboarding"
+require_relative "airwallex/resources/rfi"
+require_relative "airwallex/resources/pos_terminal"
 
 module Airwallex
   class << self