stratal 0.0.13 → 0.0.15

package/dist/storage-BtcfgibD.mjs

@@ -0,0 +1,787 @@
+import { S as ApplicationError, b as ERROR_CODES } from "./errors-CtCi1wn6.mjs";
+import { i as Transient, n as __decorateParam, r as __decorateMetadata, t as __decorate } from "./decorate-D5j-d9_z.mjs";
+import { r as Module } from "./module-BH7t7BGG.mjs";
+import { a as withI18n, i as z } from "./validation-Dbt-snjx.mjs";
+import { inject } from "tsyringe";
+import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, ListMultipartUploadsCommand, ListPartsCommand, PutObjectCommand, S3Client, UploadPartCommand } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { DOMParser } from "@xmldom/xmldom";
+//#region src/storage/errors/disk-not-configured.error.ts
+var DiskNotConfiguredError = class extends ApplicationError {
+	constructor(disk) {
+		super("errors.storage.diskNotConfigured", ERROR_CODES.SYSTEM.CONFIGURATION_ERROR, { disk });
+	}
+};
+//#endregion
+//#region src/storage/errors/file-not-found.error.ts
+var FileNotFoundError = class extends ApplicationError {
+	constructor(path) {
+		super("errors.storage.fileNotFound", ERROR_CODES.RESOURCE.NOT_FOUND, { path });
+	}
+};
+//#endregion
+//#region src/storage/errors/file-too-large.error.ts
+var FileTooLargeError = class extends ApplicationError {
+	constructor(size, maxSize) {
+		super("errors.storage.fileTooLarge", ERROR_CODES.VALIDATION.INVALID_FORMAT, {
+			size,
+			maxSize
+		});
+	}
+};
+//#endregion
+//#region src/storage/errors/invalid-disk.error.ts
+var InvalidDiskError = class extends ApplicationError {
+	constructor(disk) {
+		super("errors.storage.invalidDisk", ERROR_CODES.SYSTEM.CONFIGURATION_ERROR, { disk });
+	}
+};
+//#endregion
+//#region src/storage/errors/invalid-file-type.error.ts
+var InvalidFileTypeError = class extends ApplicationError {
+	constructor(mimeType) {
+		super("errors.storage.invalidFileType", ERROR_CODES.VALIDATION.INVALID_FORMAT, { mimeType });
+	}
+};
+//#endregion
+//#region src/storage/errors/presigned-url-invalid-expiry.error.ts
+var PresignedUrlInvalidExpiryError = class extends ApplicationError {
+	constructor(expiresIn, min, max) {
+		super("errors.storage.presignedUrlInvalidExpiry", ERROR_CODES.VALIDATION.INVALID_FORMAT, {
+			expiresIn,
+			min,
+			max
+		});
+	}
+};
+//#endregion
+//#region src/storage/errors/storage-provider-not-supported.error.ts
+var StorageProviderNotSupportedError = class extends ApplicationError {
+	constructor(provider) {
+		super("errors.storage.providerNotSupported", ERROR_CODES.SYSTEM.CONFIGURATION_ERROR, { provider });
+	}
+};
+//#endregion
+//#region src/storage/errors/storage-response-body-missing.error.ts
+var StorageResponseBodyMissingError = class extends ApplicationError {
+	constructor(path) {
+		super("errors.storage.responseBodyMissing", ERROR_CODES.SYSTEM.INFRASTRUCTURE_ERROR, { path });
+	}
+};
+//#endregion
+//#region src/storage/providers/s3-storage.provider.ts
+/**
+* S3 Storage Provider
+* Implements storage operations using AWS SDK for S3-compatible storage
+* Works with AWS S3, Cloudflare R2, MinIO, and other S3-compatible services
+*
+* Implements IS3MultipartProvider for multipart upload support needed by TUS
+*/
+var S3StorageProvider = class {
+	client;
+	bucket;
+	disk;
+	constructor(config) {
+		this.client = new S3Client({
+			region: config.region || "auto",
+			endpoint: config.endpoint,
+			credentials: {
+				accessKeyId: config.accessKeyId,
+				secretAccessKey: config.secretAccessKey
+			},
+			forcePathStyle: true
+		});
+		this.bucket = config.bucket;
+		this.disk = config.disk;
+	}
+	async upload(body, path, options) {
+		const command = new PutObjectCommand({
+			Bucket: this.bucket,
+			Key: path,
+			Body: body,
+			ContentType: options.mimeType,
+			ContentLength: options.size,
+			Metadata: options.metadata,
+			Tagging: options.tagging
+		});
+		await this.client.send(command);
+		return {
+			path,
+			disk: this.disk,
+			fullPath: `${this.bucket}/${path}`,
+			size: options.size,
+			mimeType: options.mimeType ?? "application/octet-stream",
+			uploadedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async download(path) {
+		const command = new GetObjectCommand({
+			Bucket: this.bucket,
+			Key: path
+		});
+		const response = await this.client.send(command);
+		if (!response.Body) throw new StorageResponseBodyMissingError(path);
+		return {
+			toStream: () => response.Body?.transformToWebStream(),
+			contentType: response.ContentType ?? "application/octet-stream",
+			size: response.ContentLength ?? 0,
+			metadata: response.Metadata,
+			toString: () => response.Body?.transformToString(),
+			toArrayBuffer: () => response.Body?.transformToByteArray()
+		};
+	}
+	async delete(path) {
+		const command = new DeleteObjectCommand({
+			Bucket: this.bucket,
+			Key: path
+		});
+		await this.client.send(command);
+	}
+	async exists(path) {
+		try {
+			const command = new HeadObjectCommand({
+				Bucket: this.bucket,
+				Key: path
+			});
+			await this.client.send(command);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async getPresignedUrl(path, method, expiresIn) {
+		let command;
+		switch (method) {
+			case "GET":
+				command = new GetObjectCommand({
+					Bucket: this.bucket,
+					Key: path
+				});
+				break;
+			case "PUT":
+				command = new PutObjectCommand({
+					Bucket: this.bucket,
+					Key: path
+				});
+				break;
+			case "DELETE":
+				command = new DeleteObjectCommand({
+					Bucket: this.bucket,
+					Key: path
+				});
+				break;
+			case "HEAD":
+				command = new HeadObjectCommand({
+					Bucket: this.bucket,
+					Key: path
+				});
+				break;
+		}
+		return {
+			url: await getSignedUrl(this.client, command, { expiresIn }),
+			expiresIn,
+			expiresAt: new Date(Date.now() + expiresIn * 1e3),
+			method
+		};
+	}
+	/**
+	* Chunked upload for streaming data without known size
+	* Uses @aws-sdk/lib-storage for multipart upload handling
+	*
+	* Benefits:
+	* - Handles unknown Content-Length automatically
+	* - Automatic retry on transient failures
+	* - Cleanup of partial uploads on error
+	* - Works with S3-compatible storage (R2, MinIO, RustFS)
+	*
+	* @param body - Content to upload (stream or buffer)
+	* @param path - Full path including disk root
+	* @param options - Upload options (mimeType required, size optional)
+	* @returns Upload result with metadata
+	*/
+	async chunkedUpload(body, path, options) {
+		await new Upload({
+			client: this.client,
+			params: {
+				Bucket: this.bucket,
+				Key: path,
+				Body: body,
+				ContentType: options.mimeType
+			},
+			queueSize: 4,
+			partSize: 5 * 1024 * 1024,
+			leavePartsOnError: false
+		}).done();
+		const headResponse = await this.client.send(new HeadObjectCommand({
+			Bucket: this.bucket,
+			Key: path
+		}));
+		return {
+			path,
+			disk: this.disk,
+			fullPath: `${this.bucket}/${path}`,
+			size: headResponse.ContentLength ?? options.size ?? 0,
+			mimeType: options.mimeType ?? "application/octet-stream",
+			uploadedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	/**
+	* Get the bucket name
+	*/
+	getBucket() {
+		return this.bucket;
+	}
+	/**
+	* Get object metadata without downloading the body
+	*/
+	async headObject(key) {
+		const response = await this.client.send(new HeadObjectCommand({
+			Bucket: this.bucket,
+			Key: key
+		}));
+		return {
+			size: response.ContentLength ?? 0,
+			contentType: response.ContentType,
+			metadata: response.Metadata
+		};
+	}
+	/**
+	* Delete multiple objects in a single request
+	*/
+	async deleteObjects(keys) {
+		if (keys.length === 0) return {
+			deleted: 0,
+			errors: []
+		};
+		const response = await this.client.send(new DeleteObjectsCommand({
+			Bucket: this.bucket,
+			Delete: { Objects: keys.map((key) => ({ Key: key })) }
+		}));
+		return {
+			deleted: response.Deleted?.length ?? 0,
+			errors: (response.Errors ?? []).map((e) => ({
+				key: e.Key ?? "",
+				code: e.Code ?? "Unknown",
+				message: e.Message ?? "Unknown error"
+			}))
+		};
+	}
+	/**
+	* Create a multipart upload
+	*/
+	async createMultipartUpload(key, options) {
+		const response = await this.client.send(new CreateMultipartUploadCommand({
+			Bucket: this.bucket,
+			Key: key,
+			ContentType: options?.contentType,
+			CacheControl: options?.cacheControl,
+			Metadata: options?.metadata,
+			Tagging: options?.tagging
+		}));
+		return {
+			uploadId: response.UploadId ?? "",
+			key: response.Key ?? ""
+		};
+	}
+	/**
+	* Upload a part to an existing multipart upload
+	*/
+	async uploadPart(key, uploadId, partNumber, body) {
+		return {
+			etag: (await this.client.send(new UploadPartCommand({
+				Bucket: this.bucket,
+				Key: key,
+				UploadId: uploadId,
+				PartNumber: partNumber,
+				Body: body,
+				ContentLength: body.length
+			}))).ETag ?? "",
+			partNumber
+		};
+	}
+	/**
+	* Complete a multipart upload
+	*/
+	async completeMultipartUpload(key, uploadId, parts) {
+		const response = await this.client.send(new CompleteMultipartUploadCommand({
+			Bucket: this.bucket,
+			Key: key,
+			UploadId: uploadId,
+			MultipartUpload: { Parts: parts.map((p) => ({
+				ETag: p.etag,
+				PartNumber: p.partNumber
+			})) }
+		}));
+		return {
+			location: response.Location,
+			key: response.Key ?? ""
+		};
+	}
+	/**
+	* Abort a multipart upload
+	*/
+	async abortMultipartUpload(key, uploadId) {
+		await this.client.send(new AbortMultipartUploadCommand({
+			Bucket: this.bucket,
+			Key: key,
+			UploadId: uploadId
+		}));
+	}
+	/**
+	* List parts of a multipart upload
+	*/
+	async listParts(key, uploadId, partNumberMarker) {
+		const response = await this.client.send(new ListPartsCommand({
+			Bucket: this.bucket,
+			Key: key,
+			UploadId: uploadId,
+			PartNumberMarker: partNumberMarker
+		}));
+		return {
+			parts: (response.Parts ?? []).map((p) => ({
+				partNumber: p.PartNumber ?? 0,
+				etag: p.ETag ?? "",
+				size: p.Size ?? 0
+			})),
+			isTruncated: response.IsTruncated ?? false,
+			nextPartNumberMarker: response.NextPartNumberMarker?.toString()
+		};
+	}
+	/**
+	* List all in-progress multipart uploads
+	*/
+	async listMultipartUploads(keyMarker, uploadIdMarker) {
+		const response = await this.client.send(new ListMultipartUploadsCommand({
+			Bucket: this.bucket,
+			KeyMarker: keyMarker,
+			UploadIdMarker: uploadIdMarker
+		}));
+		return {
+			uploads: (response.Uploads ?? []).map((u) => ({
+				key: u.Key ?? "",
+				uploadId: u.UploadId ?? "",
+				initiated: u.Initiated
+			})),
+			isTruncated: response.IsTruncated ?? false,
+			nextKeyMarker: response.NextKeyMarker,
+			nextUploadIdMarker: response.NextUploadIdMarker
+		};
+	}
+};
+//#endregion
+//#region src/storage/storage.tokens.ts
+/**
+* Dependency injection tokens for the Storage module
+* Using Symbol-based tokens to avoid magic strings
+*/
+const STORAGE_TOKENS = {
+	Options: Symbol.for("stratal:storage:options"),
+	StorageService: Symbol.for("stratal:storage:service"),
+	StorageManager: Symbol.for("stratal:storage:manager")
+};
+//#endregion
+//#region src/storage/services/storage-manager.service.ts
+let StorageManagerService = class StorageManagerService {
+	providers = /* @__PURE__ */ new Map();
+	diskConfigs = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.initializeDiskConfigs();
+	}
+	/**
+	* Initialize disk configurations from options
+	*/
+	initializeDiskConfigs() {
+		for (const entry of this.options.storage) this.diskConfigs.set(entry.disk, entry);
+	}
+	/**
+	* Get provider for a specific disk
+	* Lazily initializes provider on first access
+	* @param diskName - Name of the disk
+	* @returns Storage provider instance
+	*/
+	getProvider(diskName) {
+		const cached = this.providers.get(diskName);
+		if (cached) return cached;
+		const diskConfig = this.diskConfigs.get(diskName);
+		if (!diskConfig) throw new DiskNotConfiguredError(diskName);
+		const provider = this.createProvider(diskConfig);
+		this.providers.set(diskName, provider);
+		return provider;
+	}
+	/**
+	* Create a provider instance based on configuration
+	* @param config - Storage entry configuration
+	* @returns Storage provider instance
+	*/
+	createProvider(config) {
+		switch (config.provider) {
+			case "s3": return new S3StorageProvider(config);
+			case "gcs": throw new StorageProviderNotSupportedError(config.provider);
+			default: throw new StorageProviderNotSupportedError(config.provider);
+		}
+	}
+	/**
+	* Get disk configuration
+	* @param diskName - Name of the disk
+	* @returns Storage entry configuration
+	*/
+	getDiskConfig(diskName) {
+		const config = this.diskConfigs.get(diskName);
+		if (!config) throw new DiskNotConfiguredError(diskName);
+		return config;
+	}
+	/**
+	* Check if a disk exists
+	* @param diskName - Name of the disk
+	* @returns True if disk exists, false otherwise
+	*/
+	hasDisk(diskName) {
+		return this.diskConfigs.has(diskName);
+	}
+	/**
+	* Get all available disk names
+	* @returns Array of disk names
+	*/
+	getAvailableDisks() {
+		return Array.from(this.diskConfigs.keys());
+	}
+};
+StorageManagerService = __decorate([
+	Transient(STORAGE_TOKENS.StorageManager),
+	__decorateParam(0, inject(STORAGE_TOKENS.Options)),
+	__decorateMetadata("design:paramtypes", [Object])
+], StorageManagerService);
+//#endregion
+//#region src/storage/dom.polyfill.ts
+/**
+* DOM polyfills for Cloudflare Workers
+*
+* AWS SDK v3 uses DOMParser and Node for XML parsing, which are not available in Workers.
+* This module must be imported BEFORE any AWS SDK imports (including transitive).
+*
+* @see https://github.com/aws/aws-sdk-js-v3/issues/7375
+*/
+globalThis.DOMParser = DOMParser;
+if (typeof globalThis.Node === "undefined") globalThis.Node = {
+	ELEMENT_NODE: 1,
+	ATTRIBUTE_NODE: 2,
+	TEXT_NODE: 3,
+	CDATA_SECTION_NODE: 4,
+	ENTITY_REFERENCE_NODE: 5,
+	ENTITY_NODE: 6,
+	PROCESSING_INSTRUCTION_NODE: 7,
+	COMMENT_NODE: 8,
+	DOCUMENT_NODE: 9,
+	DOCUMENT_TYPE_NODE: 10,
+	DOCUMENT_FRAGMENT_NODE: 11,
+	NOTATION_NODE: 12
+};
+//#endregion
+//#region src/storage/services/storage.service.ts
+var _ref;
+let StorageService = class StorageService {
+	constructor(storageManager, options) {
+		this.storageManager = storageManager;
+		this.options = options;
+	}
+	/**
+	* Upload content to storage
+	* @param body - Content to upload (stream, buffer, or string)
+	* @param relativePath - Relative path within the disk
+	* @param options - Upload options including size and mime type
+	* @param disk - Optional disk name (uses default if not provided)
+	* @returns Upload result with metadata
+	*/
+	async upload(body, relativePath, options, disk) {
+		const diskName = this.resolveDisk(disk);
+		const provider = this.storageManager.getProvider(diskName);
+		const fullPath = this.buildFullPath(relativePath, diskName);
+		return provider.upload(body, fullPath, options);
+	}
+	/**
+	* Download a file from storage
+	* @param relativePath - Relative path within the disk
+	* @param disk - Optional disk name (uses default if not provided)
+	* @returns Download result with stream and metadata
+	*/
+	async download(relativePath, disk) {
+		const diskName = this.resolveDisk(disk);
+		const provider = this.storageManager.getProvider(diskName);
+		const fullPath = this.buildFullPath(relativePath, diskName);
+		return provider.download(fullPath);
+	}
+	/**
+	* Delete a file from storage
+	* @param relativePath - Relative path within the disk
+	* @param disk - Optional disk name (uses default if not provided)
+	*/
+	async delete(relativePath, disk) {
+		const diskName = this.resolveDisk(disk);
+		const provider = this.storageManager.getProvider(diskName);
+		const fullPath = this.buildFullPath(relativePath, diskName);
+		await provider.delete(fullPath);
+	}
+	/**
+	* Check if a file exists in storage
+	* @param relativePath - Relative path within the disk
+	* @param disk - Optional disk name (uses default if not provided)
+	* @returns True if file exists, false otherwise
+	*/
+	async exists(relativePath, disk) {
+		const diskName = this.resolveDisk(disk);
+		const provider = this.storageManager.getProvider(diskName);
+		const fullPath = this.buildFullPath(relativePath, diskName);
+		return provider.exists(fullPath);
+	}
+	/**
+	* Generate a presigned download URL
+	* @param relativePath - Relative path within the disk
+	* @param expiresIn - Optional expiry time in seconds (uses default if not provided)
+	* @param disk - Optional disk name (uses default if not provided)
+	* @returns Presigned URL result
+	*/
+	async getPresignedDownloadUrl(relativePath, expiresIn, disk) {
+		return this.getPresignedUrl(relativePath, "GET", expiresIn, disk);
+	}
+	/**
+	* Generate a presigned upload URL
+	* @param relativePath - Relative path within the disk
+	* @param expiresIn - Optional expiry time in seconds (uses default if not provided)
+	* @param disk - Optional disk name (uses default if not provided)
+	* @returns Presigned URL result
+	*/
+	async getPresignedUploadUrl(relativePath, expiresIn, disk) {
+		return this.getPresignedUrl(relativePath, "PUT", expiresIn, disk);
+	}
+	/**
+	* Generate a presigned delete URL
+	* @param relativePath - Relative path within the disk
+	* @param expiresIn - Optional expiry time in seconds (uses default if not provided)
+	* @param disk - Optional disk name (uses default if not provided)
+	* @returns Presigned URL result
+	*/
+	async getPresignedDeleteUrl(relativePath, expiresIn, disk) {
+		return this.getPresignedUrl(relativePath, "DELETE", expiresIn, disk);
+	}
+	/**
+	* Generate a presigned URL for any method
+	* @param relativePath - Relative path within the disk
+	* @param method - HTTP method (GET, PUT, DELETE, HEAD)
+	* @param expiresIn - Optional expiry time in seconds (uses default if not provided)
+	* @param disk - Optional disk name (uses default if not provided)
+	* @returns Presigned URL result
+	*/
+	async getPresignedUrl(relativePath, method, expiresIn, disk) {
+		const diskName = this.resolveDisk(disk);
+		const provider = this.storageManager.getProvider(diskName);
+		const fullPath = this.buildFullPath(relativePath, diskName);
+		const validatedExpiresIn = this.validateExpiresIn(expiresIn);
+		return provider.getPresignedUrl(fullPath, method, validatedExpiresIn);
+	}
+	/**
+	* Resolve disk name (use default if not provided)
+	* @param disk - Optional disk name
+	* @returns Resolved disk name
+	*/
+	resolveDisk(disk) {
+		const diskName = disk ?? this.options.defaultStorageDisk;
+		if (!this.storageManager.hasDisk(diskName)) throw new InvalidDiskError(diskName);
+		return diskName;
+	}
+	/**
+	* Build full path with disk root and path template substitution
+	* @param relativePath - Relative path within the disk
+	* @param diskName - Name of the disk
+	* @returns Full path including disk root
+	*/
+	buildFullPath(relativePath, diskName) {
+		let root = this.storageManager.getDiskConfig(diskName).root || "";
+		root = this.substituteTemplateVariables(root);
+		return `${root}/${relativePath}`.replace(/\/+/g, "/").replace(/^\//, "");
+	}
+	/**
+	* Substitute template variables in path
+	* Override this method in subclasses to add custom substitutions
+	*
+	* @param path - Path with template variables
+	* @returns Path with substituted variables
+	*/
+	substituteTemplateVariables(path) {
+		let result = path;
+		const now = /* @__PURE__ */ new Date();
+		result = result.replace(/{date}/g, now.toISOString().split("T")[0]);
+		result = result.replace(/{year}/g, now.getFullYear().toString());
+		result = result.replace(/{month}/g, (now.getMonth() + 1).toString().padStart(2, "0"));
+		return result;
+	}
+	/**
+	* Validate expiry time for presigned URLs
+	* @param expiresIn - Optional expiry time in seconds
+	* @returns Validated expiry time
+	*/
+	validateExpiresIn(expiresIn) {
+		const presignedUrlConfig = this.options.presignedUrl;
+		const validatedExpiresIn = expiresIn ?? presignedUrlConfig.defaultExpiry;
+		const minExpiry = 1;
+		const maxExpiry = presignedUrlConfig.maxExpiry;
+		if (validatedExpiresIn < minExpiry || validatedExpiresIn > maxExpiry) throw new PresignedUrlInvalidExpiryError(validatedExpiresIn, minExpiry, maxExpiry);
+		return validatedExpiresIn;
+	}
+	/**
+	* Get all available disk names
+	* @returns Array of disk names
+	*/
+	getAvailableDisks() {
+		return this.storageManager.getAvailableDisks();
+	}
+	/**
+	* Chunked upload for streaming data without known size
+	* Uses multipart upload under the hood - handles retries and large files
+	*
+	* Use this method when:
+	* - Content-Length is unknown or unreliable
+	* - Uploading from streams that can't be rewound
+	* - Need automatic retry handling for transient failures
+	*
+	* @param body - Content to upload (stream or buffer)
+	* @param relativePath - Relative path within the disk
+	* @param options - Upload options (mimeType required, size optional)
+	* @param disk - Optional disk name (uses default if not provided)
+	* @returns Upload result with metadata
+	*/
+	async chunkedUpload(body, relativePath, options, disk) {
+		const diskName = this.resolveDisk(disk);
+		const provider = this.storageManager.getProvider(diskName);
+		const fullPath = this.buildFullPath(relativePath, diskName);
+		return provider.chunkedUpload(body, fullPath, options);
+	}
+};
+StorageService = __decorate([
+	Transient(STORAGE_TOKENS.StorageService),
+	__decorateParam(0, inject(STORAGE_TOKENS.StorageManager)),
+	__decorateParam(1, inject(STORAGE_TOKENS.Options)),
+	__decorateMetadata("design:paramtypes", [typeof (_ref = typeof StorageManagerService !== "undefined" && StorageManagerService) === "function" ? _ref : Object, Object])
+], StorageService);
+//#endregion
+//#region src/storage/storage.module.ts
+/**
+* Storage Module
+* Provides file storage capabilities using AWS S3
+* Supports multiple disk configurations with dynamic path templates
+*/
+var _StorageModule;
+let StorageModule = _StorageModule = class StorageModule {
+	/**
+	* Configure StorageModule with static options
+	*
+	* @param options - Storage configuration options
+	* @returns Dynamic module with storage infrastructure
+	*
+	* @example
+	* ```typescript
+	* StorageModule.forRoot({
+	*   storage: [{ disk: 'uploads', provider: 's3', ... }],
+	*   defaultStorageDisk: 'uploads',
+	*   presignedUrl: { defaultExpiry: 3600, maxExpiry: 86400 }
+	* })
+	* ```
+	*/
+	static forRoot(options) {
+		return {
+			module: _StorageModule,
+			providers: [{
+				provide: STORAGE_TOKENS.Options,
+				useValue: options
+			}]
+		};
+	}
+	/**
+	* Configure StorageModule with async factory
+	*
+	* Use when configuration depends on other services.
+	*
+	* @param options - Async configuration with factory and inject tokens
+	* @returns Dynamic module with storage infrastructure
+	*
+	* @example
+	* ```typescript
+	* StorageModule.forRootAsync({
+	*   inject: [storageConfig.KEY],
+	*   useFactory: (storage) => ({
+	*     storage: storage.storage,
+	*     defaultStorageDisk: storage.defaultStorageDisk,
+	*     presignedUrl: storage.presignedUrl
+	*   })
+	* })
+	* ```
+	*/
+	static forRootAsync(options) {
+		return {
+			module: _StorageModule,
+			providers: [{
+				provide: STORAGE_TOKENS.Options,
+				useFactory: options.useFactory,
+				inject: options.inject
+			}]
+		};
+	}
+};
+StorageModule = _StorageModule = __decorate([Module({ providers: [{
+	provide: STORAGE_TOKENS.StorageManager,
+	useClass: StorageManagerService
+}, {
+	provide: STORAGE_TOKENS.StorageService,
+	useClass: StorageService
+}] })], StorageModule);
+//#endregion
+//#region src/storage/contracts/delete-file.input.ts
+const deleteFileInputSchema = z.object({
+	path: z.string().min(1, withI18n("zodI18n.errors.custom.filePathRequired")),
+	disk: z.string().optional()
+});
+//#endregion
+//#region src/storage/contracts/file-exists.input.ts
+const fileExistsInputSchema = z.object({
+	path: z.string().min(1, withI18n("zodI18n.errors.custom.filePathRequired")),
+	disk: z.string().optional()
+});
+//#endregion
+//#region src/storage/contracts/get-presigned-url.input.ts
+const getPresignedUrlInputSchema = z.object({
+	path: z.string().min(1, withI18n("zodI18n.errors.custom.filePathRequired")),
+	method: z.enum([
+		"GET",
+		"PUT",
+		"DELETE",
+		"HEAD"
+	]).default("GET"),
+	expiresIn: z.number().int().min(1).max(604800).optional(),
+	disk: z.string().optional()
+});
+const presignedUrlResultSchema = z.object({
+	url: z.string().url(),
+	expiresIn: z.number(),
+	expiresAt: z.date(),
+	method: z.enum([
+		"GET",
+		"PUT",
+		"DELETE",
+		"HEAD"
+	])
+});
+//#endregion
+//#region src/storage/contracts/upload-file.input.ts
+const uploadResultSchema = z.object({
+	path: z.string(),
+	disk: z.string(),
+	fullPath: z.string(),
+	size: z.number(),
+	mimeType: z.string(),
+	uploadedAt: z.date()
+});
+//#endregion
+export { FileNotFoundError as _, deleteFileInputSchema as a, StorageManagerService as c, StorageResponseBodyMissingError as d, StorageProviderNotSupportedError as f, FileTooLargeError as g, InvalidDiskError as h, fileExistsInputSchema as i, STORAGE_TOKENS as l, InvalidFileTypeError as m, getPresignedUrlInputSchema as n, StorageModule as o, PresignedUrlInvalidExpiryError as p, presignedUrlResultSchema as r, StorageService as s, uploadResultSchema as t, S3StorageProvider as u, DiskNotConfiguredError as v };
+
+//# sourceMappingURL=storage-BtcfgibD.mjs.map