paystack_sdk 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a47ad018e13e2e59c645d1834e38ff503c74573670e90fd3e286ff090cc0768d
-  data.tar.gz: 3ff34906416d4d3d33315af10537113fbc64189b002a95c5d27b6df32b9c5592
+  metadata.gz: 8893378c4721f9f126d73b888dd539060c93058488b49c92833183b819d06023
+  data.tar.gz: a787c8b3b413e4171c3574e38dc519c0b2eed3df09776b383a0b20fc259bd75a
 SHA512:
-  metadata.gz: d041e1cb40107e93fb39e27220c5f33c52baa8e6167a7812c907a1272311bfa7a782f5b1e9e358afa8e5900c56408f62892e35b5b4b3e71fb37b44f1228aa488
-  data.tar.gz: e1f0f1ffb505ad4a0b6c3c8944ada4e4fd61d9ab29cf7f87551c8697ba606f94bd975068396d3ca5b2226d24ccba38e7f431fab2204b177ccd5da5a1f97176fb
+  metadata.gz: a205e604c23fc3ca07a1ad7096ef920c9587fc04d322da9c40e6e00bd92870c2d833f554b275c6651a3f1aa07c23d56e2cb77fc41d2a02005e5848f8686942a4
+  data.tar.gz: d5cbb5b6bfefe710024e1cba4dcaa2097577b4df3f17e001199b281945cb8d417000c89a0fd5292d8ca8444272d55313f010b2acfadc130246372433f0465166

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-10-09
+
+### Added
+
+- `client.splits` for Paystack's Transaction Splits API: `create`, `list`, `fetch`, `update`, `add_subaccount` (also updates an existing subaccount's share) and `remove_subaccount`, generated from the OpenAPI spec. `list` sends `perPage` (the API ignores the spec's `per_page`); `fetch` takes a split code or numeric ID; `add_subaccount` requires `subaccount` and `share`, and `remove_subaccount` requires `subaccount`, as the docs and test API do.
+- `disputes` (new, generated from Paystack's OpenAPI spec): `list`, `fetch`, `list_transaction`, `update`, `add_evidence`, `fetch_upload_url`, `resolve` and `export`. `fetch_upload_url` takes `upload_filename`, which Paystack documents and the test API honours although the OpenAPI spec omits it.
+- `Subaccounts` (`client.subaccounts`): `create`, `list`, `fetch(id_or_code:)` and `update(id_or_code:, ...)`, generated from Paystack's OpenAPI spec. The bank is sent as `bank_code`, as Paystack's docs name it (the spec says `settlement_bank`; the test API reads both and prefers `bank_code`). `list(active:)` takes `1` or `0`: Paystack reads `true` as inactive.
+- `Plans` (`client.plans`): `create`, `list`, `fetch(id_or_code:)` and `update(id_or_code:, ...)`, generated from Paystack's OpenAPI spec. `interval` accepts `hourly` and `quarterly` as well as the spec's five values (the test API accepts all seven; the spec omits two). `update` takes `update_existing_subscriptions`, which Paystack documents and the test API validates although the spec omits it; leave it out and Paystack applies the change to existing subscriptions. `list(status:)` is documented by Paystack but absent from the spec.
+- `settlements` (new): `list(per_page:, page:, from:, to:)` for `GET /settlement` and `transactions(id:)` for `GET /settlement/{id}/transactions`. `from` and `to` are in Paystack's docs but not the spec; the test API validates them.
+- `Balances` (`client.balances`): `fetch` and `ledger(per_page:, page:, from:, to:)`, generated from Paystack's OpenAPI spec and read-only (GET). `fetch` returns one entry per currency with the balance in the currency's subunit (pesewas for GHS). Paystack's docs have no Balance page; the two operations sit on the Transfers Control page and the behaviour was confirmed against the test API.
+- `Subscriptions` (`client.subscriptions`): `create`, `list`, `fetch(id_or_code:)`, `enable(code:, token:)`, `disable(code:, token:)`, `generate_update_link(code:)` and `send_update_link(code:)`, generated from Paystack's OpenAPI spec. `list` filters by `plan_id:` and `customer_id:` (sent as `plan` and `customer`): the test API matches numeric IDs only. `start_date` is checked as ISO 8601 before sending, since the test API refuses an invalid one but still creates the subscription.
+- `DedicatedVirtualAccounts` (`client.dedicated_virtual_accounts`), generated from Paystack's OpenAPI spec: `create`, `assign`, `list`, `fetch(dedicated_account_id:)`, `requery`, `deactivate(dedicated_account_id:)`, `add_split`, `remove_split` and `fetch_bank_providers`.
+- `PaymentRequests` (`client.payment_requests`), generated from Paystack's OpenAPI spec: `create`, `list`, `fetch(id_or_code:)`, `update(id_or_code:)`, `verify(code:)`, `notify(code:)`, `totals`, `finalize(id_or_code:, send_notification: nil)` and `archive(id_or_code:)`. Checked against the Paystack test API, `create` does not require `amount` when `line_items` or `tax` are given (the spec says it is required), takes `metadata` as a Hash and `redirect_url` (both docs-only), and accepts a date as `due_date`; `list` filters by the numeric `customer_id:` and takes `include_archive:`.
+- `bin/paystack-scaffold` applies `required: true` from body-field entries in `spec/support/paystack_contract_exceptions.yml`, as it already did for query parameters.
+- `bin/paystack-scaffold` applies `enum:` from body-field entries in `spec/support/paystack_contract_exceptions.yml`, as it already did for query parameters.
+
+### Fixed
+
+- `bin/paystack-scaffold` now adds a resource's `Client` accessor above `Client`'s private helpers, where it is public, instead of at the end of the class. It also finds the docs anchor of an operation whose cURL sample on the docs page calls another path (Split Dedicated Account Transaction), and corrects the `@see` link of `customers.direct_debit_activation_charge` to `#directdebit-activation-charge`.
+
 ## [0.2.0] - 2026-10-09
 
 ### Breaking

data/README.md

@@ -41,6 +41,36 @@ The `paystack_sdk` gem provides a simple and intuitive interface for interacting
   - [Refunds](#refunds)
     - [Create a Refund](#create-a-refund)
     - [Fetch, List and Retry Refunds](#fetch-list-and-retry-refunds)
+  - [Settlements](#settlements)
+  - [Splits](#splits)
+    - [Create a Split](#create-a-split)
+    - [List, Fetch and Update Splits](#list-fetch-and-update-splits)
+    - [Add, Update or Remove a Subaccount](#add-update-or-remove-a-subaccount)
+  - [Disputes](#disputes)
+    - [List and Fetch Disputes](#list-and-fetch-disputes)
+    - [Answer a Dispute](#answer-a-dispute)
+  - [Subaccounts](#subaccounts)
+    - [Create a Subaccount](#create-a-subaccount)
+    - [List and Fetch Subaccounts](#list-and-fetch-subaccounts)
+    - [Update a Subaccount](#update-a-subaccount)
+  - [Balances](#balances)
+  - [Plans](#plans)
+    - [Create a Plan](#create-a-plan)
+    - [List and Fetch Plans](#list-and-fetch-plans)
+    - [Update a Plan](#update-a-plan)
+  - [Subscriptions](#subscriptions)
+    - [Create a Subscription](#create-a-subscription)
+    - [List and Fetch Subscriptions](#list-and-fetch-subscriptions)
+    - [Enable or Disable a Subscription](#enable-or-disable-a-subscription)
+    - [Let the Customer Update Their Card](#let-the-customer-update-their-card)
+  - [Dedicated Virtual Accounts](#dedicated-virtual-accounts)
+    - [Create or Assign an Account](#create-or-assign-an-account)
+    - [List, Fetch, Requery and Deactivate](#list-fetch-requery-and-deactivate)
+    - [Split Payments on an Account](#split-payments-on-an-account)
+  - [Payment Requests](#payment-requests)
+    - [Create a Payment Request](#create-a-payment-request)
+    - [List, Fetch and Verify Payment Requests](#list-fetch-and-verify-payment-requests)
+    - [Update, Finalize, Notify and Archive](#update-finalize-notify-and-archive)
   - [Response Handling](#response-handling)
     - [Working with Response Objects](#working-with-response-objects)
     - [Accessing the Original Response](#accessing-the-original-response)
@@ -894,6 +924,445 @@ paystack.refunds.retry_with_customer_details(
 ```
 
 Paystack's docs also list a `currency` filter on the list endpoint, but the test API returned the same refunds for every currency, so the SDK does not offer it.
+### Settlements
+
+Settlements are the payouts Paystack makes to your bank account. Use them to reconcile what was paid out against the transactions behind each payout.
+
+```ruby
+# List settlements (Paystack's defaults apply: 50 per page, page 1)
+paystack.settlements.list
+paystack.settlements.list(per_page: 20, page: 2)
+
+# Only settlements within a date range (a date or an ISO 8601 timestamp)
+paystack.settlements.list(from: "2025-01-01", to: "2025-01-31T23:59:59Z")
+
+# The transactions that make up one settlement
+paystack.settlements.transactions(id: 3090024)
+```
+
+Paystack's docs also list `status` and `subaccount` filters on the list endpoint, but they are not in its OpenAPI spec and the SDK does not offer them yet: the test account has no settlements, so whether they filter could not be checked. `transactions` takes no filters or pagination for the same reason.
+
+### Splits
+
+A transaction split shares the settlement for a payment between your payout account and one or more subaccounts (`ACCT_...`). Create the split once, then pass its `split_code` when you initialize a transaction or create a charge.
+
+#### Create a Split
+
+```ruby
+# type is "percentage" (each share is a percentage) or "flat" (each share is an amount in the
+# currency's subunit: kobo, pesewas, cents). currency must be enabled on your integration.
+response = paystack.splits.create(
+  name: "Halfsies",
+  type: "percentage",
+  currency: "GHS",
+  subaccounts: [{subaccount: "ACCT_6uujpqtzmnufzkw", share: 50}],
+  # Optional: who pays Paystack's fee. One of "account", "subaccount", "all-proportional" or "all"
+  # (Paystack's default). "subaccount" also needs bearer_subaccount, a subaccount in the split.
+  bearer_type: "all-proportional"
+)
+
+split_code = response.data.split_code if response.success? # e.g. "SPL_RcScyW5jp2"
+```
+
+#### List, Fetch and Update Splits
+
+```ruby
+# List, with Paystack's page pagination (default 50 per page) and filters
+paystack.splits.list(per_page: 20, page: 1, active: true)
+paystack.splits.list(name: "Halfsies", subaccount_code: "ACCT_6uujpqtzmnufzkw", from: "2025-01-01", to: "2025-04-30")
+
+# Fetch by numeric ID or by split code
+paystack.splits.fetch(id: 2703655)
+paystack.splits.fetch(id: "SPL_RcScyW5jp2")
+
+# Update (by numeric ID only: Paystack refuses a split code here)
+paystack.splits.update(id: 2703655, active: false)
+paystack.splits.update(id: 2703655, bearer_type: "subaccount", bearer_subaccount: "ACCT_6uujpqtzmnufzkw")
+```
+
+#### Add, Update or Remove a Subaccount
+
+```ruby
+# Adds the subaccount, or changes its share if it is already in the split (numeric split ID)
+paystack.splits.add_subaccount(id: 2703655, subaccount: "ACCT_eg4sob4590pq9vb", share: 20)
+
+paystack.splits.remove_subaccount(id: 2703655, subaccount: "ACCT_eg4sob4590pq9vb")
+```
+
+### Disputes
+
+Disputes (chargebacks) are filed against your transactions by customers or their banks. Listing and fetching are read-only. `update`, `add_evidence` and `resolve` change a real dispute, so call them only when you mean to answer it.
+
+#### List and Fetch Disputes
+
+```ruby
+# List, with Paystack's page pagination; filter by status, transaction ID or date range.
+# status is one of awaiting-merchant-feedback, awaiting-bank-feedback, pending, resolved
+response = paystack.disputes.list(status: "awaiting-merchant-feedback", per_page: 20, from: "2025-01-01", to: "2025-04-30")
+response.data.each { |dispute| puts "#{dispute.id}: #{dispute.status}" } if response.success?
+
+# Fetch one dispute, or every dispute filed for a transaction
+paystack.disputes.fetch(id: 2867)
+paystack.disputes.list_transaction(id: 5991760)
+
+# Export disputes. Paystack answers 404 "No disputes found" when there is nothing to export.
+paystack.disputes.export(from: "2025-01-01", to: "2025-04-30")
+```
+
+#### Answer a Dispute
+
+```ruby
+# 1. Get a signed URL, upload the evidence file to it, and keep the returned file name
+upload = paystack.disputes.fetch_upload_url(id: 2867, upload_filename: "receipt.pdf")
+upload.data.signedUrl   # upload your file to this URL
+upload.data.fileName    # pass this as uploaded_filename
+
+# 2. Add evidence
+paystack.disputes.add_evidence(
+  id: 2867,
+  customer_email: "ama@example.com",
+  customer_name: "Ama Mensah",
+  customer_phone: "0802345167",
+  service_details: "Tithe payment for March",
+  delivery_date: "2025-03-31"
+)
+
+# 3. Accept (with a refund) or decline. refund_amount is in the smallest currency unit.
+# It is `resolve` because `resolve` would shadow a method Ruby already has.
+paystack.disputes.resolve(
+  id: 2867,
+  resolution: "merchant-accepted", # or "declined"
+  message: "Refunded at the customer's request",
+  refund_amount: 50_000,
+  uploaded_filename: upload.data.fileName
+)
+
+# Or change the refund amount and attachment without resolving
+paystack.disputes.update(id: 2867, refund_amount: 50_000, uploaded_filename: upload.data.fileName)
+```
+
+### Subaccounts
+
+A subaccount is a settlement account that receives its share of the payments made to it, such as one per branch or partner. Pass its code (`ACCT_...`) as `subaccount` when you charge or initialize a transaction.
+
+#### Create a Subaccount
+
+```ruby
+# bank_code comes from paystack.banks.list (country: "ghana" lists GHS banks and the
+# MTN, VOD and ATL mobile money codes). account_number is a string: leading zeros matter.
+# percentage_charge is the percentage the main account keeps from each payment (0 to 100).
+response = paystack.subaccounts.create(
+  business_name: "Grace Chapel Accra",
+  bank_code: "MTN",
+  account_number: "0551234987",
+  percentage_charge: 2.5,
+  description: "Giving for the Accra branch",
+  primary_contact_name: "Ama Mensah",
+  primary_contact_email: "finance@gracechapel.example",
+  primary_contact_phone: "0551234987"
+)
+
+if response.success?
+  puts "Created #{response.data.subaccount_code} for #{response.data.account_name}"
+else
+  puts "Error: #{response.error_message}" # e.g. "Account details are invalid"
+end
+```
+
+Paystack's docs name the bank field `bank_code`; its OpenAPI spec calls it `settlement_bank`. The API reads both and prefers `bank_code`, so the SDK sends `bank_code`.
+
+#### List and Fetch Subaccounts
+
+```ruby
+# Paystack's page pagination (default 50 per page)
+paystack.subaccounts.list(per_page: 20, page: 2)
+
+# Without active, the test API lists only active subaccounts. active: 0 lists the inactive
+# ones. Paystack reads any value other than 1, true included, as inactive, so pass 1 or 0.
+paystack.subaccounts.list(active: 0)
+
+# Fetch by subaccount code or numeric ID
+paystack.subaccounts.fetch(id_or_code: "ACCT_6uujpqtzmnufzkw")
+```
+
+#### Update a Subaccount
+
+```ruby
+# Send only what changes
+paystack.subaccounts.update(id_or_code: "ACCT_6uujpqtzmnufzkw", percentage_charge: 3)
+
+# Deactivate (or reactivate with active: true)
+paystack.subaccounts.update(id_or_code: "ACCT_6uujpqtzmnufzkw", active: false)
+
+# A new settlement account: Paystack needs bank_code and account_number together
+paystack.subaccounts.update(id_or_code: "ACCT_6uujpqtzmnufzkw", bank_code: "040100", account_number: "1234567890123")
+```
+
+### Balances
+
+Read-only. Amounts are integers in the currency's subunit (pesewas for GHS, kobo for NGN), so `48400` is GHS 484.00. Paystack documents both operations on its Transfers Control page.
+
+```ruby
+# One entry per currency your integration holds
+response = paystack.balances.fetch
+response.data.first.currency # => "GHS"
+response.data.first.balance  # => 48400
+# Iterating (each, map) yields plain hashes with string keys
+response.data.each { |balance| puts "#{balance["currency"]}: #{balance["balance"]}" }
+
+# Every pay-in and pay-out, newest first. `difference` is the signed change in the subunit
+# (-2500 for a refund), `balance` the running balance after it, and `model_responsible`
+# says what caused it ("Transaction", "Refund", "Transfer", ...).
+ledger = paystack.balances.ledger(per_page: 20, page: 1)
+ledger.data.each { |entry| puts "#{entry["createdAt"]} #{entry["model_responsible"]} #{entry["difference"]}" }
+ledger.meta # => total, skipped, perPage, page, pageCount (50 per page by default)
+
+# Date filters work by calendar day (the time part is ignored). `to` includes that day;
+# `from` does not, so from: Date.new(2026, 10, 8) returns entries after 8 October.
+paystack.balances.ledger(from: Date.new(2026, 10, 1), to: Date.new(2026, 10, 31))
+```
+
+### Plans
+
+A plan is a recurring charge definition: an amount, an interval and a currency. Customers are subscribed to a plan to be charged on that schedule. Paystack does not let you delete a plan.
+
+#### Create a Plan
+
+```ruby
+# amount is in the subunit of the currency (pesewas for GHS). Paystack's minimum is 2 GHS.
+# interval is one of hourly, daily, weekly, monthly, quarterly, biannually (every 6 months)
+# or annually, in lowercase. currency defaults to the integration's currency.
+response = paystack.plans.create(
+  name: "Monthly tithe",
+  amount: 20_000,
+  interval: "monthly",
+  currency: "GHS",
+  description: "Standing tithe",
+  send_invoices: false,
+  send_sms: false,
+  invoice_limit: 12
+)
+
+if response.success?
+  puts "Created #{response.data.plan_code}"
+else
+  puts "Error: #{response.error_message}" # e.g. "Invalid interval selected"
+end
+```
+
+`send_invoices` and `send_sms` are booleans (Paystack's docs call `send_sms` a string; the API refuses anything that is not a boolean).
+
+#### List and Fetch Plans
+
+```ruby
+paystack.plans.list(per_page: 20, page: 1)
+
+# Filter by interval, amount (in the subunit) or a date range
+paystack.plans.list(interval: "monthly", amount: 20_000)
+paystack.plans.list(from: "2026-01-01", to: "2026-12-31")
+
+# Fetch by plan code or numeric ID
+paystack.plans.fetch(id_or_code: "PLN_gx2wn530m0i3w3m")
+```
+
+#### Update a Plan
+
+```ruby
+# Send only what changes
+paystack.plans.update(id_or_code: "PLN_gx2wn530m0i3w3m", name: "Monthly tithe (renamed)")
+
+# By default Paystack applies the change to the plan's existing subscriptions too. Pass
+# update_existing_subscriptions: false so that only new subscriptions use the new values.
+paystack.plans.update(id_or_code: "PLN_gx2wn530m0i3w3m", amount: 25_000, update_existing_subscriptions: false)
+```
+
+The response carries a message only, for example `"Plan updated. 1 subscription(s) affected"`.
+### Subscriptions
+
+A subscription charges a customer's saved card on a plan's schedule. The customer needs a reusable card authorization (from an earlier successful card payment), and the plan is created in your Paystack dashboard or through the Plans API.
+
+#### Create a Subscription
+
+```ruby
+# customer: the customer's email or customer code. plan: the plan code (PLN_...).
+# authorization: which of the customer's saved cards to charge (AUTH_...); without it Paystack
+# uses the customer's most recent authorization. It must belong to this customer.
+# start_date: the date of the first debit, a Time, Date or ISO 8601 string. On the test API it
+# becomes next_payment_date (2027-01-15T10:00:00Z here), and the schedule follows the plan's interval.
+response = paystack.subscriptions.create(
+  customer: "CUS_xnxdt6s1zg1f4nx",
+  plan: "PLN_gx2wn530m0i3w3m",
+  authorization: "AUTH_6tmt288t0o",
+  start_date: Time.utc(2027, 1, 15, 10)
+)
+
+if response.success?
+  # Keep both: enable and disable need the code and the email token
+  puts "#{response.data.subscription_code} #{response.data.email_token}"
+else
+  puts "Error: #{response.error_message}" # e.g. "This subscription is already in place."
+end
+```
+
+A customer can hold one active subscription per plan. The SDK checks that `start_date` is ISO 8601 before sending it: on the test API, an invalid `start_date` is refused with a 400 but still leaves an active subscription with no payment date behind.
+
+#### List and Fetch Subscriptions
+
+```ruby
+# Filters take numeric IDs: the plan and customer codes match nothing
+paystack.subscriptions.list(plan_id: 4298026, customer_id: 406976740, per_page: 20, page: 1)
+
+# Created within a window (Time, Date or ISO 8601 string)
+paystack.subscriptions.list(from: Date.new(2026, 10, 1), to: Time.now)
+
+# Fetch by subscription code or numeric ID
+paystack.subscriptions.fetch(id_or_code: "SUB_vsyqdmlzble3uii")
+```
+
+#### Enable or Disable a Subscription
+
+```ruby
+# token is the subscription's email_token, returned by create, list and fetch
+paystack.subscriptions.disable(code: "SUB_vsyqdmlzble3uii", token: "d7gofp6yppn3qz7")
+# => data.status "non-renewing"
+
+paystack.subscriptions.enable(code: "SUB_vsyqdmlzble3uii", token: "d7gofp6yppn3qz7")
+```
+
+Disabling answers with `data.status` `non-renewing`, and fetch shows the same status. On the test API a disabled subscription that had never been charged could not be enabled again ("Subscription has been cancelled, and cannot be reactivated").
+
+#### Let the Customer Update Their Card
+
+```ruby
+# A link to a Paystack page where the customer changes the card on the subscription
+paystack.subscriptions.generate_update_link(code: "SUB_vsyqdmlzble3uii").data.link
+
+# Or have Paystack email the customer that link
+paystack.subscriptions.send_update_link(code: "SUB_vsyqdmlzble3uii")
+```
+
+Both take the subscription code; the numeric ID is not found.
+### Dedicated Virtual Accounts
+
+A dedicated virtual account is a bank account number Paystack issues to one of your customers, so they can pay you by bank transfer. Paystack's docs offer it to Nigerian and Ghanaian businesses (`NGN` and `GHS`), and it has to be enabled for your business first: until it is, every call returns an unsuccessful response with status 403 and the message "Dedicated NUBAN is not available for your business".
+
+#### Create or Assign an Account
+
+```ruby
+# Which banks can issue an account for your integration (e.g. "wema-bank", "titan-paystack")
+paystack.dedicated_virtual_accounts.fetch_bank_providers
+
+# For a customer you already created (their code or ID)
+response = paystack.dedicated_virtual_accounts.create(customer: "CUS_xnxdt6s1zg1f4nx", preferred_bank: "wema-bank")
+
+if response.success?
+  puts "#{response.data.account_number} at #{response.data.bank.name}"
+else
+  puts "Error: #{response.error_message}"
+end
+
+# Or create the customer, validate them and assign an account in one call. Paystack's docs
+# show the reply "Assign dedicated account in progress", with no account in it.
+paystack.dedicated_virtual_accounts.assign(
+  email: "ama@example.com",
+  first_name: "Ama",
+  last_name: "Mensah",
+  phone: "+2348100000000",
+  preferred_bank: "wema-bank",
+  country: "NG"
+)
+```
+
+#### List, Fetch, Requery and Deactivate
+
+```ruby
+paystack.dedicated_virtual_accounts.list(active: true, currency: "NGN", provider_slug: "wema-bank")
+
+# By the account's numeric ID
+paystack.dedicated_virtual_accounts.fetch(dedicated_account_id: 1234553)
+
+# Ask Paystack to check the account for transfers it has not recorded yet
+paystack.dedicated_virtual_accounts.requery(account_number: "1234567890", provider_slug: "wema-bank", date: Date.new(2026, 10, 9))
+
+paystack.dedicated_virtual_accounts.deactivate(dedicated_account_id: 1234553)
+```
+
+#### Split Payments on an Account
+
+```ruby
+# Send payments into the account through a split (or a single subaccount:)
+paystack.dedicated_virtual_accounts.add_split(account_number: "0033322211", split_code: "SPL_e7jnRLtzla")
+
+# And stop splitting them
+paystack.dedicated_virtual_accounts.remove_split(account_number: "0033322211")
+```
+
+`create` and `assign` also take `split_code:` or `subaccount:` to set a split when the account is made.
+
+### Payment Requests
+
+A payment request is an invoice Paystack sends to a customer, who pays it online. Amounts are in the subunit (pesewas, kobo, cents).
+
+#### Create a Payment Request
+
+```ruby
+# customer is a customer code (CUS_...) or ID. Give line_items and tax, each an Array of Hashes,
+# and Paystack adds them up (2 x 2000 + 300 = 4300 here); give amount instead when you have none.
+response = paystack.payment_requests.create(
+  customer: "CUS_p6i0reogc8ulu1n",
+  currency: "GHS",
+  description: "Harvest thanksgiving pledge",
+  line_items: [{name: "Pledge", amount: 2000, quantity: 2}],
+  tax: [{name: "Levy", amount: 300}],
+  due_date: Date.new(2026, 12, 31), # a Date, a Time or an ISO 8601 string
+  metadata: {branch: "Osu"},        # a Hash; Paystack refuses a JSON string here
+  draft: true                       # a draft is not sent; finalize it later
+)
+
+if response.success?
+  puts "Created #{response.data.request_code} for #{response.data.amount}"
+else
+  puts "Error: #{response.error_message}"
+end
+```
+
+Paystack's docs say it emails the customer when a request is created, unless you pass `draft: true` or `send_notification: false`. Without `amount`, `line_items` or `tax`, Paystack refuses anything but a draft ("Amount was not passed or could not be extrapolated from line items.").
+
+#### List, Fetch and Verify Payment Requests
+
+```ruby
+# customer_id is the numeric customer ID (Paystack ignores a CUS_ code here)
+paystack.payment_requests.list(customer_id: 407172149, status: "pending", per_page: 20)
+
+# Archived requests are left out unless you pass include_archive: true. Paystack includes them
+# whenever the parameter is sent, even as false, so leave it out rather than passing false.
+paystack.payment_requests.list(include_archive: true)
+
+# Fetch by numeric ID or PRQ_ code
+paystack.payment_requests.fetch(id_or_code: "PRQ_7w7dpecncnebg7e")
+
+# Verify takes the PRQ_ code only, and only once the request is no longer a draft
+paystack.payment_requests.verify(code: "PRQ_7w7dpecncnebg7e")
+
+# Pending, successful and total amounts per currency
+paystack.payment_requests.totals
+```
+
+#### Update, Finalize, Notify and Archive
+
+```ruby
+# Send only what changes; new line_items and tax recompute the amount
+paystack.payment_requests.update(id_or_code: "PRQ_7w7dpecncnebg7e", due_date: "2027-01-31")
+
+# Finalize a draft. Paystack emails the customer unless send_notification is false.
+paystack.payment_requests.finalize(id_or_code: "PRQ_7w7dpecncnebg7e", send_notification: false)
+
+# Email the customer a reminder
+paystack.payment_requests.notify(code: "PRQ_7w7dpecncnebg7e")
+
+# Archive: it no longer shows up in list or verify
+paystack.payment_requests.archive(id_or_code: "PRQ_7w7dpecncnebg7e")
+```
 
 ### Response Handling
 

data/lib/paystack_sdk/client.rb

@@ -8,6 +8,15 @@ require_relative "resources/banks"
 require_relative "resources/charges"
 require_relative "resources/miscellaneous"
 require_relative "resources/refunds"
+require_relative "resources/settlements"
+require_relative "resources/splits"
+require_relative "resources/disputes"
+require_relative "resources/subaccounts"
+require_relative "resources/balances"
+require_relative "resources/plans"
+require_relative "resources/subscriptions"
+require_relative "resources/dedicated_virtual_accounts"
+require_relative "resources/payment_requests"
 require_relative "utils/connection_utils"
 
 module PaystackSdk
@@ -173,6 +182,78 @@ module PaystackSdk
       @refunds ||= Resources::Refunds.new(@connection)
     end
 
+    # Provides access to the `Settlements` resource.
+    #
+    # @return [PaystackSdk::Resources::Settlements] An instance of the
+    #  `Settlements` resource.
+    def settlements
+      @settlements ||= Resources::Settlements.new(@connection)
+    end
+
+    # Provides access to the `Splits` resource.
+    #
+    # @return [PaystackSdk::Resources::Splits] An instance of the
+    #  `Splits` resource.
+    def splits
+      @splits ||= Resources::Splits.new(@connection)
+    end
+
+    # Provides access to the `Disputes` resource.
+    #
+    # @return [PaystackSdk::Resources::Disputes] An instance of the
+    #  `Disputes` resource.
+    def disputes
+      @disputes ||= Resources::Disputes.new(@connection)
+    end
+
+    # Provides access to the `Subaccounts` resource.
+    #
+    # @return [PaystackSdk::Resources::Subaccounts] An instance of the
+    #  `Subaccounts` resource.
+    def subaccounts
+      @subaccounts ||= Resources::Subaccounts.new(@connection)
+    end
+
+    # Provides access to the `Balances` resource.
+    #
+    # @return [PaystackSdk::Resources::Balances] An instance of the
+    #  `Balances` resource.
+    def balances
+      @balances ||= Resources::Balances.new(@connection)
+    end
+
+    # Provides access to the `Plans` resource.
+    #
+    # @return [PaystackSdk::Resources::Plans] An instance of the
+    #  `Plans` resource.
+    def plans
+      @plans ||= Resources::Plans.new(@connection)
+    end
+
+    # Provides access to the `Subscriptions` resource.
+    #
+    # @return [PaystackSdk::Resources::Subscriptions] An instance of the
+    #  `Subscriptions` resource.
+    def subscriptions
+      @subscriptions ||= Resources::Subscriptions.new(@connection)
+    end
+
+    # Provides access to the `DedicatedVirtualAccounts` resource.
+    #
+    # @return [PaystackSdk::Resources::DedicatedVirtualAccounts] An instance of the
+    #  `DedicatedVirtualAccounts` resource.
+    def dedicated_virtual_accounts
+      @dedicated_virtual_accounts ||= Resources::DedicatedVirtualAccounts.new(@connection)
+    end
+
+    # Provides access to the `PaymentRequests` resource.
+    #
+    # @return [PaystackSdk::Resources::PaymentRequests] An instance of the
+    #  `PaymentRequests` resource.
+    def payment_requests
+      @payment_requests ||= Resources::PaymentRequests.new(@connection)
+    end
+
     private
 
     # The secret key a connection sends, read from its Authorization header.

data/lib/paystack_sdk/resources/balances.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Generated by bin/paystack-scaffold from Paystack's OpenAPI spec (PaystackOSS/openapi@d9d444d).
+# Do not edit by hand: regenerate it with `bin/paystack-scaffold Balance`. Hand-written extras go in lib/paystack_sdk/resources/extensions/balances.rb.
+# scaffold-digest: 65e146fbcd39c274107a8234988e1b3b51e3c58a5e74d7c4b0bf9c4f084a9b83
+
+require_relative "base"
+
+module PaystackSdk
+  module Resources
+    # Balance operations.
+    class Balances < PaystackSdk::Resources::Base
+      # Ruby keyword => the parameter name Paystack documents.
+      WIRE_NAMES = {per_page: "perPage"}.freeze
+
+      # Fetch Balance.
+      #
+      # Fetch the available balance on your integration
+      #
+      # @return [PaystackSdk::Response] The response from the Paystack API.
+      # @raise [PaystackSdk::Error] If a parameter is invalid or the API request fails.
+      # @see https://paystack.com/docs/api/transfer-control/#balance
+      def fetch
+        handle_response(@connection.get("/balance"))
+      end
+
+      # Balance Ledger.
+      #
+      # Fetch all pay-ins and pay-outs that occured on your integration
+      #
+      # @param per_page [Integer] Number of records to fetch per page
+      # @param page [Integer] The section to retrieve
+      # @param from [String] The start date
+      # @param to [String] The end date
+      # @return [PaystackSdk::Response] The response from the Paystack API.
+      # @raise [PaystackSdk::Error] If a parameter is invalid or the API request fails.
+      # @see https://paystack.com/docs/api/transfer-control/#balance-ledger
+      def ledger(per_page: nil, page: nil, from: nil, to: nil)
+        validate_positive_integer!(value: per_page, name: "perPage")
+        validate_positive_integer!(value: page, name: "page")
+
+        wire_query = to_wire(
+          {
+            per_page:,
+            page:,
+            from: format_datetime(from, name: "from"),
+            to: format_datetime(to, name: "to")
+          },
+          WIRE_NAMES
+        )
+
+        handle_response(@connection.get("/balance/ledger", wire_query))
+      end
+    end
+  end
+end