paystack_sdk 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8893378c4721f9f126d73b888dd539060c93058488b49c92833183b819d06023
-  data.tar.gz: a787c8b3b413e4171c3574e38dc519c0b2eed3df09776b383a0b20fc259bd75a
+  metadata.gz: da9c2a9982f9eb4ec639e53651b7a54a20e0adda1d0f3f21b2add3bcf51194b2
+  data.tar.gz: 12bc63e0ebc8e8448f2a73cbabe2230af8c0f783857b3931dc72973dfcb3581a
 SHA512:
-  metadata.gz: a205e604c23fc3ca07a1ad7096ef920c9587fc04d322da9c40e6e00bd92870c2d833f554b275c6651a3f1aa07c23d56e2cb77fc41d2a02005e5848f8686942a4
-  data.tar.gz: d5cbb5b6bfefe710024e1cba4dcaa2097577b4df3f17e001199b281945cb8d417000c89a0fd5292d8ca8444272d55313f010b2acfadc130246372433f0465166
+  metadata.gz: ebf5ddb53f888f1d9aaa017b4aa9af1542f28aa563654f13de77ffc78f83043073c7aa2134e030853695e06dcc98ee88e5688d1e682462c4036df239e8605f26
+  data.tar.gz: 2f7b2710265dcab7de4367ab68da1e7112e963d6a165ed3024f7881b81dc44032b0c706afddf896d52a4c0e5999208c397ae55c78ad07c5c5fefc2af13bc865d

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-09
+
+### Added
+
+- The SDK now covers every operation in Paystack's OpenAPI spec (163 of 163). Resources that could not be exercised against the Paystack test API (Terminals, Dedicated Virtual Accounts, and the state-changing calls on Apple Pay, Integrations, Virtual Terminals and Direct Debits) follow the spec and docs, and their README sections and method docs say so.
+- `Pages` (`client.pages`), generated from Paystack's OpenAPI spec: `create`, `list`, `fetch(id_or_slug:)`, `update(id_or_slug:)`, `check_slug_availability(slug:)` and `add_products(id:, products:)`. Checked against the Paystack test API, `fetch` and `update` take the numeric ID or the slug, `update` needs no `name` or `description` (the docs mark them required), and `add_products` reads `products` (the docs say `product`) and takes the numeric ID only.
+- `Products` (`client.products`), generated from Paystack's OpenAPI spec: `create`, `list`, `fetch(id:)`, `update(id:, ...)` and `delete(id:)`. `delete` (`DELETE /product/{id}`) is in the spec but on no docs page; the test API deletes the product. Checked against the test API, `create` does not require `description` (the spec and docs say it does; `name`, `price` and `currency` are required) and takes `metadata` as a Hash (the spec says a JSON string, which Paystack stores as an object of its characters). Products are addressed by numeric ID.
+- `Orders` (`client.orders`): `create`, `list`, `fetch(id:)`, `fetch_product_orders(id:)` (the product's ID) and `validate(code:)` (a GET that takes the order code), generated from Paystack's OpenAPI spec. `create` follows the spec (`email`, `first_name`, `last_name`, `phone`, `currency`, `items`, `shipping`): the test API rejects the shape on Paystack's docs page (`customer`, `line_items`) with "Customer email is required". `items` are `{item: <product ID>, type: "product", quantity:, amount:}` and `shipping` needs `street_line`, `city`, `state`, `country` and `shipping_fee`. `fetch(id:)` returned a generic API error for a just-created order in the test API.
+- `Storefronts` (`client.storefronts`), generated from Paystack's OpenAPI spec: `create`, `list`, `fetch(id:)`, `update(id:)`, `delete(id:)`, `verify_slug(slug:)`, `fetch_orders(id:)`, `add_products(id:, products:)`, `list_products(id:)`, `publish(id:)` and `duplicate(id:)`. Checked against the Paystack test API, `create` requires `slug` and `currency` (the docs mark slug optional and omit currency), `update` takes `slug`, `add_products` takes numeric product IDs, and `publish` copies the storefront and its products to the live integration even with a test key.
+- `bin/scaffold_names.yml` entries can carry a `note:`, rendered as a `@note` in the method's docs. `storefronts.publish` uses it to warn that publishing creates a live copy even with a test key.
+- `BulkCharges` (`client.bulk_charges`), generated from Paystack's OpenAPI spec: `initiate(charges:)`, `list_batches`, `fetch_batch(id_or_code:)`, `fetch_charges(id_or_code:)`, `pause_batch(batch_code:)` and `resume_batch(batch_code:)`. `initiate` sends `charges` (an Array of Hashes with `authorization`, `amount` and `reference`) as the JSON array body. Pause and resume are GET requests, as the docs and the test API have them. `from` and `to`, which the docs list, are left out: the test API ignores them.
+- `bin/paystack-scaffold` takes a `body:` keyword in `bin/scaffold_names.yml` for an operation whose body is a JSON array (default `items`), and names that keyword, not an empty string, in the missing-parameter error.
+- `ApplePay` (`client.apple_pay`), generated from Paystack's OpenAPI spec: `list_domains`, `register_domain(domain_name:)` and `unregister_domain(domain_name:)`. Only `list_domains` was checked against the Paystack test API (it answers without `use_cursor`, which the docs mark required). Registering and unregistering change account-wide Apple Pay configuration that may reach live mode with a test key, so they were not called and are unverified; their method docs carry a `@note` saying so. `bin/paystack-scaffold` can name a singular resource (`SINGULAR_TAGS`), used so the tag "Apple Pay" gives `ApplePay`, not `ApplePays`.
+- `Integrations` (`client.integrations`), generated from Paystack's OpenAPI spec: `fetch_payment_session_timeout` and `update_payment_session_timeout(timeout:)` (seconds). Only the fetch was checked against the Paystack test API. The update changes an account-wide setting that may be shared with live mode, so it was not called and is unverified; its docs carry a warning.
+- `VirtualTerminals` (`client.virtual_terminals`), generated from Paystack's OpenAPI spec: `create`, `list`, `fetch(code:)`, `update(code:, name:)`, `deactivate(code:)`, `assign_destination(code:, destinations:)`, `unassign_destination(code:, targets:)`, `add_split_code(code:, split_code:)` and `remove_split_code(code:, split_code:)` (a DELETE with a JSON body). `list` also takes `status` (`active` or `inactive`), which the docs list and the test API validates but the spec omits. Checked against the Paystack test API: `list`, `fetch`, validation errors and unknown-code errors only. Nothing was created, and assign and unassign destination were not called (a destination is a WhatsApp number), so those, `create` with a valid body and the split code operations on a real terminal are unverified.
+- `DirectDebits` (`client.direct_debits`), generated from Paystack's OpenAPI spec: `list_mandate_authorizations(cursor:, status:, per_page:)` and `trigger_activation_charge(customer_ids:)`. These are the integration-wide `/directdebit/...` endpoints; the per-customer ones stay on `client.customers`. `list_mandate_authorizations` was checked against the test API (all parameters optional, `status` limited to pending, active and revoked). `trigger_activation_charge` charges customers' bank accounts and follows the docs and spec without a live check.
+- `Terminals` (`client.terminals`), generated from Paystack's OpenAPI spec: `send_event(terminal_id:)`, `fetch_event_status(terminal_id:, event_id:)`, `fetch_status(terminal_id:)`, `list`, `fetch(terminal_id:)`, `update(terminal_id:)`, `commission(serial_number:)` and `decommission(serial_number:)`. Unverified against the Paystack API: the test account has no Terminal access (every GET returns 403 "not yet available in your country"), so the methods follow the spec, and the device operations were never called.
+
 ## [0.3.0] - 2026-10-09
 
 ### Added

data/README.md

@@ -53,6 +53,7 @@ The `paystack_sdk` gem provides a simple and intuitive interface for interacting
     - [Create a Subaccount](#create-a-subaccount)
     - [List and Fetch Subaccounts](#list-and-fetch-subaccounts)
     - [Update a Subaccount](#update-a-subaccount)
+  - [Orders](#orders)
   - [Balances](#balances)
   - [Plans](#plans)
     - [Create a Plan](#create-a-plan)
@@ -67,10 +68,38 @@ The `paystack_sdk` gem provides a simple and intuitive interface for interacting
     - [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)
+  - [Pages](#pages)
+    - [List, Fetch and Update Pages](#list-fetch-and-update-pages)
   - [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)
+  - [Products](#products)
+    - [Create a Product](#create-a-product)
+    - [List, Fetch, Update and Delete Products](#list-fetch-update-and-delete-products)
+  - [Storefronts](#storefronts)
+    - [Create a Storefront](#create-a-storefront)
+    - [List, Fetch, Update and Delete Storefronts](#list-fetch-update-and-delete-storefronts)
+    - [Products, Orders, Duplicate and Publish](#products-orders-duplicate-and-publish)
+  - [Bulk Charges](#bulk-charges)
+    - [Initiate a Bulk Charge](#initiate-a-bulk-charge)
+    - [List and Fetch Batches and Their Charges](#list-and-fetch-batches-and-their-charges)
+    - [Pause and Resume a Batch](#pause-and-resume-a-batch)
+  - [Apple Pay](#apple-pay)
+    - [List Registered Domains](#list-registered-domains)
+    - [Register and Unregister a Domain (unverified)](#register-and-unregister-a-domain-unverified)
+  - [Integration](#integration)
+    - [Payment Session Timeout](#payment-session-timeout)
+  - [Virtual Terminals](#virtual-terminals)
+    - [Create, List, Fetch, Update and Deactivate](#create-list-fetch-update-and-deactivate-virtual-terminals)
+    - [Destinations and Split Codes](#destinations-and-split-codes)
+  - [Direct Debit](#direct-debit)
+    - [List Mandate Authorizations](#list-mandate-authorizations)
+    - [Trigger Activation Charges](#trigger-activation-charges)
+  - [Terminals](#terminals)
+    - [List and Fetch Terminals](#list-and-fetch-terminals)
+    - [Send an Event and Check It](#send-an-event-and-check-it)
+    - [Update, Commission and Decommission](#update-commission-and-decommission)
   - [Response Handling](#response-handling)
     - [Working with Response Objects](#working-with-response-objects)
     - [Accessing the Original Response](#accessing-the-original-response)
@@ -698,10 +727,11 @@ paystack.customers.initialize_direct_debit(
   address: {street: "Some Where", city: "Ikeja", state: "Lagos"}
 )
 
-# The customer's Direct Debit mandates
+# The customer's Direct Debit mandates (every customer's: paystack.direct_debits.list_mandate_authorizations)
 paystack.customers.fetch_mandate_authorizations(id: 12345)
 
-# Trigger an activation charge on an inactive mandate
+# Trigger an activation charge on an inactive mandate (pending mandates of several customers:
+# paystack.direct_debits.trigger_activation_charge, see Direct Debit below)
 paystack.customers.direct_debit_activation_charge(id: 12345, authorization_id: 1069309917)
 
 # Deactivate an authorization (any channel)
@@ -1098,6 +1128,29 @@ paystack.subaccounts.update(id_or_code: "ACCT_6uujpqtzmnufzkw", active: false)
 paystack.subaccounts.update(id_or_code: "ACCT_6uujpqtzmnufzkw", bank_code: "040100", account_number: "1234567890123")
 ```
 
+### Orders
+
+Orders record a customer's purchase of your products. `create` places an order for a customer, so it may notify the buyer: use test mode and a test email while you build.
+
+```ruby
+response = paystack.orders.create(
+  email: "ama@example.com",
+  first_name: "Ama",
+  last_name: "Mensah",
+  phone: "+233200000000",
+  currency: "GHS",
+  items: [{item: 2782725, type: "product", quantity: 2, amount: 20_000}], # product ID; amount in pesewas
+  shipping: {street_line: "1 Road", city: "Accra", state: "Greater Accra", country: "Ghana", shipping_fee: 0}
+)
+
+order = paystack.orders.fetch(id: 12_345)               # numeric order ID
+paystack.orders.list(per_page: 20, from: "2026-01-01")  # filters: per_page, page, from, to
+paystack.orders.fetch_product_orders(id: 2782725)       # orders for one product (the product ID)
+paystack.orders.validate(code: "ORD_abc123def456")      # GET, for a "pay for me" order
+```
+
+Paystack's docs page shows `create` taking `customer` and `line_items`, but the API follows the OpenAPI spec: the test API answers the docs' shape with "Customer email is required". The order total must be at least 2 units of the currency (GHS 2), and a new order has status `created` until it is paid. `pay_for_me: true` needs receiver details that neither the spec nor the docs describe ("Receiver data is required"), so it is not covered here.
+
 ### 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.
@@ -1364,6 +1417,352 @@ paystack.payment_requests.notify(code: "PRQ_7w7dpecncnebg7e")
 paystack.payment_requests.archive(id_or_code: "PRQ_7w7dpecncnebg7e")
 ```
 
+### Pages
+
+A payment page is a public pay link at `https://paystack.com/pay/<slug>`, useful for donations or one-off payments. Amounts are integers in the currency's subunit (pesewas for GHS).
+
+```ruby
+# Without an amount the customer chooses what to pay (a donation page). Pass fixed_amount: true
+# together with amount to fix it.
+response = paystack.pages.create(
+  name: "Sunday Offering",
+  description: "Give to the work of the church",
+  slug: "sunday-offering",
+  collect_phone: true,
+  custom_fields: [{display_name: "Branch", variable_name: "branch"}]
+)
+response.data.slug # => "sunday-offering"
+
+# type is payment (default), subscription (with plan:), product or plan
+paystack.pages.create(name: "Lite plan", type: "subscription", plan: "4288882")
+
+# Is a slug free? An unsuccessful response ("Slug already in use") means it is taken.
+paystack.pages.check_slug_availability(slug: "sunday-offering").success?
+```
+
+#### List, Fetch and Update Pages
+
+```ruby
+paystack.pages.list(per_page: 20, page: 1)
+
+# Fetch and update take the numeric ID or the slug
+paystack.pages.fetch(id_or_slug: "sunday-offering")
+paystack.pages.update(id_or_slug: "sunday-offering", description: "New description")
+
+# Deactivate the page URL
+paystack.pages.update(id_or_slug: 2215275, active: false)
+
+# Product pages only: add products by numeric ID (the page needs type: "product")
+paystack.pages.add_products(id: 2215275, products: [473, 292])
+```
+
+### Products
+
+A product is something you sell through Paystack (a good, with stock if you track it). Prices are integers in the subunit of the currency: pesewas for GHS, kobo for NGN, cents for ZAR or USD. Only the currencies enabled on your integration are accepted.
+
+#### Create a Product
+
+```ruby
+response = paystack.products.create(
+  name: "Church anniversary t-shirt",
+  price: 5000,        # GHS 50.00, in pesewas
+  currency: "GHS",
+  description: "Cotton, sizes S to XL",
+  quantity: 100,      # stock on hand; use unlimited: true instead if you do not track stock
+  metadata: {branch: "Osu"} # a Hash; Paystack stores a JSON string as an object of its characters
+)
+
+if response.success?
+  puts "Created #{response.data.product_code} (ID #{response.data.id})"
+else
+  puts "Error: #{response.error_message}"
+end
+```
+
+`name`, `price` and `currency` are required by Paystack. Its docs and spec also list `description` as required, but the test API creates a product without one.
+
+#### List, Fetch, Update and Delete Products
+
+```ruby
+paystack.products.list(per_page: 20, page: 1, active: true)
+
+# Products are fetched, updated and deleted by their numeric ID (not the PROD_ code)
+paystack.products.fetch(id: 2782723)
+
+# Send only what changes
+paystack.products.update(id: 2782723, price: 6000, quantity: 80)
+
+paystack.products.delete(id: 2782723)
+```
+
+`delete` calls `DELETE /product/{id}`, which is in Paystack's OpenAPI spec but on no docs page; the test API deletes the product and answers `404 Product not found` afterwards.
+### Storefronts
+
+A storefront is a Paystack-hosted shop (`https://paystack.shop/<slug>`) that sells products you created with the Products API. Storefronts are identified by their numeric ID.
+
+#### Create a Storefront
+
+```ruby
+# Paystack requires name, slug and currency (its docs mark slug optional; the API does not).
+# The slug must be 5 to 100 characters: lowercase letters, numbers, dashes or underscores.
+response = paystack.storefronts.create(
+  name: "Harvest stall",
+  slug: "harvest-stall",
+  currency: "GHS", # one your integration accepts; Paystack refuses others ("Currency not supported or allowed")
+  description: "Sunday harvest sale"
+)
+
+puts response.data.id if response.success?
+```
+
+Check a slug first with `verify_slug`. Paystack answers with the storefront that holds it when it is taken (in test or live mode), and with a 404 "Storefront not found" when it is free:
+
+```ruby
+paystack.storefronts.verify_slug(slug: "harvest-stall").success? # => false: the slug is free
+```
+
+#### List, Fetch, Update and Delete Storefronts
+
+```ruby
+paystack.storefronts.list(status: "active", per_page: 20) # status is active or inactive
+paystack.storefronts.fetch(id: 1852308)
+
+# Send only what changes; update returns a message, not the storefront
+paystack.storefronts.update(id: 1852308, slug: "harvest-stall-2", description: "Harvest weekend")
+
+# Paystack keeps a deleted storefront with status "deleted"; it drops out of list
+paystack.storefronts.delete(id: 1852308)
+```
+
+#### Products, Orders, Duplicate and Publish
+
+```ruby
+# products takes numeric product IDs (Paystack refuses PROD_ codes here)
+paystack.storefronts.add_products(id: 1852308, products: [2782728])
+paystack.storefronts.list_products(id: 1852308)
+paystack.storefronts.fetch_orders(id: 1852308)
+
+# A copy with its products, named "Copy of ..." and given a new slug
+paystack.storefronts.duplicate(id: 1852308)
+
+# Publish copies the storefront and its products to your live integration, even with a test key
+paystack.storefronts.publish(id: 1852308)
+```
+
+`publish` makes a public, live storefront. On the test API it answered "Storefront published to live" and returned a new storefront with `domain: "live"` and a new ID, gave it the original slug, and renamed the test storefront (adding "-TEST" to the name and giving it a new slug). The live copy cannot be fetched or deleted with a test key: remove it from the dashboard in live mode.
+
+### Bulk Charges
+
+A bulk charge charges many saved cards (reusable authorizations) in one batch, which Paystack queues and processes in the background. Amounts are in the subunit (pesewas, kobo, cents).
+
+#### Initiate a Bulk Charge
+
+```ruby
+# The body is a JSON array: one Hash per charge, each with a reusable authorization code and an
+# integer amount. Give each a reference you can find again: it becomes the charge's transaction
+# reference (lowercase letters, digits, - and _, per the spec).
+response = paystack.bulk_charges.initiate(
+  charges: [
+    {authorization: "AUTH_50w0d0f5xo", amount: 5000, reference: "tithe-2026-10-kwesi"},
+    {authorization: "AUTH_xfuz7dy4b9", amount: 2000, reference: "tithe-2026-10-ama"}
+  ]
+)
+
+if response.success?
+  puts "Queued #{response.data.batch_code} with #{response.data.total_charges} charges"
+else
+  puts "Error: #{response.error_message}"
+end
+```
+
+The SDK refuses an empty list but sends each Hash as given: Paystack, not the SDK, checks what is inside. A successful response means the charges were queued ("Charges have been queued"), not that they succeeded; read each charge's outcome with `fetch_charges` or from your webhooks. Like every write, `initiate` is not retried after a timeout, so check `list_batches` before sending the same charges again.
+
+#### List and Fetch Batches and Their Charges
+
+```ruby
+# status is active, paused or complete. Paystack's docs also list from and to, but the API ignores them.
+paystack.bulk_charges.list_batches(status: "active", per_page: 20, page: 1)
+
+# Fetch by numeric ID or BCH_ code; total_charges and pending_charges show its progress
+batch = paystack.bulk_charges.fetch_batch(id_or_code: "BCH_1uhxe0d181eu850")
+puts "#{batch.data.pending_charges} of #{batch.data.total_charges} still pending"
+
+# Each charge with its customer, authorization, reference and status
+# (pending, success, failed, error or inactive_authorization)
+paystack.bulk_charges.fetch_charges(id_or_code: "BCH_1uhxe0d181eu850", status: "failed")
+```
+
+#### Pause and Resume a Batch
+
+```ruby
+# Both are GET requests, as Paystack documents them, and take the BCH_ batch code
+paystack.bulk_charges.pause_batch(batch_code: "BCH_1uhxe0d181eu850")  # "Bulk charge batch has been paused"
+paystack.bulk_charges.resume_batch(batch_code: "BCH_1uhxe0d181eu850") # "Bulk charge batch has been resumed"
+```
+
+A paused batch keeps its pending charges until it is resumed.
+
+### Apple Pay
+
+Apple Pay on Paystack needs each domain (or subdomain) that shows the Apple Pay button to be registered on your integration. The accessor is `paystack.apple_pay`.
+
+#### List Registered Domains
+
+```ruby
+response = paystack.apple_pay.list_domains
+
+# An account with no domains answers "Apple Pay registered domains retrieved" with an empty list
+puts response.data.domainNames.inspect # => []
+```
+
+`list_domains` was checked against the Paystack test API. Paystack's docs mark `use_cursor` required, but the API answers without it (and with `use_cursor=true`), so the SDK keeps it optional. Cursor pagination (`next_cursor:`, sent as `next`, and `previous:`) could not be exercised, because the test account has no domains.
+
+#### Register and Unregister a Domain (unverified)
+
+```ruby
+paystack.apple_pay.register_domain(domain_name: "pay.example.com")
+paystack.apple_pay.unregister_domain(domain_name: "pay.example.com")
+```
+
+**These two methods have not been called against the Paystack API.** They change the account's Apple Pay domain configuration, which is account-wide and public and may reach live mode even with a test key (`sk_test_`), so they were deliberately not tried. They follow Paystack's docs and OpenAPI spec: one domain per call, sent as `domainName`, and `unregister_domain` is a `DELETE` that carries the domain in a JSON body. How Paystack answers (and whether it reads a body on `DELETE`) is unconfirmed. Try them with a domain you own, and check the result in the dashboard.
+
+### Integration
+
+Settings of your Paystack integration (the account). Currently the payment session timeout.
+
+#### Payment Session Timeout
+
+```ruby
+# Seconds before a transaction becomes invalid. The test API returned 0 for an account that never set one.
+response = paystack.integrations.fetch_payment_session_timeout
+puts response.data.payment_session_timeout
+
+paystack.integrations.update_payment_session_timeout(timeout: 30)
+```
+
+`update_payment_session_timeout` changes a setting of the whole integration, which may be shared with live mode even when you use a test key, so treat it as a live change. It is **unverified**: it was not called against the Paystack API while building the SDK for that reason. It is generated from the OpenAPI spec and the docs page (`PUT /integration/payment_session_timeout`, body `timeout`, an integer in seconds). Only `fetch_payment_session_timeout` was checked against the API.
+
+### Virtual Terminals
+
+A virtual terminal lets you accept in-person payments without a POS device: payments made to it notify its destinations, which are WhatsApp numbers. Check that the product is enabled for your business.
+
+#### Create, List, Fetch, Update and Deactivate Virtual Terminals
+
+```ruby
+response = paystack.virtual_terminals.create(
+  name: "Front desk",
+  destinations: [{target: "+2341234567890", name: "Front desk phone"}]
+)
+puts response.data.code # "VT_..."
+
+# status is active or inactive (the docs list it, the OpenAPI spec omits it)
+paystack.virtual_terminals.list(status: "active", per_page: 20)
+
+paystack.virtual_terminals.fetch(code: "VT_MCK5292Z")
+paystack.virtual_terminals.update(code: "VT_MCK5292Z", name: "New terminal name")
+paystack.virtual_terminals.deactivate(code: "VT_MCK5292Z") # "Terminal set to inactive"
+```
+
+On the Paystack test API, `list` and `fetch` work (an account with no terminals gets an empty list). `create` answers 400 `"destinations" is required` without destinations, `"destinations" must contain at least 1 items` with an empty list and `invalid phone number ...` for a target that is not a phone number; `fetch` of an unknown code answers 404 `Virtual Terminal not found`. `create` with a valid body was not run (it needs a real phone number), so the optional `split_code` and `metadata` and the docs' `currency` and `custom_fields` are unverified; the SDK sends what the spec lists.
+
+#### Destinations and Split Codes
+
+```ruby
+paystack.virtual_terminals.assign_destination(
+  code: "VT_MCK5292Z",
+  destinations: [{target: "+2341234567890", name: "Another one"}]
+)
+paystack.virtual_terminals.unassign_destination(code: "VT_MCK5292Z", targets: ["+2341234567890"])
+
+paystack.virtual_terminals.add_split_code(code: "VT_MCK5292Z", split_code: "SPL_98WF13Zu8w5")
+# DELETE with a JSON body, as Paystack documents it
+paystack.virtual_terminals.remove_split_code(code: "VT_MCK5292Z", split_code: "SPL_98WF13Zu8w5")
+```
+
+Assign and unassign destination change who receives payment notifications on WhatsApp, so they were not called against the test API and are described from Paystack's docs only (unverified). The split code operations were only run against an unknown terminal: an unknown split code answers 400 `Invalid split code`, and removing one that is not assigned answers 400 `Virtual Terminal split code assignment does not exist`.
+
+### Direct Debit
+
+`client.direct_debits` works across your whole integration: every customer's Direct Debit mandates at once, and activation charges for several customers in one call. To link a bank account, or to work with one customer's mandates by their customer ID, use the methods on `client.customers` (see [Authorizations and Direct Debit](#authorizations-and-direct-debit)):
+
+| You want to | Integration-wide (`direct_debits`) | One customer (`customers`) |
+|---|---|---|
+| See mandates | `list_mandate_authorizations` (`GET /directdebit/mandate-authorizations`), filtered by `status`, paged by cursor | `fetch_mandate_authorizations(id:)` (`GET /customer/{id}/directdebit-mandate-authorizations`) |
+| Trigger an activation charge | `trigger_activation_charge(customer_ids:)` (`PUT /directdebit/activation-charge`), for **pending** mandates | `direct_debit_activation_charge(id:, authorization_id:)` (`PUT /customer/{id}/directdebit-activation-charge`), for one **inactive** mandate |
+
+#### List Mandate Authorizations
+
+```ruby
+# All parameters are optional. status is pending, active or revoked
+response = paystack.direct_debits.list_mandate_authorizations(status: "active", per_page: 10)
+
+response.each do |mandate|
+  puts "#{mandate.authorization_code} #{mandate.bank_name} #{mandate.status}"
+end
+
+# Cursor pagination: pass meta.next back as cursor (it is null on the last page)
+next_cursor = response.meta.next
+paystack.direct_debits.list_mandate_authorizations(status: "active", per_page: 10, cursor: next_cursor) if next_cursor
+```
+
+Paystack answers a cursor it cannot read with a 500, which the SDK raises as `PaystackSdk::ServerError`.
+
+#### Trigger Activation Charges
+
+```ruby
+# Numeric customer IDs of customers with pending mandates
+response = paystack.direct_debits.trigger_activation_charge(customer_ids: [28958104, 983697220])
+response.message # => "Mandate is queued for retry"
+```
+
+This charges the customers' bank accounts. It has not been verified against the test API: the method follows Paystack's docs and OpenAPI spec.
+
+### Terminals
+
+A Paystack Terminal is a physical point-of-sale device linked to your integration. **None of this was verified against the Paystack API:** the test account used to build the SDK (Ghana) gets `403` "Sorry, this feature is not yet available in your country." from every Terminal GET (list, fetch, status, event status; the others were not called), which the SDK returns as an unsuccessful `Response`. The methods follow Paystack's OpenAPI spec and docs page.
+
+#### List and Fetch Terminals
+
+```ruby
+# Cursor pagination: pass the meta's next or previous cursor back. per_page is sent as the spec names
+# it (the docs say perPage; which one the API reads is unverified).
+response = paystack.terminals.list(per_page: 20)
+paystack.terminals.list(next_cursor: response.meta.next) if response.success? && response.meta.next
+
+terminal = paystack.terminals.fetch(terminal_id: "2872S934")
+
+# Check a terminal is online and available before sending it an event
+status = paystack.terminals.fetch_status(terminal_id: "2872S934")
+puts "online: #{status.data.online}, available: #{status.data.available}"
+```
+
+#### Send an Event and Check It
+
+```ruby
+# Pushes an event to the physical device. type is invoice or transaction; action is process or view
+# (invoice) or process or print (transaction).
+event = paystack.terminals.send_event(
+  terminal_id: "2872S934",
+  type: "invoice",
+  action: "process",
+  data: {id: 7895939, reference: 4634337895939}
+)
+
+paystack.terminals.fetch_event_status(terminal_id: "2872S934", event_id: event.data.id) # data.delivered
+```
+
+The spec marks `type`, `action` and `data` optional and the SDK follows it; the docs list them without an "optional" badge.
+
+#### Update, Commission and Decommission
+
+```ruby
+paystack.terminals.update(terminal_id: "2872S934", name: "Front desk", address: "Accra")
+
+# Link or unlink a debug device by its serial number
+paystack.terminals.commission(serial_number: "1111150412230003899")
+paystack.terminals.decommission(serial_number: "1111150412230003899")
+```
+
 ### Response Handling
 
 #### Working with Response Objects

data/lib/paystack_sdk/client.rb

@@ -17,6 +17,16 @@ require_relative "resources/plans"
 require_relative "resources/subscriptions"
 require_relative "resources/dedicated_virtual_accounts"
 require_relative "resources/payment_requests"
+require_relative "resources/pages"
+require_relative "resources/products"
+require_relative "resources/orders"
+require_relative "resources/storefronts"
+require_relative "resources/bulk_charges"
+require_relative "resources/apple_pay"
+require_relative "resources/integrations"
+require_relative "resources/virtual_terminals"
+require_relative "resources/direct_debits"
+require_relative "resources/terminals"
 require_relative "utils/connection_utils"
 
 module PaystackSdk
@@ -254,6 +264,86 @@ module PaystackSdk
       @payment_requests ||= Resources::PaymentRequests.new(@connection)
     end
 
+    # Provides access to the `Pages` resource.
+    #
+    # @return [PaystackSdk::Resources::Pages] An instance of the
+    #  `Pages` resource.
+    def pages
+      @pages ||= Resources::Pages.new(@connection)
+    end
+
+    # Provides access to the `Products` resource.
+    #
+    # @return [PaystackSdk::Resources::Products] An instance of the
+    #  `Products` resource.
+    def products
+      @products ||= Resources::Products.new(@connection)
+    end
+
+    # Provides access to the `Orders` resource.
+    #
+    # @return [PaystackSdk::Resources::Orders] An instance of the
+    #  `Orders` resource.
+    def orders
+      @orders ||= Resources::Orders.new(@connection)
+    end
+
+    # Provides access to the `Storefronts` resource.
+    #
+    # @return [PaystackSdk::Resources::Storefronts] An instance of the
+    #  `Storefronts` resource.
+    def storefronts
+      @storefronts ||= Resources::Storefronts.new(@connection)
+    end
+
+    # Provides access to the `BulkCharges` resource.
+    #
+    # @return [PaystackSdk::Resources::BulkCharges] An instance of the
+    #  `BulkCharges` resource.
+    def bulk_charges
+      @bulk_charges ||= Resources::BulkCharges.new(@connection)
+    end
+
+    # Provides access to the `ApplePay` resource.
+    #
+    # @return [PaystackSdk::Resources::ApplePay] An instance of the
+    #  `ApplePay` resource.
+    def apple_pay
+      @apple_pay ||= Resources::ApplePay.new(@connection)
+    end
+
+    # Provides access to the `Integrations` resource.
+    #
+    # @return [PaystackSdk::Resources::Integrations] An instance of the
+    #  `Integrations` resource.
+    def integrations
+      @integrations ||= Resources::Integrations.new(@connection)
+    end
+
+    # Provides access to the `VirtualTerminals` resource.
+    #
+    # @return [PaystackSdk::Resources::VirtualTerminals] An instance of the
+    #  `VirtualTerminals` resource.
+    def virtual_terminals
+      @virtual_terminals ||= Resources::VirtualTerminals.new(@connection)
+    end
+
+    # Provides access to the `DirectDebits` resource.
+    #
+    # @return [PaystackSdk::Resources::DirectDebits] An instance of the
+    #  `DirectDebits` resource.
+    def direct_debits
+      @direct_debits ||= Resources::DirectDebits.new(@connection)
+    end
+
+    # Provides access to the `Terminals` resource.
+    #
+    # @return [PaystackSdk::Resources::Terminals] An instance of the
+    #  `Terminals` resource.
+    def terminals
+      @terminals ||= Resources::Terminals.new(@connection)
+    end
+
     private
 
     # The secret key a connection sends, read from its Authorization header.

data/lib/paystack_sdk/resources/apple_pay.rb

@@ -0,0 +1,74 @@
+# 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 Apple Pay`. Hand-written extras go in lib/paystack_sdk/resources/extensions/apple_pay.rb.
+# scaffold-digest: cd91bbd0850ed1baf4fd266d161cc41c75551ecff1190aa614ba064fddd10c7a
+
+require_relative "base"
+
+module PaystackSdk
+  module Resources
+    # Apple Pay operations.
+    class ApplePay < PaystackSdk::Resources::Base
+      # Ruby keyword => the parameter name Paystack documents.
+      WIRE_NAMES = {next_cursor: "next", domain_name: "domainName"}.freeze
+
+      # List Domains.
+      #
+      # Lists all registered domains on your integration.
+      #
+      # @param use_cursor [Boolean] A flag to indicate if cursor based pagination should be used
+      # @param next_cursor [String] An alphanumeric value returned for every cursor based retrieval, used to retrieve the next set of data
+      # @param previous [String] An alphanumeric value returned for every cursor based retrieval, used to retrieve the previous set of data
+      # @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/apple-pay/#list-domains
+      def list_domains(use_cursor: nil, next_cursor: nil, previous: nil)
+        wire_query = to_wire({use_cursor:, next_cursor:, previous:}, WIRE_NAMES)
+
+        handle_response(@connection.get("/apple-pay/domain", wire_query))
+      end
+
+      # Register Domain.
+      #
+      # Register a top-level domain or subdomain for your Apple Pay integration.
+      #
+      # @param domain_name [String] The domain or subdomain for your application
+      # @note Registers a domain for Apple Pay on the whole account. This changes Apple Pay
+      #   configuration that may also affect live mode, even with a test key (sk_test_). Not
+      #   verified against the live API by this SDK: do not call it to try the API out.
+      # @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/apple-pay/#register-domain
+      def register_domain(domain_name:)
+        validate_presence!(value: domain_name, name: "domainName")
+
+        wire_body = to_wire({domain_name:}, WIRE_NAMES)
+
+        handle_response(@connection.post("/apple-pay/domain", wire_body))
+      end
+
+      # Unregister Domain.
+      #
+      # Unregister a top-level domain or subdomain previously used for your Apple Pay integration.
+      #
+      # @param domain_name [String] The domain or subdomain for your application
+      # @note Unregisters a domain from Apple Pay on the whole account. This changes Apple Pay
+      #   configuration that may also affect live mode, even with a test key (sk_test_). Not
+      #   verified against the live API by this SDK, including how Paystack reads the request body
+      #   of a DELETE.
+      # @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/apple-pay/#unregister-domain
+      def unregister_domain(domain_name:)
+        validate_presence!(value: domain_name, name: "domainName")
+
+        wire_body = to_wire({domain_name:}, WIRE_NAMES)
+
+        handle_response(
+          @connection.delete("/apple-pay/domain") { |request| request.body = wire_body }
+        )
+      end
+    end
+  end
+end