mudbase 1.0.0 → 1.1.4

data/docs/BillingApi.md

@@ -4,21 +4,21 @@ All URIs are relative to *https://cloud.mudbase.dev*
 
 | Method | HTTP request | Description |
 | ------ | ------------ | ----------- |
-| [**billing_check_feature_access**](BillingApi.md#billing_check_feature_access) | **GET** /api/billing/public/projects/{projectId}/feature-access | Check feature access (public) |
-| [**billing_check_subscription**](BillingApi.md#billing_check_subscription) | **GET** /api/billing/public/projects/{projectId}/subscription | Check subscription status (public) |
-| [**billing_create_checkout_session**](BillingApi.md#billing_create_checkout_session) | **POST** /api/billing/public/projects/{projectId}/checkout | Create checkout session (Flutterwave or crypto) |
-| [**billing_get_checkout_payment**](BillingApi.md#billing_get_checkout_payment) | **GET** /api/billing/public/projects/{projectId}/checkout/{paymentId} | Get checkout payment details |
-| [**billing_get_public_plans**](BillingApi.md#billing_get_public_plans) | **GET** /api/billing/public/projects/{projectId}/plans | Get public plans (no auth required) |
-| [**billing_handle_crypto_webhook**](BillingApi.md#billing_handle_crypto_webhook) | **POST** /api/billing/webhooks/crypto | Crypto payment processor webhook |
-| [**billing_handle_flutterwave_webhook**](BillingApi.md#billing_handle_flutterwave_webhook) | **POST** /api/billing/webhooks/flutterwave | Flutterwave webhook |
-| [**billing_initialize_payment**](BillingApi.md#billing_initialize_payment) | **POST** /api/projects/{projectId}/payment-processing/initialize-payment | Initialize fiat payment (app-scoped) |
-| [**billing_record_usage**](BillingApi.md#billing_record_usage) | **POST** /api/billing/public/projects/{projectId}/usage | Record usage (public) |
-| [**billing_verify_payment**](BillingApi.md#billing_verify_payment) | **POST** /api/billing/public/projects/{projectId}/verify-payment | Verify payment and create subscription |
+| [**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 |
 
 
-## billing_check_feature_access
+## check_feature_access
 
-> <BillingCheckFeatureAccess200Response> billing_check_feature_access(project_id, email, feature)
+> <CheckFeatureAccess200Response> check_feature_access(project_id, email, feature)
 
 Check feature access (public)
 
@@ -37,28 +37,28 @@ feature = 'feature_example' # String | Feature slug to check access for
 
 begin
   # Check feature access (public)
-  result = api_instance.billing_check_feature_access(project_id, email, feature)
+  result = api_instance.check_feature_access(project_id, email, feature)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_check_feature_access: #{e}"
+  puts "Error when calling BillingApi->check_feature_access: #{e}"
 end
 ```
 
-#### Using the billing_check_feature_access_with_http_info variant
+#### Using the check_feature_access_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<BillingCheckFeatureAccess200Response>, Integer, Hash)> billing_check_feature_access_with_http_info(project_id, email, feature)
+> <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.billing_check_feature_access_with_http_info(project_id, email, feature)
+  data, status_code, headers = api_instance.check_feature_access_with_http_info(project_id, email, feature)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <BillingCheckFeatureAccess200Response>
+  p data # => <CheckFeatureAccess200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_check_feature_access_with_http_info: #{e}"
+  puts "Error when calling BillingApi->check_feature_access_with_http_info: #{e}"
 end
 ```
 
@@ -72,7 +72,7 @@ end
 
 ### Return type
 
-[**BillingCheckFeatureAccess200Response**](BillingCheckFeatureAccess200Response.md)
+[**CheckFeatureAccess200Response**](CheckFeatureAccess200Response.md)
 
 ### Authorization
 
@@ -84,9 +84,9 @@ No authorization required
 - **Accept**: application/json
 
 
-## billing_check_subscription
+## check_subscription
 
-> <BillingCheckSubscription200Response> billing_check_subscription(project_id, email)
+> <CheckSubscription200Response> check_subscription(project_id, email)
 
 Check subscription status (public)
 
@@ -104,28 +104,28 @@ email = 'email_example' # String | Customer email to check subscription for
 
 begin
   # Check subscription status (public)
-  result = api_instance.billing_check_subscription(project_id, email)
+  result = api_instance.check_subscription(project_id, email)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_check_subscription: #{e}"
+  puts "Error when calling BillingApi->check_subscription: #{e}"
 end
 ```
 
-#### Using the billing_check_subscription_with_http_info variant
+#### Using the check_subscription_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<BillingCheckSubscription200Response>, Integer, Hash)> billing_check_subscription_with_http_info(project_id, email)
+> <Array(<CheckSubscription200Response>, Integer, Hash)> check_subscription_with_http_info(project_id, email)
 
 ```ruby
 begin
   # Check subscription status (public)
-  data, status_code, headers = api_instance.billing_check_subscription_with_http_info(project_id, email)
+  data, status_code, headers = api_instance.check_subscription_with_http_info(project_id, email)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <BillingCheckSubscription200Response>
+  p data # => <CheckSubscription200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_check_subscription_with_http_info: #{e}"
+  puts "Error when calling BillingApi->check_subscription_with_http_info: #{e}"
 end
 ```
 
@@ -138,7 +138,7 @@ end
 
 ### Return type
 
-[**BillingCheckSubscription200Response**](BillingCheckSubscription200Response.md)
+[**CheckSubscription200Response**](CheckSubscription200Response.md)
 
 ### Authorization
 
@@ -150,9 +150,9 @@ No authorization required
 - **Accept**: application/json
 
 
-## billing_create_checkout_session
+## create_checkout_session
 
-> <BillingCreateCheckoutSession200Response> billing_create_checkout_session(project_id, billing_create_checkout_session_request)
+> <CreateCheckoutSession200Response> create_checkout_session(project_id, create_checkout_session_request)
 
 Create checkout session (Flutterwave or crypto)
 
@@ -166,32 +166,32 @@ require 'mudbase'
 
 api_instance = Mudbase::BillingApi.new
 project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) for the billing project.
-billing_create_checkout_session_request = Mudbase::BillingCreateCheckoutSessionRequest.new({plan_id: 'plan_id_example', billing_cycle: 'monthly', customer_info: Mudbase::BillingCreateCheckoutSessionRequestCustomerInfo.new({email: 'email_example'})}) # BillingCreateCheckoutSessionRequest | Plan to subscribe to, billing cycle, customer email/name, and optional success/cancel redirect URLs.
+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.billing_create_checkout_session(project_id, billing_create_checkout_session_request)
+  result = api_instance.create_checkout_session(project_id, create_checkout_session_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_create_checkout_session: #{e}"
+  puts "Error when calling BillingApi->create_checkout_session: #{e}"
 end
 ```
 
-#### Using the billing_create_checkout_session_with_http_info variant
+#### Using the create_checkout_session_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<BillingCreateCheckoutSession200Response>, Integer, Hash)> billing_create_checkout_session_with_http_info(project_id, billing_create_checkout_session_request)
+> <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.billing_create_checkout_session_with_http_info(project_id, billing_create_checkout_session_request)
+  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 # => <BillingCreateCheckoutSession200Response>
+  p data # => <CreateCheckoutSession200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_create_checkout_session_with_http_info: #{e}"
+  puts "Error when calling BillingApi->create_checkout_session_with_http_info: #{e}"
 end
 ```
 
@@ -200,11 +200,11 @@ end
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
 | **project_id** | **String** | Project ID (MongoDB ObjectId) for the billing project. |  |
-| **billing_create_checkout_session_request** | [**BillingCreateCheckoutSessionRequest**](BillingCreateCheckoutSessionRequest.md) | Plan to subscribe to, billing cycle, customer email/name, and optional success/cancel redirect URLs. |  |
+| **create_checkout_session_request** | [**CreateCheckoutSessionRequest**](CreateCheckoutSessionRequest.md) | Plan to subscribe to, billing cycle, customer email/name, and optional success/cancel redirect URLs. |  |
 
 ### Return type
 
-[**BillingCreateCheckoutSession200Response**](BillingCreateCheckoutSession200Response.md)
+[**CreateCheckoutSession200Response**](CreateCheckoutSession200Response.md)
 
 ### Authorization
 
@@ -216,9 +216,9 @@ No authorization required
 - **Accept**: application/json
 
 
-## billing_get_checkout_payment
+## get_checkout_payment
 
-> <BillingGetCheckoutPayment200Response> billing_get_checkout_payment(project_id, payment_id)
+> <GetCheckoutPayment200Response> get_checkout_payment(project_id, payment_id)
 
 Get checkout payment details
 
@@ -236,28 +236,28 @@ payment_id = 'payment_id_example' # String | Payment ID or reference from checko
 
 begin
   # Get checkout payment details
-  result = api_instance.billing_get_checkout_payment(project_id, payment_id)
+  result = api_instance.get_checkout_payment(project_id, payment_id)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_get_checkout_payment: #{e}"
+  puts "Error when calling BillingApi->get_checkout_payment: #{e}"
 end
 ```
 
-#### Using the billing_get_checkout_payment_with_http_info variant
+#### Using the get_checkout_payment_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<BillingGetCheckoutPayment200Response>, Integer, Hash)> billing_get_checkout_payment_with_http_info(project_id, payment_id)
+> <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.billing_get_checkout_payment_with_http_info(project_id, payment_id)
+  data, status_code, headers = api_instance.get_checkout_payment_with_http_info(project_id, payment_id)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <BillingGetCheckoutPayment200Response>
+  p data # => <GetCheckoutPayment200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_get_checkout_payment_with_http_info: #{e}"
+  puts "Error when calling BillingApi->get_checkout_payment_with_http_info: #{e}"
 end
 ```
 
@@ -270,7 +270,7 @@ end
 
 ### Return type
 
-[**BillingGetCheckoutPayment200Response**](BillingGetCheckoutPayment200Response.md)
+[**GetCheckoutPayment200Response**](GetCheckoutPayment200Response.md)
 
 ### Authorization
 
@@ -282,9 +282,9 @@ No authorization required
 - **Accept**: application/json
 
 
-## billing_get_public_plans
+## get_public_plans
 
-> <BillingGetPublicPlans200Response> billing_get_public_plans(project_id)
+> <GetPublicPlans200Response> get_public_plans(project_id)
 
 Get public plans (no auth required)
 
@@ -301,28 +301,28 @@ project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) to li
 
 begin
   # Get public plans (no auth required)
-  result = api_instance.billing_get_public_plans(project_id)
+  result = api_instance.get_public_plans(project_id)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_get_public_plans: #{e}"
+  puts "Error when calling BillingApi->get_public_plans: #{e}"
 end
 ```
 
-#### Using the billing_get_public_plans_with_http_info variant
+#### Using the get_public_plans_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<BillingGetPublicPlans200Response>, Integer, Hash)> billing_get_public_plans_with_http_info(project_id)
+> <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.billing_get_public_plans_with_http_info(project_id)
+  data, status_code, headers = api_instance.get_public_plans_with_http_info(project_id)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <BillingGetPublicPlans200Response>
+  p data # => <GetPublicPlans200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_get_public_plans_with_http_info: #{e}"
+  puts "Error when calling BillingApi->get_public_plans_with_http_info: #{e}"
 end
 ```
 
@@ -334,7 +334,7 @@ end
 
 ### Return type
 
-[**BillingGetPublicPlans200Response**](BillingGetPublicPlans200Response.md)
+[**GetPublicPlans200Response**](GetPublicPlans200Response.md)
 
 ### Authorization
 
@@ -346,9 +346,9 @@ No authorization required
 - **Accept**: application/json
 
 
-## billing_handle_crypto_webhook
+## handle_crypto_payment_webhook
 
-> <BillingHandleCryptoWebhook200Response> billing_handle_crypto_webhook(billing_handle_crypto_webhook_request)
+> <HandleCryptoPaymentWebhook200Response> handle_crypto_payment_webhook(handle_crypto_payment_webhook_request)
 
 Crypto payment processor webhook
 
@@ -361,32 +361,32 @@ require 'time'
 require 'mudbase'
 
 api_instance = Mudbase::BillingApi.new
-billing_handle_crypto_webhook_request = Mudbase::BillingHandleCryptoWebhookRequest.new({event: 'payment.created', data: Mudbase::BillingHandleCryptoWebhookRequestData.new}) # BillingHandleCryptoWebhookRequest | Crypto payment webhook payload (event type and data with paymentId, reference, amount, currency, network, status, metadata).
+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.billing_handle_crypto_webhook(billing_handle_crypto_webhook_request)
+  result = api_instance.handle_crypto_payment_webhook(handle_crypto_payment_webhook_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_handle_crypto_webhook: #{e}"
+  puts "Error when calling BillingApi->handle_crypto_payment_webhook: #{e}"
 end
 ```
 
-#### Using the billing_handle_crypto_webhook_with_http_info variant
+#### Using the handle_crypto_payment_webhook_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<BillingHandleCryptoWebhook200Response>, Integer, Hash)> billing_handle_crypto_webhook_with_http_info(billing_handle_crypto_webhook_request)
+> <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.billing_handle_crypto_webhook_with_http_info(billing_handle_crypto_webhook_request)
+  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 # => <BillingHandleCryptoWebhook200Response>
+  p data # => <HandleCryptoPaymentWebhook200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_handle_crypto_webhook_with_http_info: #{e}"
+  puts "Error when calling BillingApi->handle_crypto_payment_webhook_with_http_info: #{e}"
 end
 ```
 
@@ -394,11 +394,11 @@ end
 
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
-| **billing_handle_crypto_webhook_request** | [**BillingHandleCryptoWebhookRequest**](BillingHandleCryptoWebhookRequest.md) | Crypto payment webhook payload (event type and data with paymentId, reference, amount, currency, network, status, metadata). |  |
+| **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
 
-[**BillingHandleCryptoWebhook200Response**](BillingHandleCryptoWebhook200Response.md)
+[**HandleCryptoPaymentWebhook200Response**](HandleCryptoPaymentWebhook200Response.md)
 
 ### Authorization
 
@@ -410,9 +410,9 @@ No authorization required
 - **Accept**: application/json
 
 
-## billing_handle_flutterwave_webhook
+## handle_flutterwave_webhook
 
-> <BillingHandleCryptoWebhook200Response> billing_handle_flutterwave_webhook(billing_handle_flutterwave_webhook_request)
+> <HandleCryptoPaymentWebhook200Response> handle_flutterwave_webhook(handle_flutterwave_webhook_request)
 
 Flutterwave webhook
 
@@ -425,32 +425,32 @@ require 'time'
 require 'mudbase'
 
 api_instance = Mudbase::BillingApi.new
-billing_handle_flutterwave_webhook_request = Mudbase::BillingHandleFlutterwaveWebhookRequest.new # BillingHandleFlutterwaveWebhookRequest | Flutterwave webhook payload (event and data with id, tx_ref, amount, currency, status, customer, meta for subscription or payment-processing).
+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.billing_handle_flutterwave_webhook(billing_handle_flutterwave_webhook_request)
+  result = api_instance.handle_flutterwave_webhook(handle_flutterwave_webhook_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_handle_flutterwave_webhook: #{e}"
+  puts "Error when calling BillingApi->handle_flutterwave_webhook: #{e}"
 end
 ```
 
-#### Using the billing_handle_flutterwave_webhook_with_http_info variant
+#### Using the handle_flutterwave_webhook_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<BillingHandleCryptoWebhook200Response>, Integer, Hash)> billing_handle_flutterwave_webhook_with_http_info(billing_handle_flutterwave_webhook_request)
+> <Array(<HandleCryptoPaymentWebhook200Response>, Integer, Hash)> handle_flutterwave_webhook_with_http_info(handle_flutterwave_webhook_request)
 
 ```ruby
 begin
   # Flutterwave webhook
-  data, status_code, headers = api_instance.billing_handle_flutterwave_webhook_with_http_info(billing_handle_flutterwave_webhook_request)
+  data, status_code, headers = api_instance.handle_flutterwave_webhook_with_http_info(handle_flutterwave_webhook_request)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <BillingHandleCryptoWebhook200Response>
+  p data # => <HandleCryptoPaymentWebhook200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_handle_flutterwave_webhook_with_http_info: #{e}"
+  puts "Error when calling BillingApi->handle_flutterwave_webhook_with_http_info: #{e}"
 end
 ```
 
@@ -458,11 +458,11 @@ end
 
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
-| **billing_handle_flutterwave_webhook_request** | [**BillingHandleFlutterwaveWebhookRequest**](BillingHandleFlutterwaveWebhookRequest.md) | Flutterwave webhook payload (event and data with id, tx_ref, amount, currency, status, customer, meta for subscription or payment-processing). |  |
+| **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
 
-[**BillingHandleCryptoWebhook200Response**](BillingHandleCryptoWebhook200Response.md)
+[**HandleCryptoPaymentWebhook200Response**](HandleCryptoPaymentWebhook200Response.md)
 
 ### Authorization
 
@@ -474,11 +474,11 @@ No authorization required
 - **Accept**: application/json
 
 
-## billing_initialize_payment
+## initialize_payment_for_project
 
-> billing_initialize_payment(project_id, billing_initialize_payment_request)
+> initialize_payment_for_project(project_id, initialize_payment_for_project_request)
 
-Initialize fiat payment (app-scoped)
+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.
 
@@ -489,37 +489,37 @@ require 'time'
 require 'mudbase'
 # setup authorization
 Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
+  # 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.
-billing_initialize_payment_request = Mudbase::BillingInitializePaymentRequest.new({amount: 3.56, customer: Mudbase::BillingInitializePaymentRequestCustomer.new({email: 'email_example'})}) # BillingInitializePaymentRequest | Payment amount, currency, customer (email, name), and optional metadata.
+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 (app-scoped)
-  api_instance.billing_initialize_payment(project_id, billing_initialize_payment_request)
+  # 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->billing_initialize_payment: #{e}"
+  puts "Error when calling BillingApi->initialize_payment_for_project: #{e}"
 end
 ```
 
-#### Using the billing_initialize_payment_with_http_info variant
+#### 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)> billing_initialize_payment_with_http_info(project_id, billing_initialize_payment_request)
+> <Array(nil, Integer, Hash)> initialize_payment_for_project_with_http_info(project_id, initialize_payment_for_project_request)
 
 ```ruby
 begin
-  # Initialize fiat payment (app-scoped)
-  data, status_code, headers = api_instance.billing_initialize_payment_with_http_info(project_id, billing_initialize_payment_request)
+  # 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->billing_initialize_payment_with_http_info: #{e}"
+  puts "Error when calling BillingApi->initialize_payment_for_project_with_http_info: #{e}"
 end
 ```
 
@@ -528,7 +528,7 @@ end
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
 | **project_id** | **String** | Project ID for payment scope and tx_ref. |  |
-| **billing_initialize_payment_request** | [**BillingInitializePaymentRequest**](BillingInitializePaymentRequest.md) | Payment amount, currency, customer (email, name), and optional metadata. |  |
+| **initialize_payment_for_project_request** | [**InitializePaymentForProjectRequest**](InitializePaymentForProjectRequest.md) | Payment amount, currency, customer (email, name), and optional metadata. |  |
 
 ### Return type
 
@@ -536,7 +536,7 @@ nil (empty response body)
 
 ### Authorization
 
-[BearerToken](../README.md#BearerToken)
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
 
 ### HTTP request headers
 
@@ -544,9 +544,9 @@ nil (empty response body)
 - **Accept**: application/json
 
 
-## billing_record_usage
+## record_usage
 
-> <MessageResponse> billing_record_usage(project_id, billing_record_usage_request)
+> <MessageResponse> record_usage(project_id, record_usage_request)
 
 Record usage (public)
 
@@ -560,32 +560,32 @@ require 'mudbase'
 
 api_instance = Mudbase::BillingApi.new
 project_id = 'project_id_example' # String | Project ID (MongoDB ObjectId) for the billing project.
-billing_record_usage_request = Mudbase::BillingRecordUsageRequest.new({email: 'email_example', metric: 'metric_example', quantity: 3.56}) # BillingRecordUsageRequest | Customer email, metric name (e.g. api_calls, storage_mb), and quantity to record.
+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.billing_record_usage(project_id, billing_record_usage_request)
+  result = api_instance.record_usage(project_id, record_usage_request)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_record_usage: #{e}"
+  puts "Error when calling BillingApi->record_usage: #{e}"
 end
 ```
 
-#### Using the billing_record_usage_with_http_info variant
+#### 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)> billing_record_usage_with_http_info(project_id, billing_record_usage_request)
+> <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.billing_record_usage_with_http_info(project_id, billing_record_usage_request)
+  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->billing_record_usage_with_http_info: #{e}"
+  puts "Error when calling BillingApi->record_usage_with_http_info: #{e}"
 end
 ```
 
@@ -594,7 +594,7 @@ end
 | Name | Type | Description | Notes |
 | ---- | ---- | ----------- | ----- |
 | **project_id** | **String** | Project ID (MongoDB ObjectId) for the billing project. |  |
-| **billing_record_usage_request** | [**BillingRecordUsageRequest**](BillingRecordUsageRequest.md) | Customer email, metric name (e.g. api_calls, storage_mb), and quantity to record. |  |
+| **record_usage_request** | [**RecordUsageRequest**](RecordUsageRequest.md) | Customer email, metric name (e.g. api_calls, storage_mb), and quantity to record. |  |
 
 ### Return type
 
@@ -610,9 +610,9 @@ No authorization required
 - **Accept**: application/json
 
 
-## billing_verify_payment
+## verify_payment
 
-> <BillingVerifyPayment200Response> billing_verify_payment(project_id, reference)
+> <VerifyPayment200Response> verify_payment(project_id, reference)
 
 Verify payment and create subscription
 
@@ -630,28 +630,28 @@ reference = 'reference_example' # String | Payment reference (e.g. mudbase_abc12
 
 begin
   # Verify payment and create subscription
-  result = api_instance.billing_verify_payment(project_id, reference)
+  result = api_instance.verify_payment(project_id, reference)
   p result
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_verify_payment: #{e}"
+  puts "Error when calling BillingApi->verify_payment: #{e}"
 end
 ```
 
-#### Using the billing_verify_payment_with_http_info variant
+#### Using the verify_payment_with_http_info variant
 
 This returns an Array which contains the response data, status code and headers.
 
-> <Array(<BillingVerifyPayment200Response>, Integer, Hash)> billing_verify_payment_with_http_info(project_id, reference)
+> <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.billing_verify_payment_with_http_info(project_id, reference)
+  data, status_code, headers = api_instance.verify_payment_with_http_info(project_id, reference)
   p status_code # => 2xx
   p headers # => { ... }
-  p data # => <BillingVerifyPayment200Response>
+  p data # => <VerifyPayment200Response>
 rescue Mudbase::ApiError => e
-  puts "Error when calling BillingApi->billing_verify_payment_with_http_info: #{e}"
+  puts "Error when calling BillingApi->verify_payment_with_http_info: #{e}"
 end
 ```
 
@@ -664,7 +664,7 @@ end
 
 ### Return type
 
-[**BillingVerifyPayment200Response**](BillingVerifyPayment200Response.md)
+[**VerifyPayment200Response**](VerifyPayment200Response.md)
 
 ### Authorization