mudbase 1.0.0

data/docs/StorageApi.md

@@ -0,0 +1,1080 @@
+# Mudbase::StorageApi
+
+All URIs are relative to *https://cloud.mudbase.dev*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**storage_confirm_upload**](StorageApi.md#storage_confirm_upload) | **POST** /api/files/upload/confirm | Confirm direct upload (scan + finalize metadata) |
+| [**storage_create_bucket**](StorageApi.md#storage_create_bucket) | **POST** /api/bucket/projects/{projectId}/buckets | Create a new bucket |
+| [**storage_delete_bucket**](StorageApi.md#storage_delete_bucket) | **DELETE** /api/bucket/projects/{projectId}/buckets/{bucketId} | Delete bucket |
+| [**storage_delete_file**](StorageApi.md#storage_delete_file) | **DELETE** /api/bucket/projects/{projectId}/buckets/{bucketId}/files/{fileId} | Delete file |
+| [**storage_download_bucket_file**](StorageApi.md#storage_download_bucket_file) | **GET** /api/bucket/files/{fileId}/download | Download file from bucket |
+| [**storage_download_file**](StorageApi.md#storage_download_file) | **GET** /api/files/{fileId}/download | Generate a presigned URL for downloading a file |
+| [**storage_get_bucket**](StorageApi.md#storage_get_bucket) | **GET** /api/bucket/projects/{projectId}/buckets/{bucketId} | Get bucket details |
+| [**storage_get_file**](StorageApi.md#storage_get_file) | **GET** /api/bucket/projects/{projectId}/buckets/{bucketId}/files/{fileId} | Get file metadata |
+| [**storage_get_presigned_upload**](StorageApi.md#storage_get_presigned_upload) | **POST** /api/files/upload/presigned | Generate presigned POST data for direct browser upload |
+| [**storage_get_signed_url**](StorageApi.md#storage_get_signed_url) | **POST** /api/bucket/projects/{projectId}/buckets/{bucketId}/files/{fileId}/signed-url | Generate signed URL for file |
+| [**storage_list_buckets**](StorageApi.md#storage_list_buckets) | **GET** /api/bucket/projects/{projectId}/buckets | List buckets in a project |
+| [**storage_list_files**](StorageApi.md#storage_list_files) | **GET** /api/bucket/projects/{projectId}/buckets/{bucketId}/files | List files in bucket |
+| [**storage_update_bucket**](StorageApi.md#storage_update_bucket) | **PATCH** /api/bucket/projects/{projectId}/buckets/{bucketId} | Update bucket |
+| [**storage_upload_files**](StorageApi.md#storage_upload_files) | **POST** /api/bucket/projects/{projectId}/buckets/{bucketId}/files | Upload files to bucket |
+
+
+## storage_confirm_upload
+
+> <ConfirmUploadResponse> storage_confirm_upload(storage_confirm_upload_request)
+
+Confirm direct upload (scan + finalize metadata)
+
+After a client uploads directly to S3 using the presigned POST, call this endpoint to have the server scan the object, create the File record, and optionally quarantine if infected.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::StorageApi.new
+storage_confirm_upload_request = Mudbase::StorageConfirmUploadRequest.new({key: 'key_example', project_id: 'project_id_example'}) # StorageConfirmUploadRequest | S3 key from presigned response, projectId, and optional originalName, contentType, size, bucket, isPublic.
+
+begin
+  # Confirm direct upload (scan + finalize metadata)
+  result = api_instance.storage_confirm_upload(storage_confirm_upload_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_confirm_upload: #{e}"
+end
+```
+
+#### Using the storage_confirm_upload_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ConfirmUploadResponse>, Integer, Hash)> storage_confirm_upload_with_http_info(storage_confirm_upload_request)
+
+```ruby
+begin
+  # Confirm direct upload (scan + finalize metadata)
+  data, status_code, headers = api_instance.storage_confirm_upload_with_http_info(storage_confirm_upload_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ConfirmUploadResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_confirm_upload_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **storage_confirm_upload_request** | [**StorageConfirmUploadRequest**](StorageConfirmUploadRequest.md) | S3 key from presigned response, projectId, and optional originalName, contentType, size, bucket, isPublic. |  |
+
+### Return type
+
+[**ConfirmUploadResponse**](ConfirmUploadResponse.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## storage_create_bucket
+
+> <BucketResponse> storage_create_bucket(project_id, create_bucket_request)
+
+Create a new bucket
+
+Create a new storage bucket in a project. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+create_bucket_request = Mudbase::CreateBucketRequest.new({name: 'name_example'}) # CreateBucketRequest | Bucket name, isPublic flag, and optional settings.
+
+begin
+  # Create a new bucket
+  result = api_instance.storage_create_bucket(project_id, create_bucket_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_create_bucket: #{e}"
+end
+```
+
+#### Using the storage_create_bucket_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<BucketResponse>, Integer, Hash)> storage_create_bucket_with_http_info(project_id, create_bucket_request)
+
+```ruby
+begin
+  # Create a new bucket
+  data, status_code, headers = api_instance.storage_create_bucket_with_http_info(project_id, create_bucket_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <BucketResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_create_bucket_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **create_bucket_request** | [**CreateBucketRequest**](CreateBucketRequest.md) | Bucket name, isPublic flag, and optional settings. |  |
+
+### Return type
+
+[**BucketResponse**](BucketResponse.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## storage_delete_bucket
+
+> <MessageResponse> storage_delete_bucket(project_id, bucket_id)
+
+Delete bucket
+
+Delete a storage bucket permanently. This is a destructive operation that will also delete all files in the bucket. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### 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::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+bucket_id = 'bucket_id_example' # String | Bucket ID.
+
+begin
+  # Delete bucket
+  result = api_instance.storage_delete_bucket(project_id, bucket_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_delete_bucket: #{e}"
+end
+```
+
+#### Using the storage_delete_bucket_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> storage_delete_bucket_with_http_info(project_id, bucket_id)
+
+```ruby
+begin
+  # Delete bucket
+  data, status_code, headers = api_instance.storage_delete_bucket_with_http_info(project_id, bucket_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_delete_bucket_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **bucket_id** | **String** | Bucket ID. |  |
+
+### Return type
+
+[**MessageResponse**](MessageResponse.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## storage_delete_file
+
+> <MessageResponse> storage_delete_file(project_id, bucket_id, file_id)
+
+Delete file
+
+Delete a file from a bucket permanently. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### 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::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+bucket_id = 'bucket_id_example' # String | Bucket ID.
+file_id = 'file_id_example' # String | File ID.
+
+begin
+  # Delete file
+  result = api_instance.storage_delete_file(project_id, bucket_id, file_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_delete_file: #{e}"
+end
+```
+
+#### Using the storage_delete_file_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<MessageResponse>, Integer, Hash)> storage_delete_file_with_http_info(project_id, bucket_id, file_id)
+
+```ruby
+begin
+  # Delete file
+  data, status_code, headers = api_instance.storage_delete_file_with_http_info(project_id, bucket_id, file_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <MessageResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_delete_file_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **bucket_id** | **String** | Bucket ID. |  |
+| **file_id** | **String** | File ID. |  |
+
+### Return type
+
+[**MessageResponse**](MessageResponse.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## storage_download_bucket_file
+
+> File storage_download_bucket_file(file_id, opts)
+
+Download file from bucket
+
+Download a file from a bucket. For public files, no authentication is required. For private files, a download token (obtained via signed URL endpoint) is required in the query parameter. Accepts: Token-based authentication via query parameter (for private files), or no authentication (for public files). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+
+api_instance = Mudbase::StorageApi.new
+file_id = '685af8b85d73a104065b6a77' # String | File ID to download.
+opts = {
+  token: 'token_example' # String | Download token for private files (from signed URL endpoint).
+}
+
+begin
+  # Download file from bucket
+  result = api_instance.storage_download_bucket_file(file_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_download_bucket_file: #{e}"
+end
+```
+
+#### Using the storage_download_bucket_file_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(File, Integer, Hash)> storage_download_bucket_file_with_http_info(file_id, opts)
+
+```ruby
+begin
+  # Download file from bucket
+  data, status_code, headers = api_instance.storage_download_bucket_file_with_http_info(file_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => File
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_download_bucket_file_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **file_id** | **String** | File ID to download. |  |
+| **token** | **String** | Download token for private files (from signed URL endpoint). | [optional] |
+
+### Return type
+
+**File**
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/octet-stream, application/json
+
+
+## storage_download_file
+
+> <SignedUrlResponse> storage_download_file(file_id, opts)
+
+Generate a presigned URL for downloading a file
+
+Returns a time-limited provider-signed URL (S3) for direct download. Server enforces RBAC before issuing the URL.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::StorageApi.new
+file_id = 'file_id_example' # String | File ID.
+opts = {
+  token: 'token_example' # String | Optional one-time download token (if provided by upload flow).
+}
+
+begin
+  # Generate a presigned URL for downloading a file
+  result = api_instance.storage_download_file(file_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_download_file: #{e}"
+end
+```
+
+#### Using the storage_download_file_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<SignedUrlResponse>, Integer, Hash)> storage_download_file_with_http_info(file_id, opts)
+
+```ruby
+begin
+  # Generate a presigned URL for downloading a file
+  data, status_code, headers = api_instance.storage_download_file_with_http_info(file_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <SignedUrlResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_download_file_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **file_id** | **String** | File ID. |  |
+| **token** | **String** | Optional one-time download token (if provided by upload flow). | [optional] |
+
+### Return type
+
+[**SignedUrlResponse**](SignedUrlResponse.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## storage_get_bucket
+
+> <BucketResponse> storage_get_bucket(project_id, bucket_id)
+
+Get bucket details
+
+Retrieve metadata and configuration for a single storage bucket, including name, project, public/private status, and settings. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+bucket_id = 'bucket_id_example' # String | Bucket ID.
+
+begin
+  # Get bucket details
+  result = api_instance.storage_get_bucket(project_id, bucket_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_get_bucket: #{e}"
+end
+```
+
+#### Using the storage_get_bucket_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<BucketResponse>, Integer, Hash)> storage_get_bucket_with_http_info(project_id, bucket_id)
+
+```ruby
+begin
+  # Get bucket details
+  data, status_code, headers = api_instance.storage_get_bucket_with_http_info(project_id, bucket_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <BucketResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_get_bucket_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **bucket_id** | **String** | Bucket ID. |  |
+
+### Return type
+
+[**BucketResponse**](BucketResponse.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## storage_get_file
+
+> <FileResponse> storage_get_file(project_id, bucket_id, file_id)
+
+Get file metadata
+
+Get metadata for a specific file in a bucket. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+bucket_id = 'bucket_id_example' # String | Bucket ID.
+file_id = 'file_id_example' # String | File ID.
+
+begin
+  # Get file metadata
+  result = api_instance.storage_get_file(project_id, bucket_id, file_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_get_file: #{e}"
+end
+```
+
+#### Using the storage_get_file_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<FileResponse>, Integer, Hash)> storage_get_file_with_http_info(project_id, bucket_id, file_id)
+
+```ruby
+begin
+  # Get file metadata
+  data, status_code, headers = api_instance.storage_get_file_with_http_info(project_id, bucket_id, file_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <FileResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_get_file_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **bucket_id** | **String** | Bucket ID. |  |
+| **file_id** | **String** | File ID. |  |
+
+### Return type
+
+[**FileResponse**](FileResponse.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## storage_get_presigned_upload
+
+> <PresignedPostResponse> storage_get_presigned_upload(storage_get_presigned_upload_request)
+
+Generate presigned POST data for direct browser upload
+
+Issue a presigned POST (fields + url) for clients to upload directly to S3. The server stores the issued key with expiry and RBAC is enforced.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::StorageApi.new
+storage_get_presigned_upload_request = Mudbase::StorageGetPresignedUploadRequest.new({project_id: 'project_id_example', original_name: 'original_name_example'}) # StorageGetPresignedUploadRequest | projectId, originalName, optional bucket, contentType, isPublic.
+
+begin
+  # Generate presigned POST data for direct browser upload
+  result = api_instance.storage_get_presigned_upload(storage_get_presigned_upload_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_get_presigned_upload: #{e}"
+end
+```
+
+#### Using the storage_get_presigned_upload_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<PresignedPostResponse>, Integer, Hash)> storage_get_presigned_upload_with_http_info(storage_get_presigned_upload_request)
+
+```ruby
+begin
+  # Generate presigned POST data for direct browser upload
+  data, status_code, headers = api_instance.storage_get_presigned_upload_with_http_info(storage_get_presigned_upload_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <PresignedPostResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_get_presigned_upload_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **storage_get_presigned_upload_request** | [**StorageGetPresignedUploadRequest**](StorageGetPresignedUploadRequest.md) | projectId, originalName, optional bucket, contentType, isPublic. |  |
+
+### Return type
+
+[**PresignedPostResponse**](PresignedPostResponse.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## storage_get_signed_url
+
+> <SignedUrlResponse> storage_get_signed_url(project_id, bucket_id, file_id, opts)
+
+Generate signed URL for file
+
+Generate a time-limited signed URL for downloading a private file. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+bucket_id = 'bucket_id_example' # String | Bucket ID.
+file_id = 'file_id_example' # String | File ID.
+opts = {
+  storage_get_signed_url_request: Mudbase::StorageGetSignedUrlRequest.new # StorageGetSignedUrlRequest | Optional expiresIn (seconds) for the signed URL.
+}
+
+begin
+  # Generate signed URL for file
+  result = api_instance.storage_get_signed_url(project_id, bucket_id, file_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_get_signed_url: #{e}"
+end
+```
+
+#### Using the storage_get_signed_url_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<SignedUrlResponse>, Integer, Hash)> storage_get_signed_url_with_http_info(project_id, bucket_id, file_id, opts)
+
+```ruby
+begin
+  # Generate signed URL for file
+  data, status_code, headers = api_instance.storage_get_signed_url_with_http_info(project_id, bucket_id, file_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <SignedUrlResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_get_signed_url_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **bucket_id** | **String** | Bucket ID. |  |
+| **file_id** | **String** | File ID. |  |
+| **storage_get_signed_url_request** | [**StorageGetSignedUrlRequest**](StorageGetSignedUrlRequest.md) | Optional expiresIn (seconds) for the signed URL. | [optional] |
+
+### Return type
+
+[**SignedUrlResponse**](SignedUrlResponse.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## storage_list_buckets
+
+> <BucketListResponse> storage_list_buckets(project_id, opts)
+
+List buckets in a project
+
+List all storage buckets in a project with pagination and search. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### 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::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+opts = {
+  page: 56, # Integer | Page number (1-based).
+  limit: 56, # Integer | Number of buckets per page.
+  search: 'search_example' # String | Search by bucket name.
+}
+
+begin
+  # List buckets in a project
+  result = api_instance.storage_list_buckets(project_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_list_buckets: #{e}"
+end
+```
+
+#### Using the storage_list_buckets_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<BucketListResponse>, Integer, Hash)> storage_list_buckets_with_http_info(project_id, opts)
+
+```ruby
+begin
+  # List buckets in a project
+  data, status_code, headers = api_instance.storage_list_buckets_with_http_info(project_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <BucketListResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_list_buckets_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **page** | **Integer** | Page number (1-based). | [optional][default to 1] |
+| **limit** | **Integer** | Number of buckets per page. | [optional][default to 20] |
+| **search** | **String** | Search by bucket name. | [optional] |
+
+### Return type
+
+[**BucketListResponse**](BucketListResponse.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## storage_list_files
+
+> <FileListResponse> storage_list_files(project_id, bucket_id, opts)
+
+List files in bucket
+
+List files in a bucket with pagination, search, and optional type filter. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### 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::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+bucket_id = 'bucket_id_example' # String | Bucket ID.
+opts = {
+  page: 56, # Integer | Page number (1-based).
+  limit: 56, # Integer | Number of files per page.
+  search: 'search_example', # String | Search by filename.
+  type: 'type_example' # String | Filter by MIME type or file type.
+}
+
+begin
+  # List files in bucket
+  result = api_instance.storage_list_files(project_id, bucket_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_list_files: #{e}"
+end
+```
+
+#### Using the storage_list_files_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<FileListResponse>, Integer, Hash)> storage_list_files_with_http_info(project_id, bucket_id, opts)
+
+```ruby
+begin
+  # List files in bucket
+  data, status_code, headers = api_instance.storage_list_files_with_http_info(project_id, bucket_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <FileListResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_list_files_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **bucket_id** | **String** | Bucket ID. |  |
+| **page** | **Integer** | Page number (1-based). | [optional][default to 1] |
+| **limit** | **Integer** | Number of files per page. | [optional][default to 20] |
+| **search** | **String** | Search by filename. | [optional] |
+| **type** | **String** | Filter by MIME type or file type. | [optional] |
+
+### Return type
+
+[**FileListResponse**](FileListResponse.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## storage_update_bucket
+
+> <BucketResponse> storage_update_bucket(project_id, bucket_id, update_bucket_request)
+
+Update bucket
+
+Update bucket configuration (name, public/private status, settings). Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### 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::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+bucket_id = 'bucket_id_example' # String | Bucket ID.
+update_bucket_request = Mudbase::UpdateBucketRequest.new # UpdateBucketRequest | Fields to update (name, isPublic, settings).
+
+begin
+  # Update bucket
+  result = api_instance.storage_update_bucket(project_id, bucket_id, update_bucket_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_update_bucket: #{e}"
+end
+```
+
+#### Using the storage_update_bucket_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<BucketResponse>, Integer, Hash)> storage_update_bucket_with_http_info(project_id, bucket_id, update_bucket_request)
+
+```ruby
+begin
+  # Update bucket
+  data, status_code, headers = api_instance.storage_update_bucket_with_http_info(project_id, bucket_id, update_bucket_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <BucketResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_update_bucket_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **bucket_id** | **String** | Bucket ID. |  |
+| **update_bucket_request** | [**UpdateBucketRequest**](UpdateBucketRequest.md) | Fields to update (name, isPublic, settings). |  |
+
+### Return type
+
+[**BucketResponse**](BucketResponse.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## storage_upload_files
+
+> <FileUploadResponse> storage_upload_files(project_id, bucket_id, upload_files_to_bucket_request)
+
+Upload files to bucket
+
+Upload one or more files to a storage bucket using multipart/form-data. Accepts BearerToken (JWT) or ApiKeyAuth (X-API-Key). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::StorageApi.new
+project_id = 'project_id_example' # String | Project ID.
+bucket_id = 'bucket_id_example' # String | Bucket ID.
+upload_files_to_bucket_request = Mudbase::UploadFilesToBucketRequest.new({files: [File.new('/path/to/some/file')]}) # UploadFilesToBucketRequest | Use multipart/form-data for file upload (files required; optional folder, tags). application/json uses the same schema for metadata-only or tooling that prefers JSON.
+
+begin
+  # Upload files to bucket
+  result = api_instance.storage_upload_files(project_id, bucket_id, upload_files_to_bucket_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_upload_files: #{e}"
+end
+```
+
+#### Using the storage_upload_files_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<FileUploadResponse>, Integer, Hash)> storage_upload_files_with_http_info(project_id, bucket_id, upload_files_to_bucket_request)
+
+```ruby
+begin
+  # Upload files to bucket
+  data, status_code, headers = api_instance.storage_upload_files_with_http_info(project_id, bucket_id, upload_files_to_bucket_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <FileUploadResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling StorageApi->storage_upload_files_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Project ID. |  |
+| **bucket_id** | **String** | Bucket ID. |  |
+| **upload_files_to_bucket_request** | [**UploadFilesToBucketRequest**](UploadFilesToBucketRequest.md) | Use multipart/form-data for file upload (files required; optional folder, tags). application/json uses the same schema for metadata-only or tooling that prefers JSON. |  |
+
+### Return type
+
+[**FileUploadResponse**](FileUploadResponse.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json, multipart/form-data
+- **Accept**: application/json
+