@objectstack/spec 0.6.1 → 0.7.2

package/dist/system/object-storage.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-storage.zod.d.ts","sourceRoot":"","sources":["../../src/system/object-storage.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;;;GAYG;AAMH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,yGAWY,CAAC;AAE5C,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;EAQ7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAM9D;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,iGAUE,CAAC;AAErC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,oIAOc,CAAC;AAE5C,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,wFAMwB,CAAC;AAExD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,qBAAqB,8CAIS,CAAC;AAE5C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAMpE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;EAOtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAepC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuB7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,yBAAyB;;;;IAKpC;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOH;;;OAGG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKH,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAM5E;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyB9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BlC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B5B,CAAC"}

package/dist/system/object-storage.zod.js

@@ -0,0 +1,591 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gcsStorageExample = exports.azureBlobStorageExample = exports.minioStorageExample = exports.s3StorageExample = exports.ObjectStorageConfigSchema = exports.StorageConnectionSchema = exports.BucketConfigSchema = exports.LifecyclePolicyConfigSchema = exports.LifecyclePolicyRuleSchema = exports.AccessControlConfigSchema = exports.MultipartUploadConfigSchema = exports.PresignedUrlConfigSchema = exports.ObjectMetadataSchema = exports.LifecycleActionSchema = exports.StorageClassSchema = exports.StorageAclSchema = exports.StorageProviderSchema = exports.FileMetadataSchema = exports.StorageScopeSchema = void 0;
+const zod_1 = require("zod");
+const identifiers_zod_1 = require("../shared/identifiers.zod");
+/**
+ * Object Storage Protocol
+ *
+ * Unified storage protocol that combines:
+ * - Object storage systems (S3, Azure Blob, GCS, MinIO)
+ * - Scoped storage configuration (temp, cache, data, logs, config, public)
+ * - Multi-cloud storage providers
+ * - Bucket/container configuration
+ * - Access control and permissions
+ * - Lifecycle policies for data retention
+ * - Presigned URLs for secure direct access
+ * - Multipart uploads for large files
+ */
+// ============================================================================
+// Storage Scope Protocol (formerly from scoped-storage.zod.ts)
+// ============================================================================
+/**
+ * Storage Scope Enum
+ * Defines the lifecycle and persistence guarantee of the storage area.
+ */
+exports.StorageScopeSchema = zod_1.z.enum([
+    'global', // Global application-wide storage
+    'tenant', // Tenant-scoped storage (multi-tenant apps)
+    'user', // User-scoped storage
+    'session', // Session-scoped storage (ephemeral)
+    'temp', // Ephemeral, cleared on restart
+    'cache', // Ephemeral, survives restarts, cleared on LRU/Expiration
+    'data', // Persistent, backed up
+    'logs', // Append-only, rotated
+    'config', // Read-heavy, versioned
+    'public' // Publicly accessible static assets
+]).describe('Storage scope classification');
+/**
+ * File Metadata Schema
+ * Standardized file attribute structure
+ */
+exports.FileMetadataSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('File path'),
+    name: zod_1.z.string().describe('File name'),
+    size: zod_1.z.number().int().describe('File size in bytes'),
+    mimeType: zod_1.z.string().describe('MIME type'),
+    lastModified: zod_1.z.string().datetime().describe('Last modified timestamp'),
+    created: zod_1.z.string().datetime().describe('Creation timestamp'),
+    etag: zod_1.z.string().optional().describe('Entity tag'),
+});
+// ============================================================================
+// Enums
+// ============================================================================
+/**
+ * Storage Provider Types
+ *
+ * Supported cloud and self-hosted object storage providers.
+ */
+exports.StorageProviderSchema = zod_1.z.enum([
+    's3', // Amazon S3
+    'azure_blob', // Azure Blob Storage
+    'gcs', // Google Cloud Storage
+    'minio', // MinIO (self-hosted S3-compatible)
+    'r2', // Cloudflare R2
+    'spaces', // DigitalOcean Spaces
+    'wasabi', // Wasabi Hot Cloud Storage
+    'backblaze', // Backblaze B2
+    'local', // Local filesystem (development only)
+]).describe('Storage provider type');
+/**
+ * Storage Access Control List (ACL)
+ *
+ * Predefined access control configurations for objects and buckets.
+ */
+exports.StorageAclSchema = zod_1.z.enum([
+    'private', // Owner has full control, no one else has access
+    'public_read', // Owner has full control, everyone can read
+    'public_read_write', // Owner has full control, everyone can read/write (not recommended)
+    'authenticated_read', // Owner has full control, authenticated users can read
+    'bucket_owner_read', // Object owner has full control, bucket owner can read
+    'bucket_owner_full_control', // Both object and bucket owner have full control
+]).describe('Storage access control level');
+/**
+ * Storage Class / Tier
+ *
+ * Different storage tiers for cost optimization.
+ * Maps to provider-specific storage classes.
+ */
+exports.StorageClassSchema = zod_1.z.enum([
+    'standard', // Standard/hot storage for frequently accessed data
+    'intelligent', // Intelligent tiering (auto-moves between hot/cool)
+    'infrequent_access', // Infrequent access/cool storage
+    'glacier', // Archive/cold storage (slower retrieval)
+    'deep_archive', // Deep archive (cheapest, slowest retrieval)
+]).describe('Storage class/tier for cost optimization');
+/**
+ * Lifecycle Transition Action
+ */
+exports.LifecycleActionSchema = zod_1.z.enum([
+    'transition', // Move to different storage class
+    'delete', // Delete the object
+    'abort', // Abort incomplete multipart uploads
+]).describe('Lifecycle policy action type');
+// ============================================================================
+// Configuration Schemas
+// ============================================================================
+/**
+ * Object Metadata Schema
+ *
+ * Standard and custom metadata attached to stored objects.
+ *
+ * @example
+ * {
+ *   contentType: 'image/jpeg',
+ *   contentLength: 1024000,
+ *   etag: '"abc123"',
+ *   lastModified: new Date('2024-01-01'),
+ *   custom: {
+ *     uploadedBy: 'user123',
+ *     department: 'marketing'
+ *   }
+ * }
+ */
+exports.ObjectMetadataSchema = zod_1.z.object({
+    contentType: zod_1.z.string().describe('MIME type (e.g., image/jpeg, application/pdf)'),
+    contentLength: zod_1.z.number().min(0).describe('File size in bytes'),
+    contentEncoding: zod_1.z.string().optional().describe('Content encoding (e.g., gzip)'),
+    contentDisposition: zod_1.z.string().optional().describe('Content disposition header'),
+    contentLanguage: zod_1.z.string().optional().describe('Content language'),
+    cacheControl: zod_1.z.string().optional().describe('Cache control directives'),
+    etag: zod_1.z.string().optional().describe('Entity tag for versioning/caching'),
+    lastModified: zod_1.z.date().optional().describe('Last modification timestamp'),
+    versionId: zod_1.z.string().optional().describe('Object version identifier'),
+    storageClass: exports.StorageClassSchema.optional().describe('Storage class/tier'),
+    encryption: zod_1.z.object({
+        algorithm: zod_1.z.string().describe('Encryption algorithm (e.g., AES256, aws:kms)'),
+        keyId: zod_1.z.string().optional().describe('KMS key ID if using managed encryption'),
+    }).optional().describe('Server-side encryption configuration'),
+    custom: zod_1.z.record(zod_1.z.string()).optional().describe('Custom user-defined metadata'),
+});
+/**
+ * Presigned URL Configuration
+ *
+ * Configuration for generating temporary URLs for direct access to objects.
+ * Useful for secure file uploads/downloads without exposing credentials.
+ *
+ * @example
+ * // Generate download URL valid for 1 hour
+ * {
+ *   operation: 'get',
+ *   expiresIn: 3600,
+ *   contentType: 'image/jpeg'
+ * }
+ *
+ * @example
+ * // Generate upload URL valid for 15 minutes with size limit
+ * {
+ *   operation: 'put',
+ *   expiresIn: 900,
+ *   contentType: 'application/pdf',
+ *   maxSize: 10485760
+ * }
+ */
+exports.PresignedUrlConfigSchema = zod_1.z.object({
+    operation: zod_1.z.enum(['get', 'put', 'delete', 'head']).describe('Allowed operation'),
+    expiresIn: zod_1.z.number().min(1).max(604800).describe('Expiration time in seconds (max 7 days)'),
+    contentType: zod_1.z.string().optional().describe('Required content type for PUT operations'),
+    maxSize: zod_1.z.number().min(0).optional().describe('Maximum file size in bytes for PUT operations'),
+    responseContentType: zod_1.z.string().optional().describe('Override content-type for GET operations'),
+    responseContentDisposition: zod_1.z.string().optional().describe('Override content-disposition for GET operations'),
+});
+/**
+ * Multipart Upload Configuration
+ *
+ * Configuration for chunked uploads of large files.
+ * Enables resumable uploads and parallel transfer.
+ *
+ * @example
+ * // Enable multipart for files > 100MB with 10MB chunks
+ * {
+ *   enabled: true,
+ *   partSize: 10485760,
+ *   maxParts: 10000,
+ *   threshold: 104857600,
+ *   maxConcurrent: 4
+ * }
+ */
+exports.MultipartUploadConfigSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().default(true).describe('Enable multipart uploads'),
+    partSize: zod_1.z.number().min(5 * 1024 * 1024).max(5 * 1024 * 1024 * 1024).default(10 * 1024 * 1024).describe('Part size in bytes (min 5MB, max 5GB)'),
+    maxParts: zod_1.z.number().min(1).max(10000).default(10000).describe('Maximum number of parts (max 10,000)'),
+    threshold: zod_1.z.number().min(0).default(100 * 1024 * 1024).describe('File size threshold to trigger multipart upload (bytes)'),
+    maxConcurrent: zod_1.z.number().min(1).max(100).default(4).describe('Maximum concurrent part uploads'),
+    abortIncompleteAfterDays: zod_1.z.number().min(1).optional().describe('Auto-abort incomplete uploads after N days'),
+});
+/**
+ * Access Control Configuration
+ *
+ * Fine-grained access control for buckets and objects.
+ *
+ * @example
+ * {
+ *   acl: 'private',
+ *   allowedOrigins: ['https://app.example.com'],
+ *   allowedMethods: ['GET', 'PUT'],
+ *   corsEnabled: true,
+ *   publicAccess: {
+ *     allowPublicRead: false,
+ *     allowPublicWrite: false
+ *   }
+ * }
+ */
+exports.AccessControlConfigSchema = zod_1.z.object({
+    acl: exports.StorageAclSchema.default('private').describe('Default access control level'),
+    allowedOrigins: zod_1.z.array(zod_1.z.string()).optional().describe('CORS allowed origins'),
+    allowedMethods: zod_1.z.array(zod_1.z.enum(['GET', 'PUT', 'POST', 'DELETE', 'HEAD'])).optional().describe('CORS allowed HTTP methods'),
+    allowedHeaders: zod_1.z.array(zod_1.z.string()).optional().describe('CORS allowed headers'),
+    exposeHeaders: zod_1.z.array(zod_1.z.string()).optional().describe('CORS exposed headers'),
+    maxAge: zod_1.z.number().min(0).optional().describe('CORS preflight cache duration in seconds'),
+    corsEnabled: zod_1.z.boolean().default(false).describe('Enable CORS configuration'),
+    publicAccess: zod_1.z.object({
+        allowPublicRead: zod_1.z.boolean().default(false).describe('Allow public read access'),
+        allowPublicWrite: zod_1.z.boolean().default(false).describe('Allow public write access'),
+        allowPublicList: zod_1.z.boolean().default(false).describe('Allow public bucket listing'),
+    }).optional().describe('Public access control'),
+    allowedIps: zod_1.z.array(zod_1.z.string()).optional().describe('Allowed IP addresses/CIDR blocks'),
+    blockedIps: zod_1.z.array(zod_1.z.string()).optional().describe('Blocked IP addresses/CIDR blocks'),
+});
+/**
+ * Lifecycle Policy Rule
+ *
+ * Individual rule for automatic object lifecycle management.
+ *
+ * @example
+ * // Transition to infrequent access after 30 days
+ * {
+ *   id: 'move_to_ia',
+ *   enabled: true,
+ *   action: 'transition',
+ *   daysAfterCreation: 30,
+ *   targetStorageClass: 'infrequent_access'
+ * }
+ *
+ * @example
+ * // Delete objects after 365 days
+ * {
+ *   id: 'delete_old',
+ *   enabled: true,
+ *   action: 'delete',
+ *   daysAfterCreation: 365
+ * }
+ */
+exports.LifecyclePolicyRuleSchema = zod_1.z.object({
+    id: identifiers_zod_1.SystemIdentifierSchema.describe('Rule identifier'),
+    enabled: zod_1.z.boolean().default(true).describe('Enable this rule'),
+    action: exports.LifecycleActionSchema.describe('Action to perform'),
+    prefix: zod_1.z.string().optional().describe('Object key prefix filter (e.g., "uploads/")'),
+    tags: zod_1.z.record(zod_1.z.string()).optional().describe('Object tag filters'),
+    daysAfterCreation: zod_1.z.number().min(0).optional().describe('Days after object creation'),
+    daysAfterModification: zod_1.z.number().min(0).optional().describe('Days after last modification'),
+    targetStorageClass: exports.StorageClassSchema.optional().describe('Target storage class for transition action'),
+}).refine((data) => {
+    // Validate that transition action has targetStorageClass
+    if (data.action === 'transition' && !data.targetStorageClass) {
+        return false;
+    }
+    return true;
+}, {
+    message: 'targetStorageClass is required when action is "transition"',
+});
+/**
+ * Lifecycle Policy Configuration
+ *
+ * Collection of lifecycle rules for automatic data management.
+ *
+ * @example
+ * {
+ *   enabled: true,
+ *   rules: [
+ *     {
+ *       id: 'archive_old_files',
+ *       enabled: true,
+ *       action: 'transition',
+ *       daysAfterCreation: 90,
+ *       targetStorageClass: 'glacier'
+ *     },
+ *     {
+ *       id: 'delete_temp_files',
+ *       enabled: true,
+ *       action: 'delete',
+ *       prefix: 'temp/',
+ *       daysAfterCreation: 7
+ *     }
+ *   ]
+ * }
+ */
+exports.LifecyclePolicyConfigSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().default(false).describe('Enable lifecycle policies'),
+    rules: zod_1.z.array(exports.LifecyclePolicyRuleSchema).default([]).describe('Lifecycle rules'),
+});
+/**
+ * Bucket Configuration Schema
+ *
+ * Comprehensive configuration for a storage bucket/container.
+ *
+ * @example
+ * {
+ *   name: 'user_uploads',
+ *   label: 'User Uploads',
+ *   bucketName: 'my-app-uploads',
+ *   region: 'us-east-1',
+ *   provider: 's3',
+ *   versioning: true,
+ *   accessControl: {
+ *     acl: 'private',
+ *     corsEnabled: true,
+ *     allowedOrigins: ['https://app.example.com']
+ *   },
+ *   multipartConfig: {
+ *     enabled: true,
+ *     threshold: 104857600
+ *   }
+ * }
+ */
+exports.BucketConfigSchema = zod_1.z.object({
+    name: identifiers_zod_1.SystemIdentifierSchema.describe('Bucket identifier in ObjectStack (snake_case)'),
+    label: zod_1.z.string().describe('Display label'),
+    bucketName: zod_1.z.string().describe('Actual bucket/container name in storage provider'),
+    region: zod_1.z.string().optional().describe('Storage region (e.g., us-east-1, westus)'),
+    provider: exports.StorageProviderSchema.describe('Storage provider'),
+    endpoint: zod_1.z.string().optional().describe('Custom endpoint URL (for S3-compatible providers)'),
+    pathStyle: zod_1.z.boolean().default(false).describe('Use path-style URLs (for S3-compatible providers)'),
+    versioning: zod_1.z.boolean().default(false).describe('Enable object versioning'),
+    encryption: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(false).describe('Enable server-side encryption'),
+        algorithm: zod_1.z.enum(['AES256', 'aws:kms', 'azure:kms', 'gcp:kms']).default('AES256').describe('Encryption algorithm'),
+        kmsKeyId: zod_1.z.string().optional().describe('KMS key ID for managed encryption'),
+    }).optional().describe('Server-side encryption configuration'),
+    accessControl: exports.AccessControlConfigSchema.optional().describe('Access control configuration'),
+    lifecyclePolicy: exports.LifecyclePolicyConfigSchema.optional().describe('Lifecycle policy configuration'),
+    multipartConfig: exports.MultipartUploadConfigSchema.optional().describe('Multipart upload configuration'),
+    tags: zod_1.z.record(zod_1.z.string()).optional().describe('Bucket tags for organization'),
+    description: zod_1.z.string().optional().describe('Bucket description'),
+    enabled: zod_1.z.boolean().default(true).describe('Enable this bucket'),
+});
+/**
+ * Storage Connection Configuration
+ *
+ * Provider-specific connection credentials and settings.
+ *
+ * @example S3
+ * {
+ *   accessKeyId: '${AWS_ACCESS_KEY_ID}',
+ *   secretAccessKey: '${AWS_SECRET_ACCESS_KEY}',
+ *   sessionToken: '${AWS_SESSION_TOKEN}',
+ *   region: 'us-east-1'
+ * }
+ *
+ * @example Azure
+ * {
+ *   accountName: 'mystorageaccount',
+ *   accountKey: '${AZURE_STORAGE_KEY}',
+ *   endpoint: 'https://mystorageaccount.blob.core.windows.net'
+ * }
+ */
+exports.StorageConnectionSchema = zod_1.z.object({
+    // AWS S3 / MinIO
+    accessKeyId: zod_1.z.string().optional().describe('AWS access key ID or MinIO access key'),
+    secretAccessKey: zod_1.z.string().optional().describe('AWS secret access key or MinIO secret key'),
+    sessionToken: zod_1.z.string().optional().describe('AWS session token for temporary credentials'),
+    // Azure Blob Storage
+    accountName: zod_1.z.string().optional().describe('Azure storage account name'),
+    accountKey: zod_1.z.string().optional().describe('Azure storage account key'),
+    sasToken: zod_1.z.string().optional().describe('Azure SAS token'),
+    // Google Cloud Storage
+    projectId: zod_1.z.string().optional().describe('GCP project ID'),
+    credentials: zod_1.z.string().optional().describe('GCP service account credentials JSON'),
+    // Common
+    endpoint: zod_1.z.string().optional().describe('Custom endpoint URL'),
+    region: zod_1.z.string().optional().describe('Default region'),
+    useSSL: zod_1.z.boolean().default(true).describe('Use SSL/TLS for connections'),
+    timeout: zod_1.z.number().min(0).optional().describe('Connection timeout in milliseconds'),
+});
+/**
+ * Object Storage Configuration
+ *
+ * Complete object storage system configuration.
+ *
+ * @example
+ * {
+ *   name: 'production_storage',
+ *   label: 'Production File Storage',
+ *   provider: 's3',
+ *   scope: 'global',
+ *   connection: {
+ *     accessKeyId: '${AWS_ACCESS_KEY_ID}',
+ *     secretAccessKey: '${AWS_SECRET_ACCESS_KEY}',
+ *     region: 'us-east-1'
+ *   },
+ *   buckets: [
+ *     {
+ *       name: 'user_uploads',
+ *       label: 'User Uploads',
+ *       bucketName: 'prod-uploads',
+ *       provider: 's3',
+ *       region: 'us-east-1'
+ *     }
+ *   ],
+ *   defaultBucket: 'user_uploads'
+ * }
+ */
+exports.ObjectStorageConfigSchema = zod_1.z.object({
+    name: identifiers_zod_1.SystemIdentifierSchema.describe('Storage configuration identifier'),
+    label: zod_1.z.string().describe('Display label'),
+    provider: exports.StorageProviderSchema.describe('Primary storage provider'),
+    /**
+     * Storage scope
+     * Defines the lifecycle and access pattern for this storage
+     */
+    scope: exports.StorageScopeSchema.optional().default('global').describe('Storage scope'),
+    connection: exports.StorageConnectionSchema.describe('Connection credentials'),
+    buckets: zod_1.z.array(exports.BucketConfigSchema).default([]).describe('Configured buckets'),
+    defaultBucket: zod_1.z.string().optional().describe('Default bucket name for operations'),
+    /**
+     * Base path or location
+     * For local/scoped storage configurations
+     */
+    location: zod_1.z.string().optional().describe('Root path (local) or base location'),
+    /**
+     * Storage quota in bytes
+     */
+    quota: zod_1.z.number().int().positive().optional().describe('Max size in bytes'),
+    /**
+     * Provider-specific options
+     */
+    options: zod_1.z.record(zod_1.z.any()).optional().describe('Provider-specific configuration options'),
+    enabled: zod_1.z.boolean().default(true).describe('Enable this storage configuration'),
+    description: zod_1.z.string().optional().describe('Configuration description'),
+});
+// ============================================================================
+// Helper Examples
+// ============================================================================
+/**
+ * Example: AWS S3 Configuration
+ */
+exports.s3StorageExample = exports.ObjectStorageConfigSchema.parse({
+    name: 'aws_s3_storage',
+    label: 'AWS S3 Production Storage',
+    provider: 's3',
+    connection: {
+        accessKeyId: '${AWS_ACCESS_KEY_ID}',
+        secretAccessKey: '${AWS_SECRET_ACCESS_KEY}',
+        region: 'us-east-1',
+    },
+    buckets: [
+        {
+            name: 'user_uploads',
+            label: 'User Uploads',
+            bucketName: 'my-app-user-uploads',
+            region: 'us-east-1',
+            provider: 's3',
+            versioning: true,
+            encryption: {
+                enabled: true,
+                algorithm: 'aws:kms',
+                kmsKeyId: '${AWS_KMS_KEY_ID}',
+            },
+            accessControl: {
+                acl: 'private',
+                corsEnabled: true,
+                allowedOrigins: ['https://app.example.com'],
+                allowedMethods: ['GET', 'PUT', 'POST'],
+            },
+            lifecyclePolicy: {
+                enabled: true,
+                rules: [
+                    {
+                        id: 'archive_old_uploads',
+                        enabled: true,
+                        action: 'transition',
+                        daysAfterCreation: 90,
+                        targetStorageClass: 'glacier',
+                    },
+                ],
+            },
+            multipartConfig: {
+                enabled: true,
+                partSize: 10 * 1024 * 1024,
+                threshold: 100 * 1024 * 1024,
+                maxConcurrent: 4,
+            },
+        },
+    ],
+    defaultBucket: 'user_uploads',
+    enabled: true,
+});
+/**
+ * Example: MinIO Configuration
+ */
+exports.minioStorageExample = exports.ObjectStorageConfigSchema.parse({
+    name: 'minio_local',
+    label: 'MinIO Local Storage',
+    provider: 'minio',
+    connection: {
+        accessKeyId: 'minioadmin',
+        secretAccessKey: 'minioadmin',
+        endpoint: 'http://localhost:9000',
+        useSSL: false,
+    },
+    buckets: [
+        {
+            name: 'development_files',
+            label: 'Development Files',
+            bucketName: 'dev-files',
+            provider: 'minio',
+            endpoint: 'http://localhost:9000',
+            pathStyle: true,
+            accessControl: {
+                acl: 'private',
+            },
+        },
+    ],
+    defaultBucket: 'development_files',
+    enabled: true,
+});
+/**
+ * Example: Azure Blob Storage Configuration
+ */
+exports.azureBlobStorageExample = exports.ObjectStorageConfigSchema.parse({
+    name: 'azure_blob_storage',
+    label: 'Azure Blob Storage',
+    provider: 'azure_blob',
+    connection: {
+        accountName: 'mystorageaccount',
+        accountKey: '${AZURE_STORAGE_KEY}',
+        endpoint: 'https://mystorageaccount.blob.core.windows.net',
+    },
+    buckets: [
+        {
+            name: 'media_files',
+            label: 'Media Files',
+            bucketName: 'media',
+            provider: 'azure_blob',
+            region: 'eastus',
+            accessControl: {
+                acl: 'public_read',
+                publicAccess: {
+                    allowPublicRead: true,
+                    allowPublicWrite: false,
+                    allowPublicList: false,
+                },
+            },
+        },
+    ],
+    defaultBucket: 'media_files',
+    enabled: true,
+});
+/**
+ * Example: Google Cloud Storage Configuration
+ */
+exports.gcsStorageExample = exports.ObjectStorageConfigSchema.parse({
+    name: 'gcs_storage',
+    label: 'Google Cloud Storage',
+    provider: 'gcs',
+    connection: {
+        projectId: 'my-gcp-project',
+        credentials: '${GCP_SERVICE_ACCOUNT_JSON}',
+    },
+    buckets: [
+        {
+            name: 'backup_storage',
+            label: 'Backup Storage',
+            bucketName: 'my-app-backups',
+            region: 'us-central1',
+            provider: 'gcs',
+            lifecyclePolicy: {
+                enabled: true,
+                rules: [
+                    {
+                        id: 'delete_old_backups',
+                        enabled: true,
+                        action: 'delete',
+                        daysAfterCreation: 30,
+                    },
+                ],
+            },
+        },
+    ],
+    defaultBucket: 'backup_storage',
+    enabled: true,
+});