RubyGems - mudbase - Versions diffs - 1.2.12 → 1.3.0 - Mend

mudbase 1.2.12 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2558) hide show

data/docs/AuthApi.md DELETED Viewed

@@ -1,1261 +0,0 @@
-# Mudbase::AuthApi
-All URIs are relative to *https://cloud.mudbase.dev*
-| Method | HTTP request | Description |
-| ------ | ------------ | ----------- |
-| [**auth_confirm_password_reset**](AuthApi.md#auth_confirm_password_reset) | **POST** /api/auth/local/password-reset/confirm | Confirm password reset with OTP |
-| [**auth_convert_anonymous**](AuthApi.md#auth_convert_anonymous) | **POST** /api/auth/anonymous/convert | Convert anonymous account to full account |
-| [**auth_create_anonymous**](AuthApi.md#auth_create_anonymous) | **POST** /api/auth/anonymous | Create anonymous session |
-| [**auth_get_o_auth_providers**](AuthApi.md#auth_get_o_auth_providers) | **GET** /api/auth/oauth/providers/available | Get all available OAuth providers |
-| [**auth_get_session**](AuthApi.md#auth_get_session) | **GET** /api/auth/local/session | Get current session |
-| [**auth_login**](AuthApi.md#auth_login) | **POST** /api/auth/local/login | Login user |
-| [**auth_logout**](AuthApi.md#auth_logout) | **POST** /api/auth/local/logout | Logout user |
-| [**auth_oauth_callback**](AuthApi.md#auth_oauth_callback) | **GET** /api/auth/oauth/callback/{provider} | OAuth callback handler |
-| [**auth_oauth_initiate**](AuthApi.md#auth_oauth_initiate) | **GET** /api/auth/oauth/{provider}/{projectId} | Initiate OAuth authentication |
-| [**auth_refresh**](AuthApi.md#auth_refresh) | **POST** /api/auth/refresh | Refresh access token (dashboard and project) |
-| [**auth_register**](AuthApi.md#auth_register) | **POST** /api/auth/local/register | Register new user |
-| [**auth_request_password_reset**](AuthApi.md#auth_request_password_reset) | **POST** /api/auth/local/password-reset | Request password reset (OTP) |
-| [**auth_resend_verification**](AuthApi.md#auth_resend_verification) | **POST** /api/auth/resend-verification | Resend verification email (no auth) |
-| [**auth_reset_password**](AuthApi.md#auth_reset_password) | **POST** /api/auth/local/password-reset/{token} | Reset password with token (legacy) |
-| [**auth_send_magic_link**](AuthApi.md#auth_send_magic_link) | **POST** /api/auth/magic-link/send | Send magic link |
-| [**auth_send_otp**](AuthApi.md#auth_send_otp) | **POST** /api/auth/otp/send | Send OTP code |
-| [**auth_verify_email**](AuthApi.md#auth_verify_email) | **POST** /api/auth/verify-email | Verify email address (no auth) |
-| [**auth_verify_magic_link**](AuthApi.md#auth_verify_magic_link) | **POST** /api/auth/magic-link/verify | Verify magic link |
-| [**auth_verify_otp**](AuthApi.md#auth_verify_otp) | **POST** /api/auth/otp/verify | Verify OTP code |
-## auth_confirm_password_reset
-> <MessageResponse> auth_confirm_password_reset(auth_confirm_password_reset_request)
-Confirm password reset with OTP
-Set new password using the OTP sent to the user's email. Call after POST /api/auth/local/password-reset with projectId. Rate limited (OTP limit). If the user's email was not yet verified, it is marked as verified upon successful reset.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-auth_confirm_password_reset_request = Mudbase::AuthConfirmPasswordResetRequest.new({email: 'user@example.com', project_id: '685ad30be129932fbb7a1047', otp: '123456', new_password: 'NewSecurePass123!'}) # AuthConfirmPasswordResetRequest | Email, projectId, OTP code, and new password.
-begin
-  # Confirm password reset with OTP
-  result = api_instance.auth_confirm_password_reset(auth_confirm_password_reset_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_confirm_password_reset: #{e}"
-end
-```
-#### Using the auth_confirm_password_reset_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<MessageResponse>, Integer, Hash)> auth_confirm_password_reset_with_http_info(auth_confirm_password_reset_request)
-```ruby
-begin
-  # Confirm password reset with OTP
-  data, status_code, headers = api_instance.auth_confirm_password_reset_with_http_info(auth_confirm_password_reset_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <MessageResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_confirm_password_reset_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_confirm_password_reset_request** | [**AuthConfirmPasswordResetRequest**](AuthConfirmPasswordResetRequest.md) | Email, projectId, OTP code, and new password. |  |
-### Return type
-[**MessageResponse**](MessageResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_convert_anonymous
-> <AuthConvertAnonymous200Response> auth_convert_anonymous(auth_convert_anonymous_request)
-Convert anonymous account to full account
-Convert an anonymous user session to a full authenticated account. Preserves user data. Requires JWT Bearer token (BearerToken). API keys are not supported for this endpoint.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-# setup authorization
-Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
-  config.access_token = 'YOUR_BEARER_TOKEN'
-end
-api_instance = Mudbase::AuthApi.new
-auth_convert_anonymous_request = Mudbase::AuthConvertAnonymousRequest.new({email: 'user@example.com', password: 'SecurePassword123!'}) # AuthConvertAnonymousRequest | Email, password, and optional firstName, lastName for the new full account.
-begin
-  # Convert anonymous account to full account
-  result = api_instance.auth_convert_anonymous(auth_convert_anonymous_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_convert_anonymous: #{e}"
-end
-```
-#### Using the auth_convert_anonymous_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthConvertAnonymous200Response>, Integer, Hash)> auth_convert_anonymous_with_http_info(auth_convert_anonymous_request)
-```ruby
-begin
-  # Convert anonymous account to full account
-  data, status_code, headers = api_instance.auth_convert_anonymous_with_http_info(auth_convert_anonymous_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthConvertAnonymous200Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_convert_anonymous_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_convert_anonymous_request** | [**AuthConvertAnonymousRequest**](AuthConvertAnonymousRequest.md) | Email, password, and optional firstName, lastName for the new full account. |  |
-### Return type
-[**AuthConvertAnonymous200Response**](AuthConvertAnonymous200Response.md)
-### Authorization
-[BearerToken](../README.md#BearerToken)
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_create_anonymous
-> <AuthCreateAnonymous200Response> auth_create_anonymous(opts)
-Create anonymous session
-Create an anonymous user session for guest access. Users can later convert to full accounts.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-opts = {
-  auth_create_anonymous_request: Mudbase::AuthCreateAnonymousRequest.new # AuthCreateAnonymousRequest | Optional projectId and deviceId for the anonymous session.
-}
-begin
-  # Create anonymous session
-  result = api_instance.auth_create_anonymous(opts)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_create_anonymous: #{e}"
-end
-```
-#### Using the auth_create_anonymous_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthCreateAnonymous200Response>, Integer, Hash)> auth_create_anonymous_with_http_info(opts)
-```ruby
-begin
-  # Create anonymous session
-  data, status_code, headers = api_instance.auth_create_anonymous_with_http_info(opts)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthCreateAnonymous200Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_create_anonymous_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_create_anonymous_request** | [**AuthCreateAnonymousRequest**](AuthCreateAnonymousRequest.md) | Optional projectId and deviceId for the anonymous session. | [optional] |
-### Return type
-[**AuthCreateAnonymous200Response**](AuthCreateAnonymous200Response.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_get_o_auth_providers
-> <AuthGetOAuthProviders200Response> auth_get_o_auth_providers
-Get all available OAuth providers
-Returns a list of all supported OAuth providers with their configuration details
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-begin
-  # Get all available OAuth providers
-  result = api_instance.auth_get_o_auth_providers
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_get_o_auth_providers: #{e}"
-end
-```
-#### Using the auth_get_o_auth_providers_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthGetOAuthProviders200Response>, Integer, Hash)> auth_get_o_auth_providers_with_http_info
-```ruby
-begin
-  # Get all available OAuth providers
-  data, status_code, headers = api_instance.auth_get_o_auth_providers_with_http_info
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthGetOAuthProviders200Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_get_o_auth_providers_with_http_info: #{e}"
-end
-```
-### Parameters
-This endpoint does not need any parameter.
-### Return type
-[**AuthGetOAuthProviders200Response**](AuthGetOAuthProviders200Response.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: Not defined
-- **Accept**: application/json
-## auth_get_session
-> <AuthGetSession200Response> auth_get_session(project_id)
-Get current session
-Get the current authenticated user session. Requires JWT Bearer token (BearerToken). API keys are not supported for this endpoint.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-# setup authorization
-Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
-  config.access_token = 'YOUR_BEARER_TOKEN'
-end
-api_instance = Mudbase::AuthApi.new
-project_id = 'project_id_example' # String | Project ID to get session for.
-begin
-  # Get current session
-  result = api_instance.auth_get_session(project_id)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_get_session: #{e}"
-end
-```
-#### Using the auth_get_session_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthGetSession200Response>, Integer, Hash)> auth_get_session_with_http_info(project_id)
-```ruby
-begin
-  # Get current session
-  data, status_code, headers = api_instance.auth_get_session_with_http_info(project_id)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthGetSession200Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_get_session_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **project_id** | **String** | Project ID to get session for. |  |
-### Return type
-[**AuthGetSession200Response**](AuthGetSession200Response.md)
-### Authorization
-[BearerToken](../README.md#BearerToken)
-### HTTP request headers
-- **Content-Type**: Not defined
-- **Accept**: application/json
-## auth_login
-> <AuthLogin200Response> auth_login(auth_login_request)
-Login user
-When the project has **requireEmailVerification** enabled and the user has not verified their email, returns 403 with code **EMAIL_VERIFICATION_REQUIRED** (user must verify email first, then login again).
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-auth_login_request = Mudbase::AuthLoginRequest.new({email: 'email_example', password: 'password_example'}) # AuthLoginRequest | Login credentials (email, password) and project ID.
-begin
-  # Login user
-  result = api_instance.auth_login(auth_login_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_login: #{e}"
-end
-```
-#### Using the auth_login_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthLogin200Response>, Integer, Hash)> auth_login_with_http_info(auth_login_request)
-```ruby
-begin
-  # Login user
-  data, status_code, headers = api_instance.auth_login_with_http_info(auth_login_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthLogin200Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_login_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_login_request** | [**AuthLoginRequest**](AuthLoginRequest.md) | Login credentials (email, password) and project ID. |  |
-### Return type
-[**AuthLogin200Response**](AuthLogin200Response.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_logout
-> <MessageResponse> auth_logout
-Logout user
-Logout the current authenticated user session. Requires JWT Bearer token (BearerToken). API keys are not supported for this endpoint.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-# setup authorization
-Mudbase.configure do |config|
-  # Configure Bearer authorization (JWT): BearerToken
-  config.access_token = 'YOUR_BEARER_TOKEN'
-end
-api_instance = Mudbase::AuthApi.new
-begin
-  # Logout user
-  result = api_instance.auth_logout
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_logout: #{e}"
-end
-```
-#### Using the auth_logout_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<MessageResponse>, Integer, Hash)> auth_logout_with_http_info
-```ruby
-begin
-  # Logout user
-  data, status_code, headers = api_instance.auth_logout_with_http_info
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <MessageResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_logout_with_http_info: #{e}"
-end
-```
-### Parameters
-This endpoint does not need any parameter.
-### Return type
-[**MessageResponse**](MessageResponse.md)
-### Authorization
-[BearerToken](../README.md#BearerToken)
-### HTTP request headers
-- **Content-Type**: Not defined
-- **Accept**: application/json
-## auth_oauth_callback
-> <AuthOauthCallback200Response> auth_oauth_callback(provider)
-OAuth callback handler
-OAuth provider redirects the user here after consent. The server exchanges the code for tokens, creates or finds the user, and redirects to the client with token, refreshToken, and expiresIn in query params.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-provider = 'provider_example' # String | OAuth provider identifier (e.g. google, github).
-begin
-  # OAuth callback handler
-  result = api_instance.auth_oauth_callback(provider)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_oauth_callback: #{e}"
-end
-```
-#### Using the auth_oauth_callback_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthOauthCallback200Response>, Integer, Hash)> auth_oauth_callback_with_http_info(provider)
-```ruby
-begin
-  # OAuth callback handler
-  data, status_code, headers = api_instance.auth_oauth_callback_with_http_info(provider)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthOauthCallback200Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_oauth_callback_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **provider** | **String** | OAuth provider identifier (e.g. google, github). |  |
-### Return type
-[**AuthOauthCallback200Response**](AuthOauthCallback200Response.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: Not defined
-- **Accept**: application/json
-## auth_oauth_initiate
-> <AuthOauthInitiate200Response> auth_oauth_initiate(provider, project_id, opts)
-Initiate OAuth authentication
-Initiates OAuth authentication flow for a specified provider and project. The OAuth provider must be configured and enabled for the project first. After user authentication, redirects to the OAuth provider's consent screen.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-provider = 'google' # String | OAuth provider identifier (e.g. google, github).
-project_id = '685ad30be129932fbb7a1047' # String | Project ID for which OAuth is configured.
-opts = {
-  redirect_url: 'https://client.app/auth/callback' # String | The URL to redirect to after authentication. Must be pre-registered in project settings.
-}
-begin
-  # Initiate OAuth authentication
-  result = api_instance.auth_oauth_initiate(provider, project_id, opts)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_oauth_initiate: #{e}"
-end
-```
-#### Using the auth_oauth_initiate_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthOauthInitiate200Response>, Integer, Hash)> auth_oauth_initiate_with_http_info(provider, project_id, opts)
-```ruby
-begin
-  # Initiate OAuth authentication
-  data, status_code, headers = api_instance.auth_oauth_initiate_with_http_info(provider, project_id, opts)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthOauthInitiate200Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_oauth_initiate_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **provider** | **String** | OAuth provider identifier (e.g. google, github). |  |
-| **project_id** | **String** | Project ID for which OAuth is configured. |  |
-| **redirect_url** | **String** | The URL to redirect to after authentication. Must be pre-registered in project settings. | [optional] |
-### Return type
-[**AuthOauthInitiate200Response**](AuthOauthInitiate200Response.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: Not defined
-- **Accept**: application/json
-## auth_refresh
-> <AuthRefresh200Response> auth_refresh(auth_refresh_request)
-Refresh access token (dashboard and project)
-Exchange a valid refresh token for a new JWT access token and refresh token. Works for both **dashboard** (builder console) and **app** (end-user) auth; the same endpoint is used. The previous refresh token is invalidated (rotation). If the same refresh token is used again, the session is revoked (reuse detection).
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-auth_refresh_request = Mudbase::AuthRefreshRequest.new({refresh_token: 'refresh_token_example'}) # AuthRefreshRequest | JSON body containing the refresh token to exchange for a new access token and refresh token (token rotation).
-begin
-  # Refresh access token (dashboard and project)
-  result = api_instance.auth_refresh(auth_refresh_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_refresh: #{e}"
-end
-```
-#### Using the auth_refresh_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthRefresh200Response>, Integer, Hash)> auth_refresh_with_http_info(auth_refresh_request)
-```ruby
-begin
-  # Refresh access token (dashboard and project)
-  data, status_code, headers = api_instance.auth_refresh_with_http_info(auth_refresh_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthRefresh200Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_refresh_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_refresh_request** | [**AuthRefreshRequest**](AuthRefreshRequest.md) | JSON body containing the refresh token to exchange for a new access token and refresh token (token rotation). |  |
-### Return type
-[**AuthRefresh200Response**](AuthRefresh200Response.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_register
-> <AuthRegister201Response> auth_register(auth_register_request)
-Register new user
-When the project has **requireEmailVerification** enabled (default), the response is 201 with **requireVerification: true** and **no token**; the user must verify their email then sign in via login. When email verification is disabled, a token and refreshToken are returned.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-auth_register_request = Mudbase::AuthRegisterRequest.new({email: 'email_example', password: 'password_example', first_name: 'first_name_example', last_name: 'last_name_example', project_id: 'project_id_example'}) # AuthRegisterRequest | Registration payload (email, password, firstName, lastName, projectId).
-begin
-  # Register new user
-  result = api_instance.auth_register(auth_register_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_register: #{e}"
-end
-```
-#### Using the auth_register_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthRegister201Response>, Integer, Hash)> auth_register_with_http_info(auth_register_request)
-```ruby
-begin
-  # Register new user
-  data, status_code, headers = api_instance.auth_register_with_http_info(auth_register_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthRegister201Response>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_register_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_register_request** | [**AuthRegisterRequest**](AuthRegisterRequest.md) | Registration payload (email, password, firstName, lastName, projectId). |  |
-### Return type
-[**AuthRegister201Response**](AuthRegister201Response.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_request_password_reset
-> <MessageResponse> auth_request_password_reset(auth_request_password_reset_request)
-Request password reset (OTP)
-When projectId is provided, sends a 6-digit OTP to the user's email (app reset uses OTP, not link). When projectId is omitted, sends a token link (org/platform local account). Rate limited.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-auth_request_password_reset_request = Mudbase::AuthRequestPasswordResetRequest.new({email: 'user@example.com'}) # AuthRequestPasswordResetRequest | Email and optional projectId for app OTP or org token link.
-begin
-  # Request password reset (OTP)
-  result = api_instance.auth_request_password_reset(auth_request_password_reset_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_request_password_reset: #{e}"
-end
-```
-#### Using the auth_request_password_reset_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<MessageResponse>, Integer, Hash)> auth_request_password_reset_with_http_info(auth_request_password_reset_request)
-```ruby
-begin
-  # Request password reset (OTP)
-  data, status_code, headers = api_instance.auth_request_password_reset_with_http_info(auth_request_password_reset_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <MessageResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_request_password_reset_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_request_password_reset_request** | [**AuthRequestPasswordResetRequest**](AuthRequestPasswordResetRequest.md) | Email and optional projectId for app OTP or org token link. |  |
-### Return type
-[**MessageResponse**](MessageResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_resend_verification
-> <MessageResponse> auth_resend_verification(auth_resend_verification_request)
-Resend verification email (no auth)
-Sends a new verification email to the given email (and optional project). For unauthenticated users who have not verified yet. Rate limited (e.g. 3 per 15 min per IP).
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-auth_resend_verification_request = Mudbase::AuthResendVerificationRequest.new({email: 'email_example'}) # AuthResendVerificationRequest | Email address to resend to; optional `projectId` for project-scoped verification links.
-begin
-  # Resend verification email (no auth)
-  result = api_instance.auth_resend_verification(auth_resend_verification_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_resend_verification: #{e}"
-end
-```
-#### Using the auth_resend_verification_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<MessageResponse>, Integer, Hash)> auth_resend_verification_with_http_info(auth_resend_verification_request)
-```ruby
-begin
-  # Resend verification email (no auth)
-  data, status_code, headers = api_instance.auth_resend_verification_with_http_info(auth_resend_verification_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <MessageResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_resend_verification_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_resend_verification_request** | [**AuthResendVerificationRequest**](AuthResendVerificationRequest.md) | Email address to resend to; optional &#x60;projectId&#x60; for project-scoped verification links. |  |
-### Return type
-[**MessageResponse**](MessageResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_reset_password
-> <MessageResponse> auth_reset_password(token, auth_reset_password_request)
-Reset password with token (legacy)
-Legacy token-based completion. Prefer OTP flow: use POST .../password-reset/confirm with the OTP sent to email for app resets.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-token = 'token_example' # String | Password reset token from email link.
-auth_reset_password_request = Mudbase::AuthResetPasswordRequest.new({password: 'NewSecurePass123!'}) # AuthResetPasswordRequest | New password and optional projectId.
-begin
-  # Reset password with token (legacy)
-  result = api_instance.auth_reset_password(token, auth_reset_password_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_reset_password: #{e}"
-end
-```
-#### Using the auth_reset_password_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<MessageResponse>, Integer, Hash)> auth_reset_password_with_http_info(token, auth_reset_password_request)
-```ruby
-begin
-  # Reset password with token (legacy)
-  data, status_code, headers = api_instance.auth_reset_password_with_http_info(token, auth_reset_password_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <MessageResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_reset_password_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **token** | **String** | Password reset token from email link. |  |
-| **auth_reset_password_request** | [**AuthResetPasswordRequest**](AuthResetPasswordRequest.md) | New password and optional projectId. |  |
-### Return type
-[**MessageResponse**](MessageResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_send_magic_link
-> <MessageResponse> auth_send_magic_link(magic_link_request)
-Send magic link
-Sends a one-time magic link to the given email for the project. The user clicks the link and is authenticated without a password. Use verify endpoint with the token from the link. Public endpoint; rate limited.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-magic_link_request = Mudbase::MagicLinkRequest.new({email: 'email_example', project_id: 'project_id_example'}) # MagicLinkRequest | Email, projectId, and optional redirect URL for the magic link.
-begin
-  # Send magic link
-  result = api_instance.auth_send_magic_link(magic_link_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_send_magic_link: #{e}"
-end
-```
-#### Using the auth_send_magic_link_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<MessageResponse>, Integer, Hash)> auth_send_magic_link_with_http_info(magic_link_request)
-```ruby
-begin
-  # Send magic link
-  data, status_code, headers = api_instance.auth_send_magic_link_with_http_info(magic_link_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <MessageResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_send_magic_link_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **magic_link_request** | [**MagicLinkRequest**](MagicLinkRequest.md) | Email, projectId, and optional redirect URL for the magic link. |  |
-### Return type
-[**MessageResponse**](MessageResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_send_otp
-> <MessageResponse> auth_send_otp(otp_send_request)
-Send OTP code
-Sends a one-time code via SMS or email for the given project. Use verify endpoint to exchange the code for a session. Public endpoint; rate limited.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-otp_send_request = Mudbase::OTPSendRequest.new({project_id: 'project_id_example', method: 'sms'}) # OTPSendRequest | Project ID, delivery method (sms/email), and phone or email.
-begin
-  # Send OTP code
-  result = api_instance.auth_send_otp(otp_send_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_send_otp: #{e}"
-end
-```
-#### Using the auth_send_otp_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<MessageResponse>, Integer, Hash)> auth_send_otp_with_http_info(otp_send_request)
-```ruby
-begin
-  # Send OTP code
-  data, status_code, headers = api_instance.auth_send_otp_with_http_info(otp_send_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <MessageResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_send_otp_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **otp_send_request** | [**OTPSendRequest**](OTPSendRequest.md) | Project ID, delivery method (sms/email), and phone or email. |  |
-### Return type
-[**MessageResponse**](MessageResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_verify_email
-> <MessageResponse> auth_verify_email(auth_verify_email_request)
-Verify email address (no auth)
-Verifies the user's email using the token from the link sent at signup. Use for project-scoped or general signup flows (unauthenticated). Same behavior as POST /api/users/verify-email.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-auth_verify_email_request = Mudbase::AuthVerifyEmailRequest.new({token: 'token_example'}) # AuthVerifyEmailRequest | Verification token from the email link; optional `projectId` for project-scoped signup.
-begin
-  # Verify email address (no auth)
-  result = api_instance.auth_verify_email(auth_verify_email_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_verify_email: #{e}"
-end
-```
-#### Using the auth_verify_email_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<MessageResponse>, Integer, Hash)> auth_verify_email_with_http_info(auth_verify_email_request)
-```ruby
-begin
-  # Verify email address (no auth)
-  data, status_code, headers = api_instance.auth_verify_email_with_http_info(auth_verify_email_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <MessageResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_verify_email_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_verify_email_request** | [**AuthVerifyEmailRequest**](AuthVerifyEmailRequest.md) | Verification token from the email link; optional &#x60;projectId&#x60; for project-scoped signup. |  |
-### Return type
-[**MessageResponse**](MessageResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_verify_magic_link
-> <AuthResponse> auth_verify_magic_link(auth_verify_magic_link_request)
-Verify magic link
-Exchanges the magic link token (from the link sent by send) for a session. Returns token and user on success. Token is short-lived and single-use.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-auth_verify_magic_link_request = Mudbase::AuthVerifyMagicLinkRequest.new({token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6InVzZXJAZXhhbXBsZS5jb20iLCJwcm9qZWN0SWQiOiI2ODVhZDMwYmUxMjk5MzJmYmI3YTEwNDciLCJpYXQiOjE3NTA3ODA4OTgsImV4cCI6MTc1MDc4NDQ5OH0.example'}) # AuthVerifyMagicLinkRequest | The token from the magic link URL.
-begin
-  # Verify magic link
-  result = api_instance.auth_verify_magic_link(auth_verify_magic_link_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_verify_magic_link: #{e}"
-end
-```
-#### Using the auth_verify_magic_link_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthResponse>, Integer, Hash)> auth_verify_magic_link_with_http_info(auth_verify_magic_link_request)
-```ruby
-begin
-  # Verify magic link
-  data, status_code, headers = api_instance.auth_verify_magic_link_with_http_info(auth_verify_magic_link_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_verify_magic_link_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **auth_verify_magic_link_request** | [**AuthVerifyMagicLinkRequest**](AuthVerifyMagicLinkRequest.md) | The token from the magic link URL. |  |
-### Return type
-[**AuthResponse**](AuthResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json
-## auth_verify_otp
-> <AuthResponse> auth_verify_otp(otp_verify_request)
-Verify OTP code
-Verifies the OTP code and returns a session token and user. Public endpoint.
-### Examples
-```ruby
-require 'time'
-require 'mudbase'
-api_instance = Mudbase::AuthApi.new
-otp_verify_request = Mudbase::OTPVerifyRequest.new({otp: 'otp_example', project_id: 'project_id_example'}) # OTPVerifyRequest | Identifier (phone/email), OTP code, and project ID.
-begin
-  # Verify OTP code
-  result = api_instance.auth_verify_otp(otp_verify_request)
-  p result
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_verify_otp: #{e}"
-end
-```
-#### Using the auth_verify_otp_with_http_info variant
-This returns an Array which contains the response data, status code and headers.
-> <Array(<AuthResponse>, Integer, Hash)> auth_verify_otp_with_http_info(otp_verify_request)
-```ruby
-begin
-  # Verify OTP code
-  data, status_code, headers = api_instance.auth_verify_otp_with_http_info(otp_verify_request)
-  p status_code # => 2xx
-  p headers # => { ... }
-  p data # => <AuthResponse>
-rescue Mudbase::ApiError => e
-  puts "Error when calling AuthApi->auth_verify_otp_with_http_info: #{e}"
-end
-```
-### Parameters
-| Name | Type | Description | Notes |
-| ---- | ---- | ----------- | ----- |
-| **otp_verify_request** | [**OTPVerifyRequest**](OTPVerifyRequest.md) | Identifier (phone/email), OTP code, and project ID. |  |
-### Return type
-[**AuthResponse**](AuthResponse.md)
-### Authorization
-No authorization required
-### HTTP request headers
-- **Content-Type**: application/json
-- **Accept**: application/json