nuxt-ui-elements 0.1.25 → 0.1.27

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ui-elements",
   "configKey": "uiElements",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -253,8 +253,8 @@ const module$1 = defineNuxtModule({
     addImportsDir(resolver.resolve("./runtime/composables"));
     addImports([
       {
-        name: "useUploader",
-        from: resolver.resolve("./runtime/composables/useUploader")
+        name: "useUploadManager",
+        from: resolver.resolve("./runtime/composables/useUploadManager")
       }
     ]);
     nuxt.options.alias["#std"] = resolver.resolve("./runtime/utils/std");

package/dist/runtime/composables/{useUploader → useUploadManager}/index.d.ts

@@ -1,152 +1,148 @@
-import type { PluginFn, UploaderEvents, UploadFile, UploadOptions, UploadStatus, UploadFn, GetRemoteFileFn } from "./types.js";
-export declare const useUploader: <TUploadResult = any>(_options?: UploadOptions) => {
-    files: Readonly<import("vue").Ref<readonly {
-        readonly id: string;
-        readonly name: string;
-        readonly size: number;
-        readonly mimeType: string;
-        readonly data: {
+import type { UploaderEvents, UploadFile, UploadOptions, UploadStatus, UploadFn, GetRemoteFileFn, Plugin as UploaderPlugin } from "./types.js";
+export declare const useUploadManager: <TUploadResult = any>(_options?: UploadOptions) => {
+    files: import("vue").Ref<{
+        id: string;
+        name: string;
+        size: number;
+        mimeType: string;
+        data: {
             readonly lastModified: number;
             readonly name: string;
             readonly webkitRelativePath: string;
             readonly size: number;
             readonly type: string;
-            readonly arrayBuffer: {
+            arrayBuffer: {
                 (): Promise<ArrayBuffer>;
                 (): Promise<ArrayBuffer>;
             };
-            readonly bytes: {
+            bytes: {
                 (): Promise<Uint8Array<ArrayBuffer>>;
                 (): Promise<Uint8Array<ArrayBuffer>>;
             };
-            readonly slice: {
+            slice: {
                 (start?: number, end?: number, contentType?: string): Blob;
                 (start?: number, end?: number, contentType?: string): Blob;
             };
-            readonly stream: {
+            stream: {
                 (): ReadableStream<Uint8Array<ArrayBuffer>>;
                 (): ReadableStream<Uint8Array<ArrayBuffer>>;
             };
-            readonly text: {
+            text: {
                 (): Promise<string>;
                 (): Promise<string>;
             };
         } | {
             readonly size: number;
             readonly type: string;
-            readonly arrayBuffer: {
+            arrayBuffer: {
                 (): Promise<ArrayBuffer>;
                 (): Promise<ArrayBuffer>;
             };
-            readonly bytes: {
+            bytes: {
                 (): Promise<Uint8Array<ArrayBuffer>>;
                 (): Promise<Uint8Array<ArrayBuffer>>;
             };
-            readonly slice: {
+            slice: {
                 (start?: number, end?: number, contentType?: string): Blob;
                 (start?: number, end?: number, contentType?: string): Blob;
             };
-            readonly stream: {
+            stream: {
                 (): ReadableStream<Uint8Array<ArrayBuffer>>;
                 (): ReadableStream<Uint8Array<ArrayBuffer>>;
             };
-            readonly text: {
+            text: {
                 (): Promise<string>;
                 (): Promise<string>;
             };
         };
-        readonly status: import("./types.js").FileStatus;
-        readonly preview?: string | undefined;
-        readonly progress: {
-            readonly percentage: number;
+        status: import("./types.js").FileStatus;
+        preview?: string | undefined;
+        progress: {
+            percentage: number;
         };
-        readonly error?: {
-            readonly message: string;
-            readonly details?: Readonly<unknown> | undefined;
+        error?: {
+            message: string;
+            details?: unknown;
         } | undefined;
-        readonly uploadResult?: import("vue").DeepReadonly<import("vue").UnwrapRef<TUploadResult>> | undefined;
-        readonly isRemote?: boolean | undefined;
-        readonly remoteUrl?: string | undefined;
-        readonly meta: {
-            readonly [x: string]: Readonly<unknown>;
-        };
-    }[], readonly {
-        readonly id: string;
-        readonly name: string;
-        readonly size: number;
-        readonly mimeType: string;
-        readonly data: {
+        uploadResult?: import("vue").UnwrapRef<TUploadResult> | undefined;
+        isRemote?: boolean | undefined;
+        remoteUrl?: string | undefined;
+        meta: Record<string, unknown>;
+    }[], UploadFile<TUploadResult>[] | {
+        id: string;
+        name: string;
+        size: number;
+        mimeType: string;
+        data: {
             readonly lastModified: number;
             readonly name: string;
             readonly webkitRelativePath: string;
             readonly size: number;
             readonly type: string;
-            readonly arrayBuffer: {
+            arrayBuffer: {
                 (): Promise<ArrayBuffer>;
                 (): Promise<ArrayBuffer>;
             };
-            readonly bytes: {
+            bytes: {
                 (): Promise<Uint8Array<ArrayBuffer>>;
                 (): Promise<Uint8Array<ArrayBuffer>>;
             };
-            readonly slice: {
+            slice: {
                 (start?: number, end?: number, contentType?: string): Blob;
                 (start?: number, end?: number, contentType?: string): Blob;
             };
-            readonly stream: {
+            stream: {
                 (): ReadableStream<Uint8Array<ArrayBuffer>>;
                 (): ReadableStream<Uint8Array<ArrayBuffer>>;
             };
-            readonly text: {
+            text: {
                 (): Promise<string>;
                 (): Promise<string>;
             };
         } | {
             readonly size: number;
             readonly type: string;
-            readonly arrayBuffer: {
+            arrayBuffer: {
                 (): Promise<ArrayBuffer>;
                 (): Promise<ArrayBuffer>;
             };
-            readonly bytes: {
+            bytes: {
                 (): Promise<Uint8Array<ArrayBuffer>>;
                 (): Promise<Uint8Array<ArrayBuffer>>;
             };
-            readonly slice: {
+            slice: {
                 (start?: number, end?: number, contentType?: string): Blob;
                 (start?: number, end?: number, contentType?: string): Blob;
             };
-            readonly stream: {
+            stream: {
                 (): ReadableStream<Uint8Array<ArrayBuffer>>;
                 (): ReadableStream<Uint8Array<ArrayBuffer>>;
             };
-            readonly text: {
+            text: {
                 (): Promise<string>;
                 (): Promise<string>;
             };
         };
-        readonly status: import("./types.js").FileStatus;
-        readonly preview?: string | undefined;
-        readonly progress: {
-            readonly percentage: number;
+        status: import("./types.js").FileStatus;
+        preview?: string | undefined;
+        progress: {
+            percentage: number;
         };
-        readonly error?: {
-            readonly message: string;
-            readonly details?: Readonly<unknown> | undefined;
+        error?: {
+            message: string;
+            details?: unknown;
         } | undefined;
-        readonly uploadResult?: import("vue").DeepReadonly<import("vue").UnwrapRef<TUploadResult>> | undefined;
-        readonly isRemote?: boolean | undefined;
-        readonly remoteUrl?: string | undefined;
-        readonly meta: {
-            readonly [x: string]: Readonly<unknown>;
-        };
-    }[]>>;
+        uploadResult?: import("vue").UnwrapRef<TUploadResult> | undefined;
+        isRemote?: boolean | undefined;
+        remoteUrl?: string | undefined;
+        meta: Record<string, unknown>;
+    }[]>;
     totalProgress: import("vue").ComputedRef<number>;
     addFiles: (newFiles: File[]) => Promise<(UploadFile<any> | null)[]>;
     addFile: (file: File) => Promise<UploadFile<any> | null>;
     onGetRemoteFile: (fn: GetRemoteFileFn) => void;
     onUpload: (fn: UploadFn<TUploadResult>) => void;
-    removeFile: (fileId: string) => void;
+    removeFile: (fileId: string) => Promise<void>;
     removeFiles: (fileIds: string[]) => {
         id: string;
         name: string;
@@ -360,9 +356,9 @@ export declare const useUploader: <TUploadResult = any>(_options?: UploadOptions
     status: import("vue").Ref<UploadStatus, UploadStatus>;
     updateFile: (fileId: string, updatedFile: Partial<UploadFile<TUploadResult>>) => void;
     initializeExistingFiles: (initialFiles: Array<Partial<UploadFile>>) => Promise<void>;
-    addPlugin: <TOptions>(fn: PluginFn<TOptions>, pluginOptions: TOptions) => void;
+    addPlugin: (plugin: UploaderPlugin<any, any>) => void;
     on: {
-        <Key extends keyof UploaderEvents<TUploadResult>>(type: Key, handler: import("mitt").Handler<UploaderEvents<TUploadResult>[Key]>): void;
-        (type: "*", handler: import("mitt").WildcardHandler<UploaderEvents<TUploadResult>>): void;
+        <K extends keyof UploaderEvents<TUploadResult>>(type: K, handler: (event: UploaderEvents<TUploadResult>[K]) => void): void;
+        (type: string, handler: (event: any) => void): void;
     };
 };

package/dist/runtime/composables/{useUploader → useUploadManager}/index.js

@@ -1,5 +1,5 @@
 import mitt from "mitt";
-import { computed, readonly, ref } from "vue";
+import { computed, ref } from "vue";
 import { ValidatorAllowedFileTypes, ValidatorMaxfileSize, ValidatorMaxFiles } from "./validators/index.js";
 import { PluginThumbnailGenerator, PluginImageCompressor } from "./plugins/index.js";
 function getExtension(fullFileName) {
@@ -18,11 +18,23 @@ const defaultOptions = {
   imageCompression: false,
   autoProceed: false
 };
-export const useUploader = (_options = {}) => {
+export const useUploadManager = (_options = {}) => {
   const options = { ...defaultOptions, ..._options };
   const files = ref([]);
   const emitter = mitt();
   const status = ref("waiting");
+  const pluginEmitFunctions = /* @__PURE__ */ new Map();
+  const getPluginEmitFn = (pluginId) => {
+    let emitFn = pluginEmitFunctions.get(pluginId);
+    if (!emitFn) {
+      emitFn = (event, payload) => {
+        const prefixedEvent = `${pluginId}:${String(event)}`;
+        emitter.emit(prefixedEvent, payload);
+      };
+      pluginEmitFunctions.set(pluginId, emitFn);
+    }
+    return emitFn;
+  };
   let uploadFn = async () => {
     throw new Error("No uploader configured");
   };
@@ -34,37 +46,71 @@ export const useUploader = (_options = {}) => {
     const sum = files.value.reduce((acc, file) => acc + file.progress.percentage, 0);
     return Math.round(sum / files.value.length);
   });
-  const addPlugin = (fn, pluginOptions) => {
-    const plugin = fn({ files: files.value, options }, pluginOptions);
+  const isStoragePlugin = (plugin) => {
+    return !!(plugin.hooks.upload || plugin.hooks.getRemoteFile || plugin.hooks.remove);
+  };
+  const getStoragePlugin = () => {
+    if (!options.plugins) return null;
+    for (let i = options.plugins.length - 1; i >= 0; i--) {
+      const plugin = options.plugins[i];
+      if (plugin && isStoragePlugin(plugin)) {
+        return plugin;
+      }
+    }
+    return null;
+  };
+  const addPlugin = (plugin) => {
+    if (isStoragePlugin(plugin)) {
+      const existingStorage = options.plugins?.find((p) => isStoragePlugin(p));
+      if (existingStorage && import.meta.dev) {
+        console.warn(
+          `[useUploadManager] Multiple storage plugins detected!
+
+You're trying to add "${plugin.id}" but "${existingStorage.id}" is already registered.
+The LAST storage plugin ("${plugin.id}") will be used for uploads.
+
+\u{1F4A1} If you need multiple storage destinations, create separate uploader instances:
+
+   const s3Uploader = useUploadManager({ plugins: [PluginS3Storage({ ... })] })
+   const azureUploader = useUploadManager({ plugins: [PluginAzureStorage({ ... })] })
+`
+        );
+      }
+    }
+    ;
     options.plugins?.push(plugin);
   };
   if (options.maxFiles !== false && options.maxFiles !== void 0) {
-    addPlugin(ValidatorMaxFiles, { maxFiles: options.maxFiles });
+    addPlugin(ValidatorMaxFiles({ maxFiles: options.maxFiles }));
   }
   if (options.maxFileSize !== false && options.maxFileSize !== void 0) {
-    addPlugin(ValidatorMaxfileSize, { maxFileSize: options.maxFileSize });
+    addPlugin(ValidatorMaxfileSize({ maxFileSize: options.maxFileSize }));
   }
   if (options.allowedFileTypes !== false && options.allowedFileTypes !== void 0 && options.allowedFileTypes.length > 0) {
-    addPlugin(ValidatorAllowedFileTypes, { allowedFileTypes: options.allowedFileTypes });
+    addPlugin(ValidatorAllowedFileTypes({ allowedFileTypes: options.allowedFileTypes }));
   }
   if (options.thumbnails !== false && options.thumbnails !== void 0) {
     const thumbOpts = options.thumbnails === true ? {} : options.thumbnails || {};
-    addPlugin(PluginThumbnailGenerator, {
-      width: thumbOpts.width ?? 128,
-      height: thumbOpts.height ?? 128,
-      quality: thumbOpts.quality ?? 1
-    });
+    addPlugin(
+      PluginThumbnailGenerator({
+        width: thumbOpts.width ?? 128,
+        height: thumbOpts.height ?? 128,
+        quality: thumbOpts.quality ?? 1
+      })
+    );
   }
   if (options.imageCompression !== false && options.imageCompression !== void 0) {
     const compressionOpts = options.imageCompression === true ? {} : options.imageCompression || {};
-    addPlugin(PluginImageCompressor, {
-      maxWidth: compressionOpts.maxWidth ?? 1920,
-      maxHeight: compressionOpts.maxHeight ?? 1920,
-      quality: compressionOpts.quality ?? 0.85,
-      outputFormat: compressionOpts.outputFormat ?? "auto",
-      minSizeToCompress: compressionOpts.minSizeToCompress ?? 1e5,
-      preserveMetadata: compressionOpts.preserveMetadata ?? true
-    });
+    addPlugin(
+      PluginImageCompressor({
+        maxWidth: compressionOpts.maxWidth ?? 1920,
+        maxHeight: compressionOpts.maxHeight ?? 1920,
+        quality: compressionOpts.quality ?? 0.85,
+        outputFormat: compressionOpts.outputFormat ?? "auto",
+        minSizeToCompress: compressionOpts.minSizeToCompress ?? 1e5,
+        preserveMetadata: compressionOpts.preserveMetadata ?? true
+      })
+    );
   }
   emitter.on("upload:progress", ({ file, progress }) => {
     updateFile(file.id, { progress: { percentage: progress } });
@@ -82,7 +128,21 @@ export const useUploader = (_options = {}) => {
     const initializedfiles = await Promise.all(
       initialFiles.map(async (file) => {
         if (!file.id) return null;
-        const { mimeType, size, remoteUrl } = await getRemoteFileFn(file.id);
+        const storagePlugin = getStoragePlugin();
+        let remoteFileData;
+        if (storagePlugin?.hooks.getRemoteFile) {
+          const context = {
+            files: files.value,
+            options,
+            emit: (event, payload) => {
+              const prefixedEvent = `${storagePlugin.id}:${String(event)}`;
+              emitter.emit(prefixedEvent, payload);
+            }
+          };
+          remoteFileData = await storagePlugin.hooks.getRemoteFile(file.id, context);
+        } else {
+          remoteFileData = await getRemoteFileFn(file.id);
+        }
         const existingFile = {
           ...file,
           id: file.id,
@@ -91,9 +151,9 @@ export const useUploader = (_options = {}) => {
           status: "complete",
           progress: { percentage: 100 },
           meta: {},
-          size,
-          mimeType,
-          remoteUrl
+          size: remoteFileData.size,
+          mimeType: remoteFileData.mimeType,
+          remoteUrl: remoteFileData.remoteUrl
         };
         const processedFile = await runPluginStage("process", existingFile);
         if (!processedFile) return null;
@@ -134,9 +194,25 @@ export const useUploader = (_options = {}) => {
   const addFiles = (newFiles) => {
     return Promise.all(newFiles.map((file) => addFile(file)));
   };
-  const removeFile = (fileId) => {
+  const removeFile = async (fileId) => {
     const file = files.value.find((f) => f.id === fileId);
     if (!file) return;
+    const storagePlugin = getStoragePlugin();
+    if (storagePlugin?.hooks.remove) {
+      try {
+        const context = {
+          files: files.value,
+          options,
+          emit: (event, payload) => {
+            const prefixedEvent = `${storagePlugin.id}:${String(event)}`;
+            emitter.emit(prefixedEvent, payload);
+          }
+        };
+        await storagePlugin.hooks.remove(file, context);
+      } catch (error) {
+        console.error(`Storage plugin remove error:`, error);
+      }
+    }
     files.value = files.value.filter((f) => f.id !== fileId);
     emitter.emit("file:removed", file);
   };
@@ -188,7 +264,22 @@ export const useUploader = (_options = {}) => {
           updateFile(file.id, { progress: { percentage: progress } });
           emitter.emit("upload:progress", { file, progress });
         };
-        const uploadResult = await uploadFn(file, onProgress);
+        const storagePlugin = getStoragePlugin();
+        let uploadResult;
+        if (storagePlugin?.hooks.upload) {
+          const context = {
+            files: files.value,
+            options,
+            onProgress,
+            emit: (event, payload) => {
+              const prefixedEvent = `${storagePlugin.id}:${String(event)}`;
+              emitter.emit(prefixedEvent, payload);
+            }
+          };
+          uploadResult = await storagePlugin.hooks.upload(file, context);
+        } else {
+          uploadResult = await uploadFn(file, onProgress);
+        }
         updateFile(file.id, { status: "complete", uploadResult });
       } catch (err) {
         const error = {
@@ -225,12 +316,16 @@ export const useUploader = (_options = {}) => {
   };
   async function runPluginStage(stage, file) {
     if (!options.plugins) return file;
-    const context = { files: files.value, options };
     let currentFile = file;
     for (const plugin of options.plugins) {
       const hook = plugin.hooks[stage];
       if (hook) {
         try {
+          const context = {
+            files: files.value,
+            options,
+            emit: getPluginEmitFn(plugin.id)
+          };
           const result = await callPluginHook(hook, stage, currentFile, context);
           if (!result) continue;
           if (currentFile && "id" in result) {
@@ -249,7 +344,7 @@ export const useUploader = (_options = {}) => {
   }
   return {
     // State
-    files: readonly(files),
+    files,
     totalProgress,
     // Core Methods
     addFiles,
@@ -268,7 +363,7 @@ export const useUploader = (_options = {}) => {
     initializeExistingFiles,
     // Utilities
     addPlugin,
-    // Events
+    // Events - autocomplete for core events, allow arbitrary strings for plugin events
     on: emitter.on
   };
 };

package/dist/runtime/composables/{useUploader → useUploadManager}/plugins/image-compressor.d.ts

@@ -1,4 +1,25 @@
-import type { PluginFn } from "../types.js";
+import type { UploadFile } from "../types.js";
+/**
+ * Events emitted by the image compressor plugin
+ * Note: These are automatically prefixed with "image-compressor:" by the plugin system
+ * e.g., "start" becomes "image-compressor:start"
+ */
+type ImageCompressorEvents = {
+    start: {
+        file: UploadFile;
+        originalSize: number;
+    };
+    complete: {
+        file: UploadFile;
+        originalSize: number;
+        compressedSize: number;
+        savedBytes: number;
+    };
+    skip: {
+        file: UploadFile;
+        reason: string;
+    };
+};
 interface ImageCompressorOptions {
     /**
      * Maximum width in pixels. Images wider than this will be scaled down.
@@ -31,19 +52,5 @@ interface ImageCompressorOptions {
      */
     preserveMetadata?: boolean;
 }
-/**
- * Compresses images before upload to reduce bandwidth and storage costs.
- * Particularly useful for social media scheduling where images are often large.
- *
- * @example
- * ```ts
- * const uploader = useUpload()
- * uploader.addPlugin(PluginImageCompressor, {
- *   maxWidth: 2048,
- *   quality: 0.85,
- *   outputFormat: 'webp'
- * })
- * ```
- */
-export declare const PluginImageCompressor: PluginFn<ImageCompressorOptions>;
+export declare const PluginImageCompressor: (options: ImageCompressorOptions) => import("../types.js").Plugin<any, ImageCompressorEvents>;
 export {};

package/dist/runtime/composables/{useUploader → useUploadManager}/plugins/image-compressor.js

@@ -1,29 +1,36 @@
-export const PluginImageCompressor = (_, pluginOptions) => {
+import { defineUploaderPlugin } from "../types.js";
+export const PluginImageCompressor = defineUploaderPlugin((pluginOptions) => {
   const {
     maxWidth = 1920,
     maxHeight = 1920,
     quality = 0.85,
     outputFormat = "auto",
-    minSizeToCompress = 1e5,
+    minSizeToCompress = 1e5
     // 100KB
-    preserveMetadata = true
   } = pluginOptions;
   return {
     id: "image-compressor",
     hooks: {
-      process: async (file) => {
+      process: async (file, context) => {
         if (!file.mimeType.startsWith("image/")) {
           return file;
         }
         if (file.mimeType === "image/gif") {
+          context.emit("skip", { file, reason: "GIF format not supported" });
           return file;
         }
         if (file.mimeType === "image/svg+xml") {
+          context.emit("skip", { file, reason: "SVG already optimized" });
           return file;
         }
         if (file.size < minSizeToCompress) {
+          context.emit("skip", {
+            file,
+            reason: `File size (${file.size} bytes) below minimum threshold`
+          });
           return file;
         }
+        context.emit("start", { file, originalSize: file.size });
         try {
           const sourceUrl = URL.createObjectURL(file.data);
           const image = new Image();
@@ -35,6 +42,10 @@ export const PluginImageCompressor = (_, pluginOptions) => {
           const needsResize = image.width > maxWidth || image.height > maxHeight;
           if (!needsResize && outputFormat === "auto") {
             URL.revokeObjectURL(sourceUrl);
+            context.emit("skip", {
+              file,
+              reason: "Image within size limits and format is auto"
+            });
             return file;
           }
           let targetWidth = image.width;
@@ -79,6 +90,13 @@ export const PluginImageCompressor = (_, pluginOptions) => {
           });
           URL.revokeObjectURL(sourceUrl);
           if (compressedBlob.size < file.size) {
+            const savedBytes = file.size - compressedBlob.size;
+            context.emit("complete", {
+              file,
+              originalSize: file.size,
+              compressedSize: compressedBlob.size,
+              savedBytes
+            });
             let newId = file.id;
             if (outputFormat !== "auto" && outputFormat !== file.meta.extension) {
               const extension = outputFormat === "jpeg" ? "jpg" : outputFormat;
@@ -100,6 +118,10 @@ export const PluginImageCompressor = (_, pluginOptions) => {
               }
             };
           }
+          context.emit("skip", {
+            file,
+            reason: "Compressed version larger than original"
+          });
           return file;
         } catch (error) {
           console.warn(`Image compression failed for ${file.name}:`, error);
@@ -108,4 +130,4 @@ export const PluginImageCompressor = (_, pluginOptions) => {
       }
     }
   };
-};
+});

package/dist/runtime/composables/{useUploader → useUploadManager}/plugins/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./thumbnail-generator.js";
 export * from "./image-compressor.js";
+export * from "./storage/index.js";

package/dist/runtime/composables/{useUploader → useUploadManager}/plugins/index.js

@@ -1,2 +1,3 @@
 export * from "./thumbnail-generator.js";
 export * from "./image-compressor.js";
+export * from "./storage/index.js";

package/dist/runtime/composables/useUploadManager/plugins/storage/azure-datalake.d.ts

@@ -0,0 +1,45 @@
+type PathHttpHeaders = import("@azure/storage-file-datalake").PathHttpHeaders;
+export interface AzureDataLakeOptions {
+    /**
+     * Static SAS URL for Azure Data Lake Storage
+     */
+    sasURL?: string;
+    /**
+     * Function to dynamically fetch SAS URL
+     * Use this to handle token expiration/refreshing.
+     * If provided, it will be called before every file operation.
+     */
+    getSASUrl?: () => Promise<string>;
+    /**
+     * Optional subdirectory path within the container
+     * @example "uploads/images"
+     */
+    path?: string;
+    /**
+     * Custom metadata to attach to uploaded files
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Custom HTTP headers for uploaded files
+     */
+    pathHttpHeaders?: Omit<PathHttpHeaders, "contentType">;
+    /**
+     * Automatically try to create the directory if it doesn't exist.
+     * Disable this if your SAS token only has 'Write' (Blob) permissions
+     * and not 'Create' (Directory) permissions.
+     * @default true
+     */
+    autoCreateDirectory?: boolean;
+}
+export interface AzureUploadResult {
+    /**
+     * Full URL to the uploaded file
+     */
+    url: string;
+    /**
+     * File name/path in the storage
+     */
+    blobPath: string;
+}
+export declare const PluginAzureDataLake: (options: AzureDataLakeOptions) => import("../../types.js").Plugin<any, Record<string, never>>;
+export {};