mudbase 1.1.4

data/docs/Billing.md

@@ -0,0 +1,22 @@
+# Mudbase::Billing
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **next_billing_date** | **Time** |  | [optional] |
+| **payment_method** | **String** |  | [optional] |
+| **last_payment** | [**BillingLastPayment**](BillingLastPayment.md) |  | [optional] |
+
+## Example
+
+```ruby
+require 'mudbase'
+
+instance = Mudbase::Billing.new(
+  next_billing_date: null,
+  payment_method: null,
+  last_payment: null
+)
+```
+

data/docs/BillingApi.md

@@ -0,0 +1,677 @@
+# Mudbase::BillingApi
+
+All URIs are relative to *https://cloud.mudbase.dev*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**check_feature_access**](BillingApi.md#check_feature_access) | **GET** /api/billing/public/projects/{projectId}/feature-access | Check feature access (public) |
+| [**check_subscription**](BillingApi.md#check_subscription) | **GET** /api/billing/public/projects/{projectId}/subscription | Check subscription status (public) |
+| [**create_checkout_session**](BillingApi.md#create_checkout_session) | **POST** /api/billing/public/projects/{projectId}/checkout | Create checkout session (Flutterwave or crypto) |
+| [**get_checkout_payment**](BillingApi.md#get_checkout_payment) | **GET** /api/billing/public/projects/{projectId}/checkout/{paymentId} | Get checkout payment details |
+| [**get_public_plans**](BillingApi.md#get_public_plans) | **GET** /api/billing/public/projects/{projectId}/plans | Get public plans (no auth required) |
+| [**handle_crypto_payment_webhook**](BillingApi.md#handle_crypto_payment_webhook) | **POST** /api/billing/webhooks/crypto | Crypto payment processor webhook |
+| [**handle_flutterwave_webhook**](BillingApi.md#handle_flutterwave_webhook) | **POST** /api/billing/webhooks/flutterwave | Flutterwave webhook |
+| [**initialize_payment_for_project**](BillingApi.md#initialize_payment_for_project) | **POST** /api/projects/{projectId}/payment-processing/initialize-payment | Initialize fiat payment (project-scoped) |
+| [**record_usage**](BillingApi.md#record_usage) | **POST** /api/billing/public/projects/{projectId}/usage | Record usage (public) |
+| [**verify_payment**](BillingApi.md#verify_payment) | **POST** /api/billing/public/projects/{projectId}/verify-payment | Verify payment and create subscription |
+
+
+## check_feature_access
+
+> <CheckFeatureAccess200Response> check_feature_access(project_id, email, feature)
+
+Check feature access (public)
+
+Check whether a customer has access to a feature (by plan or entitlement). Public; no auth required.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) for the billing project.
+email = 'email_example' # String | Customer email
+feature = 'feature_example' # String | Feature slug to check access for
+
+begin
+  # Check feature access (public)
+  result = api_instance.check_feature_access(project_id, email, feature)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->check_feature_access: #{e}"
+end
+```
+
+#### Using the check_feature_access_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<CheckFeatureAccess200Response>, Integer, Hash)> check_feature_access_with_http_info(project_id, email, feature)
+
+```ruby
+begin
+  # Check feature access (public)
+  data, status_code, headers = api_instance.check_feature_access_with_http_info(project_id, email, feature)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <CheckFeatureAccess200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->check_feature_access_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID (MongoDB ObjectId) for the billing project. |  |
+| **email** | **String** | Customer email |  |
+| **feature** | **String** | Feature slug to check access for |  |
+
+### Return type
+
+[**CheckFeatureAccess200Response**](CheckFeatureAccess200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## check_subscription
+
+> <CheckSubscription200Response> check_subscription(project_id, email)
+
+Check subscription status (public)
+
+Check whether a customer (by email) has an active subscription for the project. Public; no auth required.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) for the billing project.
+email = 'email_example' # String | Customer email to check subscription for
+
+begin
+  # Check subscription status (public)
+  result = api_instance.check_subscription(project_id, email)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->check_subscription: #{e}"
+end
+```
+
+#### Using the check_subscription_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<CheckSubscription200Response>, Integer, Hash)> check_subscription_with_http_info(project_id, email)
+
+```ruby
+begin
+  # Check subscription status (public)
+  data, status_code, headers = api_instance.check_subscription_with_http_info(project_id, email)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <CheckSubscription200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->check_subscription_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID (MongoDB ObjectId) for the billing project. |  |
+| **email** | **String** | Customer email to check subscription for |  |
+
+### Return type
+
+[**CheckSubscription200Response**](CheckSubscription200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## create_checkout_session
+
+> <CreateCheckoutSession200Response> create_checkout_session(project_id, create_checkout_session_request)
+
+Create checkout session (Flutterwave or crypto)
+
+Creates a checkout session for subscription billing. When Flutterwave is configured (platform), returns authorizationUrl and accessCode for redirect. When using crypto payment processor, returns checkoutUrl, paymentOptions (multi-chain USDC/USDT/BTC Lightning), and reference. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) for the billing project.
+create_checkout_session_request = Mudbase::CreateCheckoutSessionRequest.new({plan_id: 'plan_id_example', billing_cycle: 'monthly', customer_info: Mudbase::CreateCheckoutSessionRequestCustomerInfo.new({email: 'email_example'})}) # CreateCheckoutSessionRequest | Plan to subscribe to, billing cycle, customer email/name, and optional success/cancel redirect URLs.
+
+begin
+  # Create checkout session (Flutterwave or crypto)
+  result = api_instance.create_checkout_session(project_id, create_checkout_session_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->create_checkout_session: #{e}"
+end
+```
+
+#### Using the create_checkout_session_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<CreateCheckoutSession200Response>, Integer, Hash)> create_checkout_session_with_http_info(project_id, create_checkout_session_request)
+
+```ruby
+begin
+  # Create checkout session (Flutterwave or crypto)
+  data, status_code, headers = api_instance.create_checkout_session_with_http_info(project_id, create_checkout_session_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <CreateCheckoutSession200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->create_checkout_session_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID (MongoDB ObjectId) for the billing project. |  |
+| **create_checkout_session_request** | [**CreateCheckoutSessionRequest**](CreateCheckoutSessionRequest.md) | Plan to subscribe to, billing cycle, customer email/name, and optional success/cancel redirect URLs. |  |
+
+### Return type
+
+[**CreateCheckoutSession200Response**](CreateCheckoutSession200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## get_checkout_payment
+
+> <GetCheckoutPayment200Response> get_checkout_payment(project_id, payment_id)
+
+Get checkout payment details
+
+Returns payment intent/checkout status (for refresh or deep link). No auth required.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) for the billing project.
+payment_id = 'payment_id_example' # String | Payment ID or reference from checkout session
+
+begin
+  # Get checkout payment details
+  result = api_instance.get_checkout_payment(project_id, payment_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->get_checkout_payment: #{e}"
+end
+```
+
+#### Using the get_checkout_payment_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetCheckoutPayment200Response>, Integer, Hash)> get_checkout_payment_with_http_info(project_id, payment_id)
+
+```ruby
+begin
+  # Get checkout payment details
+  data, status_code, headers = api_instance.get_checkout_payment_with_http_info(project_id, payment_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetCheckoutPayment200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->get_checkout_payment_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID (MongoDB ObjectId) for the billing project. |  |
+| **payment_id** | **String** | Payment ID or reference from checkout session |  |
+
+### Return type
+
+[**GetCheckoutPayment200Response**](GetCheckoutPayment200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_public_plans
+
+> <GetPublicPlans200Response> get_public_plans(project_id)
+
+Get public plans (no auth required)
+
+Returns subscription plans available for the project. Public; no authentication required. Use for pricing pages and checkout flow.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) to list plans for.
+
+begin
+  # Get public plans (no auth required)
+  result = api_instance.get_public_plans(project_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->get_public_plans: #{e}"
+end
+```
+
+#### Using the get_public_plans_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetPublicPlans200Response>, Integer, Hash)> get_public_plans_with_http_info(project_id)
+
+```ruby
+begin
+  # Get public plans (no auth required)
+  data, status_code, headers = api_instance.get_public_plans_with_http_info(project_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetPublicPlans200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->get_public_plans_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID (MongoDB ObjectId) to list plans for. |  |
+
+### Return type
+
+[**GetPublicPlans200Response**](GetPublicPlans200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## handle_crypto_payment_webhook
+
+> <HandleCryptoPaymentWebhook200Response> handle_crypto_payment_webhook(handle_crypto_payment_webhook_request)
+
+Crypto payment processor webhook
+
+Receives crypto payment events (payment.completed, etc.) for platform billing. No auth; verified by provider signature.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+handle_crypto_payment_webhook_request = Mudbase::HandleCryptoPaymentWebhookRequest.new({event: 'payment.created', data: Mudbase::HandleCryptoPaymentWebhookRequestData.new}) # HandleCryptoPaymentWebhookRequest | Crypto payment webhook payload (event type and data with paymentId, reference, amount, currency, network, status, metadata).
+
+begin
+  # Crypto payment processor webhook
+  result = api_instance.handle_crypto_payment_webhook(handle_crypto_payment_webhook_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->handle_crypto_payment_webhook: #{e}"
+end
+```
+
+#### Using the handle_crypto_payment_webhook_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<HandleCryptoPaymentWebhook200Response>, Integer, Hash)> handle_crypto_payment_webhook_with_http_info(handle_crypto_payment_webhook_request)
+
+```ruby
+begin
+  # Crypto payment processor webhook
+  data, status_code, headers = api_instance.handle_crypto_payment_webhook_with_http_info(handle_crypto_payment_webhook_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <HandleCryptoPaymentWebhook200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->handle_crypto_payment_webhook_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **handle_crypto_payment_webhook_request** | [**HandleCryptoPaymentWebhookRequest**](HandleCryptoPaymentWebhookRequest.md) | Crypto payment webhook payload (event type and data with paymentId, reference, amount, currency, network, status, metadata). |  |
+
+### Return type
+
+[**HandleCryptoPaymentWebhook200Response**](HandleCryptoPaymentWebhook200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## handle_flutterwave_webhook
+
+> <HandleCryptoPaymentWebhook200Response> handle_flutterwave_webhook(handle_flutterwave_webhook_request)
+
+Flutterwave webhook
+
+Receives Flutterwave webhook events (charge.completed, payment.successful). No auth; verified by verif-hash header. - Subscription billing: meta without isPaymentProcessing triggers verifyPaymentAndCreateSubscription (mudbase_xxx refs). - Payment processing: meta.isPaymentProcessing === true triggers fiat payment record (mudbase_fiat_xxx refs); org share goes to org subaccount, platform fee to main or configured subaccounts. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+handle_flutterwave_webhook_request = Mudbase::HandleFlutterwaveWebhookRequest.new # HandleFlutterwaveWebhookRequest | Flutterwave webhook payload (event and data with id, tx_ref, amount, currency, status, customer, meta for subscription or payment-processing).
+
+begin
+  # Flutterwave webhook
+  result = api_instance.handle_flutterwave_webhook(handle_flutterwave_webhook_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->handle_flutterwave_webhook: #{e}"
+end
+```
+
+#### Using the handle_flutterwave_webhook_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<HandleCryptoPaymentWebhook200Response>, Integer, Hash)> handle_flutterwave_webhook_with_http_info(handle_flutterwave_webhook_request)
+
+```ruby
+begin
+  # Flutterwave webhook
+  data, status_code, headers = api_instance.handle_flutterwave_webhook_with_http_info(handle_flutterwave_webhook_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <HandleCryptoPaymentWebhook200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->handle_flutterwave_webhook_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **handle_flutterwave_webhook_request** | [**HandleFlutterwaveWebhookRequest**](HandleFlutterwaveWebhookRequest.md) | Flutterwave webhook payload (event and data with id, tx_ref, amount, currency, status, customer, meta for subscription or payment-processing). |  |
+
+### Return type
+
+[**HandleCryptoPaymentWebhook200Response**](HandleCryptoPaymentWebhook200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## initialize_payment_for_project
+
+> initialize_payment_for_project(project_id, initialize_payment_for_project_request)
+
+Initialize fiat payment (project-scoped)
+
+Same as org-level initialize-payment; projectId from path is used for scope and tx_ref. Resolves project to org and uses org's Flutterwave subaccount.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): ProjectBearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::BillingApi.new
+project_id = 'project_id_example' # String | Project ID for payment scope and tx_ref.
+initialize_payment_for_project_request = Mudbase::InitializePaymentForProjectRequest.new({amount: 3.56, customer: Mudbase::InitializePaymentForProjectRequestCustomer.new({email: 'email_example'})}) # InitializePaymentForProjectRequest | Payment amount, currency, customer (email, name), and optional metadata.
+
+begin
+  # Initialize fiat payment (project-scoped)
+  api_instance.initialize_payment_for_project(project_id, initialize_payment_for_project_request)
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->initialize_payment_for_project: #{e}"
+end
+```
+
+#### Using the initialize_payment_for_project_with_http_info variant
+
+This returns an Array which contains the response data (`nil` in this case), status code and headers.
+
+> <Array(nil, Integer, Hash)> initialize_payment_for_project_with_http_info(project_id, initialize_payment_for_project_request)
+
+```ruby
+begin
+  # Initialize fiat payment (project-scoped)
+  data, status_code, headers = api_instance.initialize_payment_for_project_with_http_info(project_id, initialize_payment_for_project_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => nil
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->initialize_payment_for_project_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID for payment scope and tx_ref. |  |
+| **initialize_payment_for_project_request** | [**InitializePaymentForProjectRequest**](InitializePaymentForProjectRequest.md) | Payment amount, currency, customer (email, name), and optional metadata. |  |
+
+### Return type
+
+nil (empty response body)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## record_usage
+
+> <MessageResponse> record_usage(project_id, record_usage_request)
+
+Record usage (public)
+
+Record metered usage for a customer (e.g. api_calls, storage_mb). Used for usage-based billing. Public endpoint; optionally secured by webhook or API key in production.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) for the billing project.
+record_usage_request = Mudbase::RecordUsageRequest.new({email: 'email_example', metric: 'metric_example', quantity: 3.56}) # RecordUsageRequest | Customer email, metric name (e.g. api_calls, storage_mb), and quantity to record.
+
+begin
+  # Record usage (public)
+  result = api_instance.record_usage(project_id, record_usage_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->record_usage: #{e}"
+end
+```
+
+#### Using the record_usage_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> record_usage_with_http_info(project_id, record_usage_request)
+
+```ruby
+begin
+  # Record usage (public)
+  data, status_code, headers = api_instance.record_usage_with_http_info(project_id, record_usage_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->record_usage_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID (MongoDB ObjectId) for the billing project. |  |
+| **record_usage_request** | [**RecordUsageRequest**](RecordUsageRequest.md) | Customer email, metric name (e.g. api_calls, storage_mb), and quantity to record. |  |
+
+### Return type
+
+[**MessageResponse**](MessageResponse.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## verify_payment
+
+> <VerifyPayment200Response> verify_payment(project_id, reference)
+
+Verify payment and create subscription
+
+Verifies payment by reference (Flutterwave mudbase_xxx or crypto pmt_xxx) and creates or updates the subscription. Call after redirect from payment provider; pass reference as query (e.g. ?reference=mudbase_abc123). Idempotent for same reference. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::BillingApi.new
+project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) for the billing project.
+reference = 'reference_example' # String | Payment reference (e.g. mudbase_abc123 or pmt_abc123)
+
+begin
+  # Verify payment and create subscription
+  result = api_instance.verify_payment(project_id, reference)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->verify_payment: #{e}"
+end
+```
+
+#### Using the verify_payment_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<VerifyPayment200Response>, Integer, Hash)> verify_payment_with_http_info(project_id, reference)
+
+```ruby
+begin
+  # Verify payment and create subscription
+  data, status_code, headers = api_instance.verify_payment_with_http_info(project_id, reference)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <VerifyPayment200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling BillingApi->verify_payment_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID (MongoDB ObjectId) for the billing project. |  |
+| **reference** | **String** | Payment reference (e.g. mudbase_abc123 or pmt_abc123) |  |
+
+### Return type
+
+[**VerifyPayment200Response**](VerifyPayment200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+