mudbase 1.1.4

data/docs/AuthenticationApi.md

@@ -0,0 +1,1066 @@
+# Mudbase::AuthenticationApi
+
+All URIs are relative to *https://cloud.mudbase.dev*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**confirm_local_password_reset_with_otp**](AuthenticationApi.md#confirm_local_password_reset_with_otp) | **POST** /api/auth/local/password-reset/confirm | Confirm password reset with OTP (project-based) |
+| [**convert_anonymous_account**](AuthenticationApi.md#convert_anonymous_account) | **POST** /api/auth/anonymous/convert | Convert anonymous account to full account |
+| [**create_anonymous_session**](AuthenticationApi.md#create_anonymous_session) | **POST** /api/auth/anonymous | Create anonymous session |
+| [**get_available_o_auth_providers**](AuthenticationApi.md#get_available_o_auth_providers) | **GET** /api/auth/oauth/providers/available | Get all available OAuth providers |
+| [**get_local_session**](AuthenticationApi.md#get_local_session) | **GET** /api/auth/local/session | Get current session (project-based) |
+| [**initiate_o_auth**](AuthenticationApi.md#initiate_o_auth) | **GET** /api/auth/oauth/{provider}/{projectId} | Initiate OAuth authentication |
+| [**login_local_user**](AuthenticationApi.md#login_local_user) | **POST** /api/auth/local/login | Login user (project-based) |
+| [**logout_local_user**](AuthenticationApi.md#logout_local_user) | **POST** /api/auth/local/logout | Logout user (project-based) |
+| [**oauth_callback**](AuthenticationApi.md#oauth_callback) | **GET** /api/auth/oauth/callback/{provider} | OAuth callback handler |
+| [**register_local_user**](AuthenticationApi.md#register_local_user) | **POST** /api/auth/local/register | Register new user (project-based) |
+| [**request_local_password_reset**](AuthenticationApi.md#request_local_password_reset) | **POST** /api/auth/local/password-reset | Request password reset (project-based, OTP) |
+| [**reset_local_password**](AuthenticationApi.md#reset_local_password) | **POST** /api/auth/local/password-reset/{token} | Reset password with token (project-based, legacy) |
+| [**send_magic_link**](AuthenticationApi.md#send_magic_link) | **POST** /api/auth/magic-link/send | Send magic link |
+| [**send_otp**](AuthenticationApi.md#send_otp) | **POST** /api/auth/otp/send | Send OTP code |
+| [**verify_magic_link**](AuthenticationApi.md#verify_magic_link) | **POST** /api/auth/magic-link/verify | Verify magic link |
+| [**verify_otp**](AuthenticationApi.md#verify_otp) | **POST** /api/auth/otp/verify | Verify OTP code |
+
+
+## confirm_local_password_reset_with_otp
+
+> <MessageResponse> confirm_local_password_reset_with_otp(confirm_local_password_reset_with_otp_request)
+
+Confirm password reset with OTP (project-based)
+
+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::AuthenticationApi.new
+confirm_local_password_reset_with_otp_request = Mudbase::ConfirmLocalPasswordResetWithOtpRequest.new({email: 'user@example.com', project_id: '685ad30be129932fbb7a1047', otp: '123456', new_password: 'NewSecurePass123!'}) # ConfirmLocalPasswordResetWithOtpRequest | Email, projectId, OTP code, and new password.
+
+begin
+  # Confirm password reset with OTP (project-based)
+  result = api_instance.confirm_local_password_reset_with_otp(confirm_local_password_reset_with_otp_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->confirm_local_password_reset_with_otp: #{e}"
+end
+```
+
+#### Using the confirm_local_password_reset_with_otp_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> confirm_local_password_reset_with_otp_with_http_info(confirm_local_password_reset_with_otp_request)
+
+```ruby
+begin
+  # Confirm password reset with OTP (project-based)
+  data, status_code, headers = api_instance.confirm_local_password_reset_with_otp_with_http_info(confirm_local_password_reset_with_otp_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->confirm_local_password_reset_with_otp_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **confirm_local_password_reset_with_otp_request** | [**ConfirmLocalPasswordResetWithOtpRequest**](ConfirmLocalPasswordResetWithOtpRequest.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
+
+
+## convert_anonymous_account
+
+> <ConvertAnonymousAccount200Response> convert_anonymous_account(convert_anonymous_account_request)
+
+Convert anonymous account to full account
+
+Convert an anonymous user session to a full authenticated account. Preserves user data. Requires JWT Bearer token (ProjectBearerAuth). API keys are not supported for this endpoint. 
+
+### 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::AuthenticationApi.new
+convert_anonymous_account_request = Mudbase::ConvertAnonymousAccountRequest.new({email: 'user@example.com', password: 'SecurePassword123!'}) # ConvertAnonymousAccountRequest | Email, password, and optional firstName, lastName for the new full account.
+
+begin
+  # Convert anonymous account to full account
+  result = api_instance.convert_anonymous_account(convert_anonymous_account_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->convert_anonymous_account: #{e}"
+end
+```
+
+#### Using the convert_anonymous_account_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ConvertAnonymousAccount200Response>, Integer, Hash)> convert_anonymous_account_with_http_info(convert_anonymous_account_request)
+
+```ruby
+begin
+  # Convert anonymous account to full account
+  data, status_code, headers = api_instance.convert_anonymous_account_with_http_info(convert_anonymous_account_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ConvertAnonymousAccount200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->convert_anonymous_account_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **convert_anonymous_account_request** | [**ConvertAnonymousAccountRequest**](ConvertAnonymousAccountRequest.md) | Email, password, and optional firstName, lastName for the new full account. |  |
+
+### Return type
+
+[**ConvertAnonymousAccount200Response**](ConvertAnonymousAccount200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## create_anonymous_session
+
+> <CreateAnonymousSession200Response> create_anonymous_session(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::AuthenticationApi.new
+opts = {
+  create_anonymous_session_request: Mudbase::CreateAnonymousSessionRequest.new # CreateAnonymousSessionRequest | Optional projectId and deviceId for the anonymous session.
+}
+
+begin
+  # Create anonymous session
+  result = api_instance.create_anonymous_session(opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->create_anonymous_session: #{e}"
+end
+```
+
+#### Using the create_anonymous_session_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<CreateAnonymousSession200Response>, Integer, Hash)> create_anonymous_session_with_http_info(opts)
+
+```ruby
+begin
+  # Create anonymous session
+  data, status_code, headers = api_instance.create_anonymous_session_with_http_info(opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <CreateAnonymousSession200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->create_anonymous_session_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **create_anonymous_session_request** | [**CreateAnonymousSessionRequest**](CreateAnonymousSessionRequest.md) | Optional projectId and deviceId for the anonymous session. | [optional] |
+
+### Return type
+
+[**CreateAnonymousSession200Response**](CreateAnonymousSession200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## get_available_o_auth_providers
+
+> <GetAvailableOAuthProviders200Response> get_available_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::AuthenticationApi.new
+
+begin
+  # Get all available OAuth providers
+  result = api_instance.get_available_o_auth_providers
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->get_available_o_auth_providers: #{e}"
+end
+```
+
+#### Using the get_available_o_auth_providers_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetAvailableOAuthProviders200Response>, Integer, Hash)> get_available_o_auth_providers_with_http_info
+
+```ruby
+begin
+  # Get all available OAuth providers
+  data, status_code, headers = api_instance.get_available_o_auth_providers_with_http_info
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetAvailableOAuthProviders200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->get_available_o_auth_providers_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**GetAvailableOAuthProviders200Response**](GetAvailableOAuthProviders200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_local_session
+
+> <GetLocalSession200Response> get_local_session(project_id)
+
+Get current session (project-based)
+
+Get the current authenticated user session (project-based). Requires JWT Bearer token (ProjectBearerAuth). API keys are not supported for this endpoint. 
+
+### 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::AuthenticationApi.new
+project_id = 'project_id_example' # String | Project ID to get session for.
+
+begin
+  # Get current session (project-based)
+  result = api_instance.get_local_session(project_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->get_local_session: #{e}"
+end
+```
+
+#### Using the get_local_session_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetLocalSession200Response>, Integer, Hash)> get_local_session_with_http_info(project_id)
+
+```ruby
+begin
+  # Get current session (project-based)
+  data, status_code, headers = api_instance.get_local_session_with_http_info(project_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetLocalSession200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->get_local_session_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID to get session for. |  |
+
+### Return type
+
+[**GetLocalSession200Response**](GetLocalSession200Response.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## initiate_o_auth
+
+> <InitiateOAuth200Response> initiate_o_auth(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::AuthenticationApi.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.initiate_o_auth(provider, project_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->initiate_o_auth: #{e}"
+end
+```
+
+#### Using the initiate_o_auth_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<InitiateOAuth200Response>, Integer, Hash)> initiate_o_auth_with_http_info(provider, project_id, opts)
+
+```ruby
+begin
+  # Initiate OAuth authentication
+  data, status_code, headers = api_instance.initiate_o_auth_with_http_info(provider, project_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <InitiateOAuth200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->initiate_o_auth_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
+
+[**InitiateOAuth200Response**](InitiateOAuth200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## login_local_user
+
+> <LoginLocalUser200Response> login_local_user(login_local_user_request)
+
+Login user (project-based)
+
+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::AuthenticationApi.new
+login_local_user_request = Mudbase::LoginLocalUserRequest.new({email: 'email_example', password: 'password_example'}) # LoginLocalUserRequest | Login credentials (email, password) and project ID.
+
+begin
+  # Login user (project-based)
+  result = api_instance.login_local_user(login_local_user_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->login_local_user: #{e}"
+end
+```
+
+#### Using the login_local_user_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<LoginLocalUser200Response>, Integer, Hash)> login_local_user_with_http_info(login_local_user_request)
+
+```ruby
+begin
+  # Login user (project-based)
+  data, status_code, headers = api_instance.login_local_user_with_http_info(login_local_user_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <LoginLocalUser200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->login_local_user_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **login_local_user_request** | [**LoginLocalUserRequest**](LoginLocalUserRequest.md) | Login credentials (email, password) and project ID. |  |
+
+### Return type
+
+[**LoginLocalUser200Response**](LoginLocalUser200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## logout_local_user
+
+> <MessageResponse> logout_local_user
+
+Logout user (project-based)
+
+Logout the current authenticated user session (project-based). Requires JWT Bearer token (ProjectBearerAuth). API keys are not supported for this endpoint. 
+
+### 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::AuthenticationApi.new
+
+begin
+  # Logout user (project-based)
+  result = api_instance.logout_local_user
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->logout_local_user: #{e}"
+end
+```
+
+#### Using the logout_local_user_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> logout_local_user_with_http_info
+
+```ruby
+begin
+  # Logout user (project-based)
+  data, status_code, headers = api_instance.logout_local_user_with_http_info
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->logout_local_user_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**MessageResponse**](MessageResponse.md)
+
+### Authorization
+
+[ProjectBearerAuth](../README.md#ProjectBearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## oauth_callback
+
+> <OauthCallback200Response> 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 (or error) in query or fragment. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::AuthenticationApi.new
+provider = 'provider_example' # String | OAuth provider identifier (e.g. google, github).
+
+begin
+  # OAuth callback handler
+  result = api_instance.oauth_callback(provider)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->oauth_callback: #{e}"
+end
+```
+
+#### Using the oauth_callback_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<OauthCallback200Response>, Integer, Hash)> oauth_callback_with_http_info(provider)
+
+```ruby
+begin
+  # OAuth callback handler
+  data, status_code, headers = api_instance.oauth_callback_with_http_info(provider)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <OauthCallback200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->oauth_callback_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **provider** | **String** | OAuth provider identifier (e.g. google, github). |  |
+
+### Return type
+
+[**OauthCallback200Response**](OauthCallback200Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## register_local_user
+
+> <RegisterLocalUser201Response> register_local_user(register_local_user_request)
+
+Register new user (project-based)
+
+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::AuthenticationApi.new
+register_local_user_request = Mudbase::RegisterLocalUserRequest.new({email: 'email_example', password: 'password_example', first_name: 'first_name_example', last_name: 'last_name_example', project_id: 'project_id_example'}) # RegisterLocalUserRequest | Registration payload (email, password, firstName, lastName, projectId).
+
+begin
+  # Register new user (project-based)
+  result = api_instance.register_local_user(register_local_user_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->register_local_user: #{e}"
+end
+```
+
+#### Using the register_local_user_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<RegisterLocalUser201Response>, Integer, Hash)> register_local_user_with_http_info(register_local_user_request)
+
+```ruby
+begin
+  # Register new user (project-based)
+  data, status_code, headers = api_instance.register_local_user_with_http_info(register_local_user_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <RegisterLocalUser201Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->register_local_user_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **register_local_user_request** | [**RegisterLocalUserRequest**](RegisterLocalUserRequest.md) | Registration payload (email, password, firstName, lastName, projectId). |  |
+
+### Return type
+
+[**RegisterLocalUser201Response**](RegisterLocalUser201Response.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## request_local_password_reset
+
+> <MessageResponse> request_local_password_reset(request_local_password_reset_request)
+
+Request password reset (project-based, OTP)
+
+When projectId is provided, sends a 6-digit OTP to the user's email (project-based 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::AuthenticationApi.new
+request_local_password_reset_request = Mudbase::RequestLocalPasswordResetRequest.new({email: 'user@example.com'}) # RequestLocalPasswordResetRequest | Email and optional projectId for project-based OTP or org token link.
+
+begin
+  # Request password reset (project-based, OTP)
+  result = api_instance.request_local_password_reset(request_local_password_reset_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->request_local_password_reset: #{e}"
+end
+```
+
+#### Using the request_local_password_reset_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> request_local_password_reset_with_http_info(request_local_password_reset_request)
+
+```ruby
+begin
+  # Request password reset (project-based, OTP)
+  data, status_code, headers = api_instance.request_local_password_reset_with_http_info(request_local_password_reset_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->request_local_password_reset_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **request_local_password_reset_request** | [**RequestLocalPasswordResetRequest**](RequestLocalPasswordResetRequest.md) | Email and optional projectId for project-based OTP or org token link. |  |
+
+### Return type
+
+[**MessageResponse**](MessageResponse.md)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## reset_local_password
+
+> <MessageResponse> reset_local_password(token, reset_local_password_request)
+
+Reset password with token (project-based, legacy)
+
+Legacy token-based completion. Prefer OTP flow: use POST .../password-reset/confirm with the OTP sent to email for project-based resets. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::AuthenticationApi.new
+token = 'token_example' # String | Password reset token from email link.
+reset_local_password_request = Mudbase::ResetLocalPasswordRequest.new({password: 'NewSecurePass123!'}) # ResetLocalPasswordRequest | New password and optional projectId.
+
+begin
+  # Reset password with token (project-based, legacy)
+  result = api_instance.reset_local_password(token, reset_local_password_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->reset_local_password: #{e}"
+end
+```
+
+#### Using the reset_local_password_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> reset_local_password_with_http_info(token, reset_local_password_request)
+
+```ruby
+begin
+  # Reset password with token (project-based, legacy)
+  data, status_code, headers = api_instance.reset_local_password_with_http_info(token, reset_local_password_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->reset_local_password_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **token** | **String** | Password reset token from email link. |  |
+| **reset_local_password_request** | [**ResetLocalPasswordRequest**](ResetLocalPasswordRequest.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
+
+
+## send_magic_link
+
+> <MessageResponse> 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::AuthenticationApi.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.send_magic_link(magic_link_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->send_magic_link: #{e}"
+end
+```
+
+#### Using the send_magic_link_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> send_magic_link_with_http_info(magic_link_request)
+
+```ruby
+begin
+  # Send magic link
+  data, status_code, headers = api_instance.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 AuthenticationApi->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
+
+
+## send_otp
+
+> <MessageResponse> 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::AuthenticationApi.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.send_otp(otp_send_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->send_otp: #{e}"
+end
+```
+
+#### Using the send_otp_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> send_otp_with_http_info(otp_send_request)
+
+```ruby
+begin
+  # Send OTP code
+  data, status_code, headers = api_instance.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 AuthenticationApi->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
+
+
+## verify_magic_link
+
+> <AuthResponse> verify_magic_link(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::AuthenticationApi.new
+verify_magic_link_request = Mudbase::VerifyMagicLinkRequest.new({token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6InVzZXJAZXhhbXBsZS5jb20iLCJwcm9qZWN0SWQiOiI2ODVhZDMwYmUxMjk5MzJmYmI3YTEwNDciLCJpYXQiOjE3NTA3ODA4OTgsImV4cCI6MTc1MDc4NDQ5OH0.example'}) # VerifyMagicLinkRequest | The token from the magic link URL.
+
+begin
+  # Verify magic link
+  result = api_instance.verify_magic_link(verify_magic_link_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->verify_magic_link: #{e}"
+end
+```
+
+#### Using the verify_magic_link_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<AuthResponse>, Integer, Hash)> verify_magic_link_with_http_info(verify_magic_link_request)
+
+```ruby
+begin
+  # Verify magic link
+  data, status_code, headers = api_instance.verify_magic_link_with_http_info(verify_magic_link_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <AuthResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->verify_magic_link_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **verify_magic_link_request** | [**VerifyMagicLinkRequest**](VerifyMagicLinkRequest.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
+
+
+## verify_otp
+
+> <AuthResponse> 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::AuthenticationApi.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.verify_otp(otp_verify_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling AuthenticationApi->verify_otp: #{e}"
+end
+```
+
+#### Using the verify_otp_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<AuthResponse>, Integer, Hash)> verify_otp_with_http_info(otp_verify_request)
+
+```ruby
+begin
+  # Verify OTP code
+  data, status_code, headers = api_instance.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 AuthenticationApi->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
+