@pelatform/storage 1.0.0

package/dist/cloudinary.cjs

@@ -0,0 +1,496 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkI3ME6WAGcjs = require('./chunk-I3ME6WAG.cjs');
+
+// src/providers/cloudinary.ts
+var _cloudinary = require('cloudinary');
+var CloudinaryProvider = class {
+  
+  constructor(config) {
+    this.config = config;
+    _cloudinary.v2.config({
+      cloud_name: config.cloudName,
+      api_key: config.apiKey,
+      api_secret: config.apiSecret,
+      secure: config.secure !== false
+    });
+  }
+  // File operations
+  async upload(options) {
+    try {
+      let fileData;
+      if (typeof options.file === "string") {
+        fileData = options.file;
+      } else {
+        fileData = `data:${options.contentType || "application/octet-stream"};base64,${Buffer.from(options.file).toString("base64")}`;
+      }
+      let resourceType = "raw";
+      if (_optionalChain([options, 'access', _ => _.contentType, 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3("image/")])) {
+        resourceType = "image";
+      } else if (_optionalChain([options, 'access', _4 => _4.contentType, 'optionalAccess', _5 => _5.startsWith, 'call', _6 => _6("video/")])) {
+        resourceType = "video";
+      }
+      const keyParts = options.key.split("/");
+      let folder = "";
+      let publicId = options.key;
+      if (keyParts.length > 1) {
+        folder = keyParts.slice(0, -1).join("/");
+        publicId = keyParts[keyParts.length - 1];
+      }
+      const uploadOptions = {
+        public_id: publicId,
+        resource_type: resourceType,
+        overwrite: true,
+        invalidate: true,
+        ...options.metadata
+      };
+      if (folder) {
+        uploadOptions.folder = folder;
+      }
+      const result = await _cloudinary.v2.uploader.upload(fileData, uploadOptions);
+      const publicUrl = this.getPublicUrl(result.public_id);
+      return {
+        success: true,
+        key: result.public_id,
+        url: result.secure_url,
+        publicUrl,
+        etag: result.etag,
+        size: result.bytes
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Upload failed"
+      };
+    }
+  }
+  async download(options) {
+    try {
+      const publicUrl = this.getPublicUrl(options.key);
+      const response = await fetch(publicUrl);
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `Failed to download: ${response.status} ${response.statusText}`
+        };
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      const content = Buffer.from(arrayBuffer);
+      return {
+        success: true,
+        content,
+        // Main content field
+        data: content,
+        // Alias for backward compatibility
+        contentType: response.headers.get("content-type") || void 0,
+        contentLength: content.length,
+        lastModified: response.headers.get("last-modified") ? new Date(response.headers.get("last-modified")) : /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Download failed"
+      };
+    }
+  }
+  async delete(options) {
+    try {
+      const keyParts = options.key.split("/");
+      let publicId = options.key;
+      if (keyParts.length > 1) {
+        const folder = keyParts.slice(0, -1).join("/");
+        const filename = keyParts[keyParts.length - 1];
+        publicId = `${folder}/${filename}`;
+      }
+      let resourceType = "raw";
+      try {
+        await _cloudinary.v2.api.resource(publicId, { resource_type: "image" });
+        resourceType = "image";
+      } catch (e) {
+        try {
+          await _cloudinary.v2.api.resource(publicId, { resource_type: "video" });
+          resourceType = "video";
+        } catch (e2) {
+          resourceType = "raw";
+        }
+      }
+      await _cloudinary.v2.uploader.destroy(publicId, {
+        resource_type: resourceType,
+        invalidate: true
+      });
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Delete failed"
+      };
+    }
+  }
+  async batchDelete(options) {
+    try {
+      return {
+        success: false,
+        errors: options.keys.map((key) => ({
+          key,
+          error: "Cloudinary batch delete not implemented yet"
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errors: options.keys.map((key) => ({
+          key,
+          error: error instanceof Error ? error.message : "Batch delete failed"
+        }))
+      };
+    }
+  }
+  async list(options = {}) {
+    try {
+      const prefix = options.prefix || "";
+      const maxResults = options.maxKeys || 50;
+      const [images, videos, rawFiles] = await Promise.all([
+        _cloudinary.v2.api.resources({
+          type: "upload",
+          resource_type: "image",
+          prefix,
+          max_results: maxResults,
+          next_cursor: options.continuationToken
+        }).catch(() => ({ resources: [], next_cursor: void 0 })),
+        _cloudinary.v2.api.resources({
+          type: "upload",
+          resource_type: "video",
+          prefix,
+          max_results: maxResults,
+          next_cursor: options.continuationToken
+        }).catch(() => ({ resources: [], next_cursor: void 0 })),
+        _cloudinary.v2.api.resources({
+          type: "upload",
+          resource_type: "raw",
+          prefix,
+          max_results: maxResults,
+          next_cursor: options.continuationToken
+        }).catch(() => ({ resources: [], next_cursor: void 0 }))
+      ]);
+      const allResources = [
+        ...images.resources || [],
+        ...videos.resources || [],
+        ...rawFiles.resources || []
+      ];
+      const files = allResources.map((resource) => ({
+        key: String(resource.public_id || ""),
+        size: Number(resource.bytes) || 0,
+        lastModified: new Date(String(resource.created_at || /* @__PURE__ */ new Date())),
+        etag: String(resource.etag || ""),
+        contentType: resource.format ? `${resource.resource_type}/${resource.format}` : "application/octet-stream"
+      }));
+      return {
+        success: true,
+        files,
+        isTruncated: !!(images.next_cursor || videos.next_cursor || rawFiles.next_cursor),
+        nextContinuationToken: images.next_cursor || videos.next_cursor || rawFiles.next_cursor
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "List failed"
+      };
+    }
+  }
+  async exists(_key) {
+    try {
+      return {
+        exists: false,
+        error: "Cloudinary exists check not implemented yet"
+      };
+    } catch (error) {
+      return {
+        exists: false,
+        error: error instanceof Error ? error.message : "Check existence failed"
+      };
+    }
+  }
+  async copy(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary copy not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Copy failed"
+      };
+    }
+  }
+  async move(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary move not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Move failed"
+      };
+    }
+  }
+  async duplicate(options) {
+    return this.copy(options);
+  }
+  async getPresignedUrl(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary presigned URL not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Presigned URL generation failed"
+      };
+    }
+  }
+  getPublicUrl(key) {
+    const protocol = this.config.secure !== false ? "https" : "http";
+    const baseUrl = `${protocol}://res.cloudinary.com/${this.config.cloudName}`;
+    const publicId = key;
+    return `${baseUrl}/image/upload/${publicId}`;
+  }
+  // Folder operations
+  async createFolder(options) {
+    try {
+      return {
+        success: true,
+        path: options.path
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Create folder failed"
+      };
+    }
+  }
+  async deleteFolder(options) {
+    try {
+      const folderPath = options.path.endsWith("/") ? options.path.slice(0, -1) : options.path;
+      if (options.recursive) {
+        await _cloudinary.v2.api.delete_resources_by_prefix(folderPath);
+      }
+      await _cloudinary.v2.api.delete_folder(folderPath);
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Delete folder failed"
+      };
+    }
+  }
+  async listFolders(_options) {
+    try {
+      const result = await _cloudinary.v2.api.root_folders();
+      const folders = (result.folders || []).map((folder) => ({
+        name: folder.name,
+        path: folder.path
+      }));
+      return {
+        success: true,
+        folders,
+        isTruncated: false,
+        nextContinuationToken: void 0
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "List folders failed"
+      };
+    }
+  }
+  async folderExists(_path) {
+    try {
+      return {
+        exists: false,
+        error: "Cloudinary folder exists check not implemented yet"
+      };
+    } catch (error) {
+      return {
+        exists: false,
+        error: error instanceof Error ? error.message : "Check folder existence failed"
+      };
+    }
+  }
+  async renameFolder(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary rename folder not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Rename folder failed"
+      };
+    }
+  }
+  async copyFolder(_options) {
+    try {
+      return {
+        success: false,
+        error: "Cloudinary copy folder not implemented yet"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Copy folder failed"
+      };
+    }
+  }
+};
+
+// src/services/cloudinary.ts
+var CloudinaryService = class {
+  
+  
+  constructor(config) {
+    this.config = config || _chunkI3ME6WAGcjs.loadCloudinaryConfig.call(void 0, );
+    this.provider = new CloudinaryProvider(this.config);
+  }
+  // Utility methods
+  getConfig() {
+    return { ...this.config };
+  }
+  getProvider() {
+    return this.config.provider;
+  }
+  getPublicUrl(key) {
+    return this.provider.getPublicUrl(key);
+  }
+  // File operations
+  async upload(options) {
+    return this.provider.upload(options);
+  }
+  async download(options) {
+    return this.provider.download(options);
+  }
+  async delete(options) {
+    return this.provider.delete(options);
+  }
+  async batchDelete(options) {
+    return this.provider.batchDelete(options);
+  }
+  async list(options) {
+    return this.provider.list(options);
+  }
+  async exists(key) {
+    return this.provider.exists(key);
+  }
+  async copy(options) {
+    return this.provider.copy(options);
+  }
+  async move(options) {
+    return this.provider.move(options);
+  }
+  async duplicate(options) {
+    return this.provider.duplicate(options);
+  }
+  async getPresignedUrl(options) {
+    return this.provider.getPresignedUrl(options);
+  }
+  // Folder operations
+  async createFolder(options) {
+    return this.provider.createFolder(options);
+  }
+  async deleteFolder(options) {
+    return this.provider.deleteFolder(options);
+  }
+  async listFolders(options) {
+    return this.provider.listFolders(options);
+  }
+  async folderExists(path) {
+    return this.provider.folderExists(path);
+  }
+  async renameFolder(options) {
+    return this.provider.renameFolder(options);
+  }
+  async copyFolder(options) {
+    return this.provider.copyFolder(options);
+  }
+  // Convenience methods
+  async uploadFile(key, file, contentType, metadata) {
+    return this.upload({ key, file, contentType, metadata });
+  }
+  async downloadFile(key) {
+    return this.download({ key });
+  }
+  async deleteFile(key) {
+    return this.delete({ key });
+  }
+  async deleteFiles(keys) {
+    return this.batchDelete({ keys });
+  }
+  async fileExists(key) {
+    const result = await this.exists(key);
+    return result.exists;
+  }
+  async copyFile(sourceKey, destinationKey, metadata) {
+    return this.copy({ sourceKey, destinationKey, metadata });
+  }
+  async moveFile(sourceKey, destinationKey, metadata) {
+    return this.move({ sourceKey, destinationKey, metadata });
+  }
+  async duplicateFile(sourceKey, destinationKey, metadata) {
+    return this.duplicate({ sourceKey, destinationKey, metadata });
+  }
+  async renameFile(sourceKey, destinationKey, metadata) {
+    return this.moveFile(sourceKey, destinationKey, metadata);
+  }
+  async listFiles(prefix, maxKeys) {
+    return this.list({ prefix, maxKeys });
+  }
+  async getDownloadUrl(key, expiresIn) {
+    return this.getPresignedUrl({ key, operation: "get", expiresIn });
+  }
+  async getUploadUrl(key, contentType, expiresIn) {
+    return this.getPresignedUrl({
+      key,
+      operation: "put",
+      contentType,
+      expiresIn
+    });
+  }
+  // Folder convenience methods
+  async createFolderPath(path) {
+    return this.createFolder({ path });
+  }
+  async deleteFolderPath(path, recursive = false) {
+    return this.deleteFolder({ path, recursive });
+  }
+  async folderPathExists(path) {
+    const result = await this.folderExists(path);
+    return result.exists;
+  }
+  async renameFolderPath(oldPath, newPath) {
+    return this.renameFolder({ oldPath, newPath });
+  }
+  async copyFolderPath(sourcePath, destinationPath, recursive = true) {
+    return this.copyFolder({ sourcePath, destinationPath, recursive });
+  }
+};
+
+// src/cloudinary.ts
+function createCloudinary(config) {
+  if (config) {
+    return new CloudinaryService(config);
+  }
+  const envConfig = _chunkI3ME6WAGcjs.loadCloudinaryConfig.call(void 0, );
+  return new CloudinaryService(envConfig);
+}
+
+
+
+exports.CloudinaryService = CloudinaryService; exports.createCloudinary = createCloudinary;

package/dist/cloudinary.d.cts

@@ -0,0 +1,93 @@
+import { S as StorageInterface, C as CloudinaryConfig, U as UploadOptions, a as UploadResult, D as DownloadOptions, b as DownloadResult, c as DeleteOptions, d as DeleteResult, B as BatchDeleteOptions, e as BatchDeleteResult, L as ListOptions, f as ListResult, E as ExistsResult, g as CopyOptions, h as CopyResult, M as MoveOptions, i as MoveResult, j as DuplicateOptions, k as DuplicateResult, P as PresignedUrlOptions, l as PresignedUrlResult, m as CreateFolderOptions, n as CreateFolderResult, o as DeleteFolderOptions, p as DeleteFolderResult, q as ListFoldersOptions, r as ListFoldersResult, F as FolderExistsResult, R as RenameFolderOptions, s as RenameFolderResult, t as CopyFolderOptions, u as CopyFolderResult } from './storage-interface-BKeDAlGP.cjs';
+
+/**
+ * Cloudinary storage service implementation
+ * High-level service wrapper for Cloudinary storage operations with convenience methods
+ */
+
+/**
+ * Cloudinary storage service
+ * High-level service for Cloudinary storage operations with convenience methods
+ * @public
+ */
+declare class CloudinaryService implements StorageInterface {
+    private provider;
+    private config;
+    constructor();
+    constructor(config: CloudinaryConfig);
+    getConfig(): CloudinaryConfig;
+    getProvider(): string;
+    getPublicUrl(key: string): string;
+    upload(options: UploadOptions): Promise<UploadResult>;
+    download(options: DownloadOptions): Promise<DownloadResult>;
+    delete(options: DeleteOptions): Promise<DeleteResult>;
+    batchDelete(options: BatchDeleteOptions): Promise<BatchDeleteResult>;
+    list(options?: ListOptions): Promise<ListResult>;
+    exists(key: string): Promise<ExistsResult>;
+    copy(options: CopyOptions): Promise<CopyResult>;
+    move(options: MoveOptions): Promise<MoveResult>;
+    duplicate(options: DuplicateOptions): Promise<DuplicateResult>;
+    getPresignedUrl(options: PresignedUrlOptions): Promise<PresignedUrlResult>;
+    createFolder(options: CreateFolderOptions): Promise<CreateFolderResult>;
+    deleteFolder(options: DeleteFolderOptions): Promise<DeleteFolderResult>;
+    listFolders(options?: ListFoldersOptions): Promise<ListFoldersResult>;
+    folderExists(path: string): Promise<FolderExistsResult>;
+    renameFolder(options: RenameFolderOptions): Promise<RenameFolderResult>;
+    copyFolder(options: CopyFolderOptions): Promise<CopyFolderResult>;
+    uploadFile(key: string, file: Buffer | Uint8Array | string, contentType?: string, metadata?: Record<string, string>): Promise<UploadResult>;
+    downloadFile(key: string): Promise<DownloadResult>;
+    deleteFile(key: string): Promise<DeleteResult>;
+    deleteFiles(keys: string[]): Promise<BatchDeleteResult>;
+    fileExists(key: string): Promise<boolean>;
+    copyFile(sourceKey: string, destinationKey: string, metadata?: Record<string, string>): Promise<CopyResult>;
+    moveFile(sourceKey: string, destinationKey: string, metadata?: Record<string, string>): Promise<MoveResult>;
+    duplicateFile(sourceKey: string, destinationKey: string, metadata?: Record<string, string>): Promise<DuplicateResult>;
+    renameFile(sourceKey: string, destinationKey: string, metadata?: Record<string, string>): Promise<MoveResult>;
+    listFiles(prefix?: string, maxKeys?: number): Promise<ListResult>;
+    getDownloadUrl(key: string, expiresIn?: number): Promise<PresignedUrlResult>;
+    getUploadUrl(key: string, contentType?: string, expiresIn?: number): Promise<PresignedUrlResult>;
+    createFolderPath(path: string): Promise<CreateFolderResult>;
+    deleteFolderPath(path: string, recursive?: boolean): Promise<DeleteFolderResult>;
+    folderPathExists(path: string): Promise<boolean>;
+    renameFolderPath(oldPath: string, newPath: string): Promise<RenameFolderResult>;
+    copyFolderPath(sourcePath: string, destinationPath: string, recursive?: boolean): Promise<CopyFolderResult>;
+}
+
+/**
+ * Create Cloudinary service using environment variables or manual configuration
+ * @param config Optional Cloudinary configuration. If not provided, loads from environment variables
+ * @returns CloudinaryService instance
+ * @throws Error if configuration is invalid or environment variables are missing
+ * @public
+ *
+ * @example
+ * ```typescript
+ * import { createCloudinary } from '@pelatform/storage/cloudinary';
+ *
+ * // Using environment variables
+ * // Set: PELATFORM_CLOUDINARY_CLOUD_NAME=my-cloud, PELATFORM_CLOUDINARY_API_KEY=123..., etc.
+ * const cloudinaryFromEnv = createCloudinary();
+ * await cloudinaryFromEnv.uploadFile('photo.jpg', imageBuffer);
+ *
+ * // Using manual configuration
+ * const cloudinary = createCloudinary({
+ *   provider: 'cloudinary',
+ *   cloudName: 'my-cloud-name',
+ *   apiKey: '123456789012345',
+ *   apiSecret: 'your-api-secret',
+ *   secure: true,
+ *   folder: 'uploads'
+ * });
+ *
+ * // Upload with transformations
+ * await cloudinary.uploadFile('profile-pic.jpg', imageBuffer);
+ *
+ * // Get optimized URL
+ * const publicUrl = cloudinary.getPublicUrl('profile-pic.jpg');
+ * console.log(publicUrl); // Cloudinary optimized URL
+ * ```
+ */
+declare function createCloudinary(): CloudinaryService;
+declare function createCloudinary(config: CloudinaryConfig): CloudinaryService;
+
+export { CloudinaryService, createCloudinary };

package/dist/cloudinary.d.ts

@@ -0,0 +1,93 @@
+import { S as StorageInterface, C as CloudinaryConfig, U as UploadOptions, a as UploadResult, D as DownloadOptions, b as DownloadResult, c as DeleteOptions, d as DeleteResult, B as BatchDeleteOptions, e as BatchDeleteResult, L as ListOptions, f as ListResult, E as ExistsResult, g as CopyOptions, h as CopyResult, M as MoveOptions, i as MoveResult, j as DuplicateOptions, k as DuplicateResult, P as PresignedUrlOptions, l as PresignedUrlResult, m as CreateFolderOptions, n as CreateFolderResult, o as DeleteFolderOptions, p as DeleteFolderResult, q as ListFoldersOptions, r as ListFoldersResult, F as FolderExistsResult, R as RenameFolderOptions, s as RenameFolderResult, t as CopyFolderOptions, u as CopyFolderResult } from './storage-interface-BKeDAlGP.js';
+
+/**
+ * Cloudinary storage service implementation
+ * High-level service wrapper for Cloudinary storage operations with convenience methods
+ */
+
+/**
+ * Cloudinary storage service
+ * High-level service for Cloudinary storage operations with convenience methods
+ * @public
+ */
+declare class CloudinaryService implements StorageInterface {
+    private provider;
+    private config;
+    constructor();
+    constructor(config: CloudinaryConfig);
+    getConfig(): CloudinaryConfig;
+    getProvider(): string;
+    getPublicUrl(key: string): string;
+    upload(options: UploadOptions): Promise<UploadResult>;
+    download(options: DownloadOptions): Promise<DownloadResult>;
+    delete(options: DeleteOptions): Promise<DeleteResult>;
+    batchDelete(options: BatchDeleteOptions): Promise<BatchDeleteResult>;
+    list(options?: ListOptions): Promise<ListResult>;
+    exists(key: string): Promise<ExistsResult>;
+    copy(options: CopyOptions): Promise<CopyResult>;
+    move(options: MoveOptions): Promise<MoveResult>;
+    duplicate(options: DuplicateOptions): Promise<DuplicateResult>;
+    getPresignedUrl(options: PresignedUrlOptions): Promise<PresignedUrlResult>;
+    createFolder(options: CreateFolderOptions): Promise<CreateFolderResult>;
+    deleteFolder(options: DeleteFolderOptions): Promise<DeleteFolderResult>;
+    listFolders(options?: ListFoldersOptions): Promise<ListFoldersResult>;
+    folderExists(path: string): Promise<FolderExistsResult>;
+    renameFolder(options: RenameFolderOptions): Promise<RenameFolderResult>;
+    copyFolder(options: CopyFolderOptions): Promise<CopyFolderResult>;
+    uploadFile(key: string, file: Buffer | Uint8Array | string, contentType?: string, metadata?: Record<string, string>): Promise<UploadResult>;
+    downloadFile(key: string): Promise<DownloadResult>;
+    deleteFile(key: string): Promise<DeleteResult>;
+    deleteFiles(keys: string[]): Promise<BatchDeleteResult>;
+    fileExists(key: string): Promise<boolean>;
+    copyFile(sourceKey: string, destinationKey: string, metadata?: Record<string, string>): Promise<CopyResult>;
+    moveFile(sourceKey: string, destinationKey: string, metadata?: Record<string, string>): Promise<MoveResult>;
+    duplicateFile(sourceKey: string, destinationKey: string, metadata?: Record<string, string>): Promise<DuplicateResult>;
+    renameFile(sourceKey: string, destinationKey: string, metadata?: Record<string, string>): Promise<MoveResult>;
+    listFiles(prefix?: string, maxKeys?: number): Promise<ListResult>;
+    getDownloadUrl(key: string, expiresIn?: number): Promise<PresignedUrlResult>;
+    getUploadUrl(key: string, contentType?: string, expiresIn?: number): Promise<PresignedUrlResult>;
+    createFolderPath(path: string): Promise<CreateFolderResult>;
+    deleteFolderPath(path: string, recursive?: boolean): Promise<DeleteFolderResult>;
+    folderPathExists(path: string): Promise<boolean>;
+    renameFolderPath(oldPath: string, newPath: string): Promise<RenameFolderResult>;
+    copyFolderPath(sourcePath: string, destinationPath: string, recursive?: boolean): Promise<CopyFolderResult>;
+}
+
+/**
+ * Create Cloudinary service using environment variables or manual configuration
+ * @param config Optional Cloudinary configuration. If not provided, loads from environment variables
+ * @returns CloudinaryService instance
+ * @throws Error if configuration is invalid or environment variables are missing
+ * @public
+ *
+ * @example
+ * ```typescript
+ * import { createCloudinary } from '@pelatform/storage/cloudinary';
+ *
+ * // Using environment variables
+ * // Set: PELATFORM_CLOUDINARY_CLOUD_NAME=my-cloud, PELATFORM_CLOUDINARY_API_KEY=123..., etc.
+ * const cloudinaryFromEnv = createCloudinary();
+ * await cloudinaryFromEnv.uploadFile('photo.jpg', imageBuffer);
+ *
+ * // Using manual configuration
+ * const cloudinary = createCloudinary({
+ *   provider: 'cloudinary',
+ *   cloudName: 'my-cloud-name',
+ *   apiKey: '123456789012345',
+ *   apiSecret: 'your-api-secret',
+ *   secure: true,
+ *   folder: 'uploads'
+ * });
+ *
+ * // Upload with transformations
+ * await cloudinary.uploadFile('profile-pic.jpg', imageBuffer);
+ *
+ * // Get optimized URL
+ * const publicUrl = cloudinary.getPublicUrl('profile-pic.jpg');
+ * console.log(publicUrl); // Cloudinary optimized URL
+ * ```
+ */
+declare function createCloudinary(): CloudinaryService;
+declare function createCloudinary(config: CloudinaryConfig): CloudinaryService;
+
+export { CloudinaryService, createCloudinary };