@uploadista/vue 0.0.3 → 0.0.6

package/dist/index-DgHJHePD.d.mts

@@ -0,0 +1,1419 @@
+import * as vue1 from "vue";
+import { App, InjectionKey, Ref } from "vue";
+import * as _uploadista_client_browser0 from "@uploadista/client-browser";
+import { BrowserUploadInput, FlowUploadConfig, MultiFlowUploadOptions, UploadOptions, UploadistaClientOptions, UploadistaEvent, createUploadistaClient } from "@uploadista/client-browser";
+import { UploadFile } from "@uploadista/core/types";
+import * as _uploadista_client_core0 from "@uploadista/client-core";
+import * as _uploadista_core0 from "@uploadista/core";
+
+//#region src/composables/plugin.d.ts
+interface UploadistaPluginOptions extends UploadistaClientOptions {
+  /**
+   * Global event handler for all upload and flow events from this client
+   */
+  onEvent?: UploadistaClientOptions["onEvent"];
+}
+declare const UPLOADISTA_CLIENT_KEY: InjectionKey<ReturnType<typeof createUploadistaClient>>;
+declare const UPLOADISTA_EVENT_SUBSCRIBERS_KEY: InjectionKey<Ref<Set<(event: UploadistaEvent) => void>>>;
+/**
+ * Vue plugin for providing Uploadista client instance globally.
+ * Uses Vue's provide/inject pattern to make the client available
+ * throughout the component tree.
+ *
+ * @param options - Uploadista client configuration options
+ * @returns Vue plugin object
+ *
+ * @example
+ * ```typescript
+ * import { createApp } from 'vue';
+ * import { createUploadistaPlugin } from '@uploadista/vue';
+ * import App from './App.vue';
+ *
+ * const app = createApp(App);
+ *
+ * app.use(createUploadistaPlugin({
+ *   baseUrl: 'https://api.example.com',
+ *   storageId: 'my-storage',
+ *   chunkSize: 1024 * 1024, // 1MB
+ *   storeFingerprintForResuming: true,
+ *   onEvent: (event) => {
+ *     console.log('Upload event:', event);
+ *   }
+ * }));
+ *
+ * app.mount('#app');
+ * ```
+ */
+declare function createUploadistaPlugin(options: UploadistaPluginOptions): {
+  install(app: App): void;
+};
+//#endregion
+//#region src/composables/useDragDrop.d.ts
+interface DragDropOptions {
+  /**
+   * Accept specific file types (MIME types or file extensions)
+   */
+  accept?: string[];
+  /**
+   * Maximum number of files allowed
+   */
+  maxFiles?: number;
+  /**
+   * Maximum file size in bytes
+   */
+  maxFileSize?: number;
+  /**
+   * Whether to allow multiple files
+   */
+  multiple?: boolean;
+  /**
+   * Custom validation function for files
+   */
+  validator?: (files: File[]) => string[] | null;
+  /**
+   * Called when files are dropped or selected
+   */
+  onFilesReceived?: (files: File[]) => void;
+  /**
+   * Called when validation fails
+   */
+  onValidationError?: (errors: string[]) => void;
+  /**
+   * Called when drag state changes
+   */
+  onDragStateChange?: (isDragging: boolean) => void;
+}
+interface DragDropState {
+  /**
+   * Whether files are currently being dragged over the drop zone
+   */
+  isDragging: boolean;
+  /**
+   * Whether the drag is currently over the drop zone
+   */
+  isOver: boolean;
+  /**
+   * Whether the dragged items are valid files
+   */
+  isValid: boolean;
+  /**
+   * Current validation errors
+   */
+  errors: string[];
+}
+/**
+ * Vue composable for handling drag and drop file uploads with validation.
+ * Provides drag state management, file validation, and file picker integration.
+ *
+ * @param options - Configuration and event handlers
+ * @returns Drag and drop state and handlers
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useDragDrop } from '@uploadista/vue';
+ * import { ref } from 'vue';
+ *
+ * const inputRef = ref<HTMLInputElement>();
+ *
+ * const dragDrop = useDragDrop({
+ *   accept: ['image/*', '.pdf'],
+ *   maxFiles: 5,
+ *   maxFileSize: 10 * 1024 * 1024, // 10MB
+ *   multiple: true,
+ *   onFilesReceived: (files) => {
+ *     console.log('Received files:', files);
+ *     // Process files with upload composables
+ *   },
+ *   onValidationError: (errors) => {
+ *     console.error('Validation errors:', errors);
+ *   },
+ * });
+ *
+ * const openFilePicker = () => {
+ *   inputRef.value?.click();
+ * };
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <div
+ *       @dragenter="dragDrop.onDragEnter"
+ *       @dragover="dragDrop.onDragOver"
+ *       @dragleave="dragDrop.onDragLeave"
+ *       @drop="dragDrop.onDrop"
+ *       @click="openFilePicker"
+ *       :style="{
+ *         border: dragDrop.state.isDragging ? '2px dashed #007bff' : '2px dashed #ccc',
+ *         backgroundColor: dragDrop.state.isOver ? '#f8f9fa' : 'transparent',
+ *         padding: '2rem',
+ *         textAlign: 'center',
+ *         cursor: 'pointer',
+ *       }"
+ *     >
+ *       <p v-if="dragDrop.state.isDragging">Drop files here...</p>
+ *       <p v-else>Drag files here or click to select</p>
+ *
+ *       <div v-if="dragDrop.state.errors.length > 0" style="color: red; margin-top: 1rem">
+ *         <p v-for="(error, index) in dragDrop.state.errors" :key="index">{{ error }}</p>
+ *       </div>
+ *     </div>
+ *
+ *     <input
+ *       ref="inputRef"
+ *       type="file"
+ *       :multiple="dragDrop.inputProps.multiple"
+ *       :accept="dragDrop.inputProps.accept"
+ *       @change="dragDrop.onInputChange"
+ *       style="display: none"
+ *     />
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useDragDrop(options?: DragDropOptions): {
+  state: Readonly<vue1.Ref<{
+    readonly isDragging: boolean;
+    readonly isOver: boolean;
+    readonly isValid: boolean;
+    readonly errors: readonly string[];
+  }, {
+    readonly isDragging: boolean;
+    readonly isOver: boolean;
+    readonly isValid: boolean;
+    readonly errors: readonly string[];
+  }>>;
+  onDragEnter: (event: DragEvent) => void;
+  onDragOver: (event: DragEvent) => void;
+  onDragLeave: (event: DragEvent) => void;
+  onDrop: (event: DragEvent) => void;
+  onInputChange: (event: Event) => void;
+  inputProps: vue1.ComputedRef<{
+    type: "file";
+    multiple: boolean;
+    accept: string | undefined;
+  }>;
+  processFiles: (files: File[]) => void;
+  reset: () => void;
+};
+//#endregion
+//#region src/composables/useFlowUpload.d.ts
+type FlowUploadStatus = "idle" | "uploading" | "processing" | "success" | "error" | "aborted";
+interface FlowUploadState<TOutput = UploadFile> {
+  status: FlowUploadStatus;
+  progress: number;
+  bytesUploaded: number;
+  totalBytes: number | null;
+  error: Error | null;
+  result: TOutput | null;
+  jobId: string | null;
+  flowStarted: boolean;
+  currentNodeName: string | null;
+  currentNodeType: string | null;
+  flowOutputs: Record<string, unknown> | null;
+}
+interface UseFlowUploadOptions<TOutput = UploadFile> {
+  /**
+   * Flow configuration
+   */
+  flowConfig: FlowUploadConfig;
+  /**
+   * Called when upload progress updates
+   */
+  onProgress?: (progress: number, bytesUploaded: number, totalBytes: number | null) => void;
+  /**
+   * Called when a chunk completes
+   */
+  onChunkComplete?: (chunkSize: number, bytesAccepted: number, bytesTotal: number | null) => void;
+  /**
+   * Called when the flow completes successfully (receives full flow outputs)
+   * This is the recommended callback for multi-output flows
+   * Format: { [outputNodeId]: result, ... }
+   */
+  onFlowComplete?: (outputs: Record<string, unknown>) => void;
+  /**
+   * Called when upload succeeds (legacy, single-output flows)
+   * For single-output flows, receives the value from the specified outputNodeId
+   * or the first output node if outputNodeId is not specified
+   */
+  onSuccess?: (result: TOutput) => void;
+  /**
+   * Called when upload fails
+   */
+  onError?: (error: Error) => void;
+  /**
+   * Called when upload is aborted
+   */
+  onAbort?: () => void;
+  /**
+   * Custom retry logic
+   */
+  onShouldRetry?: (error: Error, retryAttempt: number) => boolean;
+}
+/**
+ * Vue composable for uploading files through a flow.
+ *
+ * This composable provides a simple interface for uploading files through a flow.
+ * The flow handles the upload process and can perform post-processing like
+ * saving to storage, optimizing images, etc.
+ *
+ * Must be used within a component tree that has the Uploadista plugin installed.
+ * Events are automatically wired up through the plugin.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useFlowUpload } from '@uploadista/vue';
+ *
+ * const flowUpload = useFlowUpload({
+ *   flowConfig: {
+ *     flowId: "my-upload-flow",
+ *     storageId: "my-storage",
+ *   },
+ *   onSuccess: (result) => {
+ *     console.log("Upload complete:", result);
+ *   },
+ * });
+ *
+ * const handleFileChange = (event: Event) => {
+ *   const file = (event.target as HTMLInputElement).files?.[0];
+ *   if (file) flowUpload.upload(file);
+ * };
+ * </script>
+ *
+ * <template>
+ *   <input type="file" @change="handleFileChange" />
+ * </template>
+ * ```
+ */
+declare function useFlowUpload<TOutput = UploadFile>(options: UseFlowUploadOptions<TOutput>): {
+  state: Readonly<vue1.Ref<{
+    readonly status: FlowUploadStatus;
+    readonly progress: number;
+    readonly bytesUploaded: number;
+    readonly totalBytes: number | null;
+    readonly error: Error | null;
+    readonly result: vue1.DeepReadonly<vue1.UnwrapRef<TOutput>> | null;
+    readonly jobId: string | null;
+    readonly flowStarted: boolean;
+    readonly currentNodeName: string | null;
+    readonly currentNodeType: string | null;
+    readonly flowOutputs: {
+      readonly [x: string]: Readonly<unknown>;
+    } | null;
+  }, {
+    readonly status: FlowUploadStatus;
+    readonly progress: number;
+    readonly bytesUploaded: number;
+    readonly totalBytes: number | null;
+    readonly error: Error | null;
+    readonly result: vue1.DeepReadonly<vue1.UnwrapRef<TOutput>> | null;
+    readonly jobId: string | null;
+    readonly flowStarted: boolean;
+    readonly currentNodeName: string | null;
+    readonly currentNodeType: string | null;
+    readonly flowOutputs: {
+      readonly [x: string]: Readonly<unknown>;
+    } | null;
+  }>>;
+  upload: (file: File | Blob) => Promise<void>;
+  abort: () => void;
+  reset: () => void;
+  isUploading: vue1.ComputedRef<boolean>;
+  isUploadingFile: vue1.ComputedRef<boolean>;
+  isProcessing: vue1.ComputedRef<boolean>;
+};
+//#endregion
+//#region src/composables/useMultiFlowUpload.d.ts
+/**
+ * Vue composable for uploading multiple files through a flow.
+ *
+ * Must be used within a component tree that has the Uploadista plugin installed.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useMultiFlowUpload } from '@uploadista/vue';
+ *
+ * const multiFlowUpload = useMultiFlowUpload({
+ *   flowConfig: {
+ *     flowId: "batch-upload-flow",
+ *     inputNodeId: "upload-node",
+ *     storageId: "my-storage",
+ *   },
+ *   maxConcurrent: 3,
+ *   onComplete: (items) => {
+ *     console.log("All uploads complete:", items);
+ *   },
+ * });
+ *
+ * const handleFileChange = (event: Event) => {
+ *   const files = (event.target as HTMLInputElement).files;
+ *   if (files) {
+ *     multiFlowUpload.addFiles(files);
+ *     multiFlowUpload.startUpload();
+ *   }
+ * };
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <input type="file" multiple @change="handleFileChange" />
+ *
+ *     <div v-for="item in multiFlowUpload.state.items" :key="item.id">
+ *       <span>{{ item.file.name }}</span>
+ *       <progress :value="item.progress" :max="100" />
+ *       <button
+ *         v-if="item.status === 'uploading'"
+ *         @click="multiFlowUpload.abortUpload(item.id)"
+ *       >
+ *         Cancel
+ *       </button>
+ *     </div>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useMultiFlowUpload(options: MultiFlowUploadOptions<BrowserUploadInput>): {
+  state: Readonly<vue1.Ref<{
+    readonly items: readonly {
+      readonly id: string;
+      readonly file: {
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+        readonly size: number;
+        readonly type: string;
+        readonly arrayBuffer: () => Promise<ArrayBuffer>;
+        readonly bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+        readonly slice: (start?: number, end?: number, contentType?: string) => Blob;
+        readonly stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+        readonly text: () => Promise<string>;
+      } | {
+        readonly size: number;
+        readonly type: string;
+        readonly arrayBuffer: () => Promise<ArrayBuffer>;
+        readonly bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+        readonly slice: (start?: number, end?: number, contentType?: string) => Blob;
+        readonly stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+        readonly text: () => Promise<string>;
+      };
+      readonly status: "pending" | "uploading" | "success" | "error" | "aborted";
+      readonly progress: number;
+      readonly bytesUploaded: number;
+      readonly totalBytes: number;
+      readonly error: Error | null;
+      readonly result: {
+        readonly id: string;
+        readonly offset: number;
+        readonly storage: {
+          readonly id: string;
+          readonly type: string;
+          readonly path?: string | undefined | undefined;
+          readonly uploadId?: string | undefined | undefined;
+          readonly bucket?: string | undefined | undefined;
+        };
+        readonly flow?: {
+          readonly flowId: string;
+          readonly nodeId: string;
+          readonly jobId: string;
+        } | undefined;
+        readonly size?: number | undefined | undefined;
+        readonly metadata?: {
+          readonly [x: string]: string | number | boolean;
+        } | undefined;
+        readonly creationDate?: string | undefined | undefined;
+        readonly url?: string | undefined | undefined;
+        readonly sizeIsDeferred?: boolean | undefined | undefined;
+        readonly checksum?: string | undefined | undefined;
+        readonly checksumAlgorithm?: string | undefined | undefined;
+      } | null;
+      readonly jobId: string | null;
+    }[];
+    readonly totalProgress: number;
+    readonly activeUploads: number;
+    readonly completedUploads: number;
+    readonly failedUploads: number;
+  }, {
+    readonly items: readonly {
+      readonly id: string;
+      readonly file: {
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+        readonly size: number;
+        readonly type: string;
+        readonly arrayBuffer: () => Promise<ArrayBuffer>;
+        readonly bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+        readonly slice: (start?: number, end?: number, contentType?: string) => Blob;
+        readonly stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+        readonly text: () => Promise<string>;
+      } | {
+        readonly size: number;
+        readonly type: string;
+        readonly arrayBuffer: () => Promise<ArrayBuffer>;
+        readonly bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+        readonly slice: (start?: number, end?: number, contentType?: string) => Blob;
+        readonly stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+        readonly text: () => Promise<string>;
+      };
+      readonly status: "pending" | "uploading" | "success" | "error" | "aborted";
+      readonly progress: number;
+      readonly bytesUploaded: number;
+      readonly totalBytes: number;
+      readonly error: Error | null;
+      readonly result: {
+        readonly id: string;
+        readonly offset: number;
+        readonly storage: {
+          readonly id: string;
+          readonly type: string;
+          readonly path?: string | undefined | undefined;
+          readonly uploadId?: string | undefined | undefined;
+          readonly bucket?: string | undefined | undefined;
+        };
+        readonly flow?: {
+          readonly flowId: string;
+          readonly nodeId: string;
+          readonly jobId: string;
+        } | undefined;
+        readonly size?: number | undefined | undefined;
+        readonly metadata?: {
+          readonly [x: string]: string | number | boolean;
+        } | undefined;
+        readonly creationDate?: string | undefined | undefined;
+        readonly url?: string | undefined | undefined;
+        readonly sizeIsDeferred?: boolean | undefined | undefined;
+        readonly checksum?: string | undefined | undefined;
+        readonly checksumAlgorithm?: string | undefined | undefined;
+      } | null;
+      readonly jobId: string | null;
+    }[];
+    readonly totalProgress: number;
+    readonly activeUploads: number;
+    readonly completedUploads: number;
+    readonly failedUploads: number;
+  }>>;
+  addFiles: (files: File[] | FileList) => void;
+  removeFile: (id: string) => void;
+  startUpload: () => void;
+  abortUpload: (id: string) => void;
+  abortAll: () => void;
+  clear: () => void;
+  retryUpload: (id: string) => void;
+  isUploading: vue1.ComputedRef<boolean>;
+};
+//#endregion
+//#region src/composables/useUpload.d.ts
+type UploadInput = File | Blob;
+type ChunkMetrics = any;
+type PerformanceInsights = any;
+type UploadSessionMetrics = any;
+type UploadStatus = "idle" | "uploading" | "success" | "error" | "aborted";
+interface UploadState {
+  status: UploadStatus;
+  progress: number;
+  bytesUploaded: number;
+  totalBytes: number | null;
+  error: Error | null;
+  result: UploadFile | null;
+}
+interface UploadMetrics {
+  /**
+   * Get performance insights from the upload client
+   */
+  getInsights: () => PerformanceInsights;
+  /**
+   * Export detailed metrics from the upload client
+   */
+  exportMetrics: () => {
+    session: Partial<UploadSessionMetrics>;
+    chunks: ChunkMetrics[];
+    insights: PerformanceInsights;
+  };
+  /**
+   * Get current network metrics
+   */
+  getNetworkMetrics: () => unknown;
+  /**
+   * Get current network condition
+   */
+  getNetworkCondition: () => unknown;
+  /**
+   * Reset all metrics
+   */
+  resetMetrics: () => void;
+}
+/**
+ * Vue composable for managing individual file uploads with full state management.
+ * Provides upload progress tracking, error handling, abort functionality, and retry logic.
+ *
+ * Must be used within a component tree that has the Uploadista plugin installed.
+ *
+ * @param options - Upload configuration and event handlers
+ * @returns Upload state and control methods
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useUpload } from '@uploadista/vue';
+ *
+ * const upload = useUpload({
+ *   onSuccess: (result) => console.log('Upload complete:', result),
+ *   onError: (error) => console.error('Upload failed:', error),
+ *   onProgress: (progress) => console.log('Progress:', progress + '%'),
+ * });
+ *
+ * const handleFileChange = (event: Event) => {
+ *   const file = (event.target as HTMLInputElement).files?.[0];
+ *   if (file) upload.upload(file);
+ * };
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <input type="file" @change="handleFileChange" />
+ *     <div v-if="upload.isUploading">Progress: {{ upload.state.progress }}%</div>
+ *     <div v-if="upload.state.error">Error: {{ upload.state.error.message }}</div>
+ *     <button v-if="upload.canRetry" @click="upload.retry">Retry</button>
+ *     <button @click="upload.abort" :disabled="!upload.isUploading">Abort</button>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useUpload(options?: UploadOptions): {
+  state: Readonly<vue1.Ref<{
+    readonly status: UploadStatus;
+    readonly progress: number;
+    readonly bytesUploaded: number;
+    readonly totalBytes: number | null;
+    readonly error: Error | null;
+    readonly result: {
+      readonly id: string;
+      readonly offset: number;
+      readonly storage: {
+        readonly id: string;
+        readonly type: string;
+        readonly path?: string | undefined | undefined;
+        readonly uploadId?: string | undefined | undefined;
+        readonly bucket?: string | undefined | undefined;
+      };
+      readonly flow?: {
+        readonly flowId: string;
+        readonly nodeId: string;
+        readonly jobId: string;
+      } | undefined;
+      readonly size?: number | undefined | undefined;
+      readonly metadata?: {
+        readonly [x: string]: string | number | boolean;
+      } | undefined;
+      readonly creationDate?: string | undefined | undefined;
+      readonly url?: string | undefined | undefined;
+      readonly sizeIsDeferred?: boolean | undefined | undefined;
+      readonly checksum?: string | undefined | undefined;
+      readonly checksumAlgorithm?: string | undefined | undefined;
+    } | null;
+  }, {
+    readonly status: UploadStatus;
+    readonly progress: number;
+    readonly bytesUploaded: number;
+    readonly totalBytes: number | null;
+    readonly error: Error | null;
+    readonly result: {
+      readonly id: string;
+      readonly offset: number;
+      readonly storage: {
+        readonly id: string;
+        readonly type: string;
+        readonly path?: string | undefined | undefined;
+        readonly uploadId?: string | undefined | undefined;
+        readonly bucket?: string | undefined | undefined;
+      };
+      readonly flow?: {
+        readonly flowId: string;
+        readonly nodeId: string;
+        readonly jobId: string;
+      } | undefined;
+      readonly size?: number | undefined | undefined;
+      readonly metadata?: {
+        readonly [x: string]: string | number | boolean;
+      } | undefined;
+      readonly creationDate?: string | undefined | undefined;
+      readonly url?: string | undefined | undefined;
+      readonly sizeIsDeferred?: boolean | undefined | undefined;
+      readonly checksum?: string | undefined | undefined;
+      readonly checksumAlgorithm?: string | undefined | undefined;
+    } | null;
+  }>>;
+  upload: (file: UploadInput) => void;
+  abort: () => void;
+  reset: () => void;
+  retry: () => void;
+  isUploading: vue1.ComputedRef<boolean>;
+  canRetry: vue1.ComputedRef<boolean>;
+  metrics: UploadMetrics;
+};
+//#endregion
+//#region src/composables/useMultiUpload.d.ts
+interface UploadItem {
+  id: string;
+  file: UploadInput;
+  state: UploadState;
+}
+interface MultiUploadOptions extends Omit<UploadOptions, "onSuccess" | "onError" | "onProgress"> {
+  /**
+   * Maximum number of concurrent uploads
+   */
+  maxConcurrent?: number;
+  /**
+   * Called when an individual file upload starts
+   */
+  onUploadStart?: (item: UploadItem) => void;
+  /**
+   * Called when an individual file upload progresses
+   */
+  onUploadProgress?: (item: UploadItem, progress: number, bytesUploaded: number, totalBytes: number | null) => void;
+  /**
+   * Called when an individual file upload succeeds
+   */
+  onUploadSuccess?: (item: UploadItem, result: UploadFile) => void;
+  /**
+   * Called when an individual file upload fails
+   */
+  onUploadError?: (item: UploadItem, error: Error) => void;
+  /**
+   * Called when all uploads complete (successfully or with errors)
+   */
+  onComplete?: (results: {
+    successful: UploadItem[];
+    failed: UploadItem[];
+    total: number;
+  }) => void;
+}
+interface MultiUploadState {
+  /**
+   * Total number of uploads
+   */
+  total: number;
+  /**
+   * Number of completed uploads (successful + failed)
+   */
+  completed: number;
+  /**
+   * Number of successful uploads
+   */
+  successful: number;
+  /**
+   * Number of failed uploads
+   */
+  failed: number;
+  /**
+   * Number of currently uploading files
+   */
+  uploading: number;
+  /**
+   * Overall progress as a percentage (0-100)
+   */
+  progress: number;
+  /**
+   * Total bytes uploaded across all files
+   */
+  totalBytesUploaded: number;
+  /**
+   * Total bytes to upload across all files
+   */
+  totalBytes: number;
+  /**
+   * Whether any uploads are currently active
+   */
+  isUploading: boolean;
+  /**
+   * Whether all uploads have completed
+   */
+  isComplete: boolean;
+}
+/**
+ * Vue composable for managing multiple file uploads with queue management,
+ * concurrent upload limits, and batch operations.
+ *
+ * Must be used within a component tree that has the Uploadista plugin installed.
+ *
+ * @param options - Multi-upload configuration and event handlers
+ * @returns Multi-upload state and control methods
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useMultiUpload } from '@uploadista/vue';
+ *
+ * const multiUpload = useMultiUpload({
+ *   maxConcurrent: 3,
+ *   onUploadSuccess: (item, result) => {
+ *     console.log(`${item.file.name} uploaded successfully`);
+ *   },
+ *   onComplete: (results) => {
+ *     console.log(`Upload batch complete: ${results.successful.length}/${results.total} successful`);
+ *   },
+ * });
+ *
+ * const handleFileChange = (event: Event) => {
+ *   const files = (event.target as HTMLInputElement).files;
+ *   if (files) {
+ *     multiUpload.addFiles(Array.from(files));
+ *   }
+ * };
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <input type="file" multiple @change="handleFileChange" />
+ *
+ *     <div>Progress: {{ multiUpload.state.progress }}%</div>
+ *     <div>
+ *       {{ multiUpload.state.uploading }} uploading,
+ *       {{ multiUpload.state.successful }} successful,
+ *       {{ multiUpload.state.failed }} failed
+ *     </div>
+ *
+ *     <button @click="multiUpload.startAll" :disabled="multiUpload.state.isUploading">
+ *       Start All
+ *     </button>
+ *     <button @click="multiUpload.abortAll" :disabled="!multiUpload.state.isUploading">
+ *       Abort All
+ *     </button>
+ *     <button @click="multiUpload.retryFailed" :disabled="multiUpload.state.failed === 0">
+ *       Retry Failed
+ *     </button>
+ *
+ *     <div v-for="item in multiUpload.items" :key="item.id">
+ *       {{ item.file.name }}: {{ item.state.status }} ({{ item.state.progress }}%)
+ *     </div>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useMultiUpload(options?: MultiUploadOptions): {
+  state: Readonly<vue1.Ref<{
+    readonly total: number;
+    readonly completed: number;
+    readonly successful: number;
+    readonly failed: number;
+    readonly uploading: number;
+    readonly progress: number;
+    readonly totalBytesUploaded: number;
+    readonly totalBytes: number;
+    readonly isUploading: boolean;
+    readonly isComplete: boolean;
+  }, {
+    readonly total: number;
+    readonly completed: number;
+    readonly successful: number;
+    readonly failed: number;
+    readonly uploading: number;
+    readonly progress: number;
+    readonly totalBytesUploaded: number;
+    readonly totalBytes: number;
+    readonly isUploading: boolean;
+    readonly isComplete: boolean;
+  }>>;
+  items: Readonly<vue1.Ref<readonly {
+    readonly id: string;
+    readonly file: {
+      readonly lastModified: number;
+      readonly name: string;
+      readonly webkitRelativePath: string;
+      readonly size: number;
+      readonly type: string;
+      readonly arrayBuffer: () => Promise<ArrayBuffer>;
+      readonly bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+      readonly slice: (start?: number, end?: number, contentType?: string) => Blob;
+      readonly stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+      readonly text: () => Promise<string>;
+    } | {
+      readonly size: number;
+      readonly type: string;
+      readonly arrayBuffer: () => Promise<ArrayBuffer>;
+      readonly bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+      readonly slice: (start?: number, end?: number, contentType?: string) => Blob;
+      readonly stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+      readonly text: () => Promise<string>;
+    };
+    readonly state: {
+      readonly status: UploadStatus;
+      readonly progress: number;
+      readonly bytesUploaded: number;
+      readonly totalBytes: number | null;
+      readonly error: Error | null;
+      readonly result: {
+        readonly id: string;
+        readonly offset: number;
+        readonly storage: {
+          readonly id: string;
+          readonly type: string;
+          readonly path?: string | undefined | undefined;
+          readonly uploadId?: string | undefined | undefined;
+          readonly bucket?: string | undefined | undefined;
+        };
+        readonly flow?: {
+          readonly flowId: string;
+          readonly nodeId: string;
+          readonly jobId: string;
+        } | undefined;
+        readonly size?: number | undefined | undefined;
+        readonly metadata?: {
+          readonly [x: string]: string | number | boolean;
+        } | undefined;
+        readonly creationDate?: string | undefined | undefined;
+        readonly url?: string | undefined | undefined;
+        readonly sizeIsDeferred?: boolean | undefined | undefined;
+        readonly checksum?: string | undefined | undefined;
+        readonly checksumAlgorithm?: string | undefined | undefined;
+      } | null;
+    };
+  }[], readonly {
+    readonly id: string;
+    readonly file: {
+      readonly lastModified: number;
+      readonly name: string;
+      readonly webkitRelativePath: string;
+      readonly size: number;
+      readonly type: string;
+      readonly arrayBuffer: () => Promise<ArrayBuffer>;
+      readonly bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+      readonly slice: (start?: number, end?: number, contentType?: string) => Blob;
+      readonly stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+      readonly text: () => Promise<string>;
+    } | {
+      readonly size: number;
+      readonly type: string;
+      readonly arrayBuffer: () => Promise<ArrayBuffer>;
+      readonly bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+      readonly slice: (start?: number, end?: number, contentType?: string) => Blob;
+      readonly stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+      readonly text: () => Promise<string>;
+    };
+    readonly state: {
+      readonly status: UploadStatus;
+      readonly progress: number;
+      readonly bytesUploaded: number;
+      readonly totalBytes: number | null;
+      readonly error: Error | null;
+      readonly result: {
+        readonly id: string;
+        readonly offset: number;
+        readonly storage: {
+          readonly id: string;
+          readonly type: string;
+          readonly path?: string | undefined | undefined;
+          readonly uploadId?: string | undefined | undefined;
+          readonly bucket?: string | undefined | undefined;
+        };
+        readonly flow?: {
+          readonly flowId: string;
+          readonly nodeId: string;
+          readonly jobId: string;
+        } | undefined;
+        readonly size?: number | undefined | undefined;
+        readonly metadata?: {
+          readonly [x: string]: string | number | boolean;
+        } | undefined;
+        readonly creationDate?: string | undefined | undefined;
+        readonly url?: string | undefined | undefined;
+        readonly sizeIsDeferred?: boolean | undefined | undefined;
+        readonly checksum?: string | undefined | undefined;
+        readonly checksumAlgorithm?: string | undefined | undefined;
+      } | null;
+    };
+  }[]>>;
+  addFiles: (files: UploadInput[]) => void;
+  removeItem: (id: string) => void;
+  removeFile: (id: string) => void;
+  startAll: () => void;
+  abortUpload: (id: string) => void;
+  abortAll: () => void;
+  retryUpload: (id: string) => void;
+  retryFailed: () => void;
+  clearCompleted: () => void;
+  clearAll: () => void;
+  getItemsByStatus: (status: UploadStatus) => {
+    id: string;
+    file: {
+      readonly lastModified: number;
+      readonly name: string;
+      readonly webkitRelativePath: string;
+      readonly size: number;
+      readonly type: string;
+      arrayBuffer: () => Promise<ArrayBuffer>;
+      bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+      slice: (start?: number, end?: number, contentType?: string) => Blob;
+      stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+      text: () => Promise<string>;
+    } | {
+      readonly size: number;
+      readonly type: string;
+      arrayBuffer: () => Promise<ArrayBuffer>;
+      bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+      slice: (start?: number, end?: number, contentType?: string) => Blob;
+      stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+      text: () => Promise<string>;
+    };
+    state: {
+      status: UploadStatus;
+      progress: number;
+      bytesUploaded: number;
+      totalBytes: number | null;
+      error: Error | null;
+      result: {
+        id: string;
+        offset: number;
+        storage: {
+          id: string;
+          type: string;
+          path?: string | undefined | undefined;
+          uploadId?: string | undefined | undefined;
+          bucket?: string | undefined | undefined;
+        };
+        flow?: {
+          flowId: string;
+          nodeId: string;
+          jobId: string;
+        } | undefined;
+        size?: number | undefined | undefined;
+        metadata?: Record<string, string | number | boolean> | undefined;
+        creationDate?: string | undefined | undefined;
+        url?: string | undefined | undefined;
+        sizeIsDeferred?: boolean | undefined | undefined;
+        checksum?: string | undefined | undefined;
+        checksumAlgorithm?: string | undefined | undefined;
+      } | null;
+    };
+  }[];
+  metrics: UploadMetrics;
+};
+//#endregion
+//#region src/composables/useUploadistaClient.d.ts
+/**
+ * Access the Uploadista client instance from the plugin or provider.
+ * Must be used within a component tree that has the Uploadista plugin or provider installed.
+ *
+ * @returns Uploadista client instance with event subscription
+ * @throws Error if used outside of Uploadista plugin/provider context
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useUploadistaClient } from '@uploadista/vue';
+ *
+ * const { client, subscribeToEvents } = useUploadistaClient();
+ *
+ * // Subscribe to all events
+ * const unsubscribe = subscribeToEvents((event) => {
+ *   console.log('Upload event:', event);
+ * });
+ *
+ * // Clean up on unmount
+ * onUnmounted(() => {
+ *   unsubscribe();
+ * });
+ * </script>
+ * ```
+ */
+declare function useUploadistaClient(): {
+  client: {
+    upload: (file: _uploadista_client_browser0.BrowserUploadInput, {
+      uploadLengthDeferred,
+      uploadSize,
+      onProgress,
+      onChunkComplete,
+      onSuccess,
+      onShouldRetry,
+      onError
+    }?: _uploadista_client_core0.UploadistaUploadOptions) => Promise<{
+      abort: () => void;
+    }>;
+    uploadWithFlow: (file: _uploadista_client_browser0.BrowserUploadInput, flowConfig: _uploadista_client_core0.FlowUploadConfig, {
+      onProgress,
+      onChunkComplete,
+      onSuccess,
+      onShouldRetry,
+      onJobStart,
+      onError
+    }?: Omit<_uploadista_client_core0.UploadistaUploadOptions, "uploadLengthDeferred" | "uploadSize" | "metadata">) => Promise<{
+      abort: () => void;
+      jobId: string;
+    }>;
+    abort: (params: Parameters<({
+      uploadId,
+      uploadIdStorageKey,
+      retryTimeout,
+      shouldTerminate,
+      abortController,
+      uploadistaApi,
+      platformService,
+      retryDelays,
+      clientStorage
+    }: {
+      uploadId: string;
+      uploadIdStorageKey: string | undefined;
+      retryTimeout: _uploadista_client_core0.Timeout | null;
+      shouldTerminate: boolean;
+      abortController: _uploadista_client_core0.AbortControllerLike;
+      uploadistaApi: _uploadista_client_core0.UploadistaApi;
+      platformService: _uploadista_client_core0.PlatformService;
+      retryDelays?: number[];
+      clientStorage: _uploadista_client_core0.ClientStorage;
+    }) => Promise<void>>[0]) => Promise<void>;
+    getFlow: (flowId: string) => Promise<{
+      status: number;
+      flow: _uploadista_core0.FlowData;
+    }>;
+    runFlow: ({
+      flowId,
+      inputs,
+      storageId: flowStorageId
+    }: {
+      flowId: string;
+      inputs: Record<string, unknown>;
+      storageId?: string;
+    }) => Promise<{
+      status: number;
+      job: _uploadista_core0.FlowJob;
+    }>;
+    continueFlow: ({
+      jobId,
+      nodeId,
+      newData,
+      contentType
+    }: {
+      jobId: string;
+      nodeId: string;
+      newData: unknown;
+      contentType?: "application/json" | "application/octet-stream";
+    }) => Promise<_uploadista_core0.FlowJob>;
+    getJobStatus: (jobId: string) => Promise<_uploadista_core0.FlowJob>;
+    openUploadWebSocket: (uploadId: string) => Promise<_uploadista_client_core0.WebSocketLike>;
+    openFlowWebSocket: (jobId: string) => Promise<_uploadista_client_core0.WebSocketLike>;
+    openWebSocket: (id: string) => Promise<_uploadista_client_core0.WebSocketLike>;
+    closeWebSocket: (id: string) => void;
+    closeAllWebSockets: () => void;
+    sendPing: (jobId: string) => boolean;
+    isWebSocketConnected: (id: string) => boolean;
+    getWebSocketConnectionCount: () => number;
+    getWebSocketConnectionCountByType: () => {
+      upload: number;
+      flow: number;
+      total: number;
+    };
+    getNetworkMetrics: () => _uploadista_client_core0.NetworkMetrics;
+    getNetworkCondition: () => _uploadista_client_core0.NetworkCondition;
+    getChunkingInsights: () => _uploadista_client_core0.PerformanceInsights;
+    exportMetrics: () => {
+      session: Partial<_uploadista_client_core0.UploadSessionMetrics>;
+      chunks: _uploadista_client_core0.ChunkMetrics[];
+      insights: _uploadista_client_core0.PerformanceInsights;
+    };
+    getConnectionMetrics: () => _uploadista_client_core0.ConnectionMetrics;
+    getDetailedConnectionMetrics: () => _uploadista_client_core0.DetailedConnectionMetrics;
+    warmupConnections: (urls: string[]) => Promise<void>;
+    getConnectionPoolingInsights: () => Promise<{
+      isOptimized: boolean;
+      reuseRate: number;
+      recommendedMinChunkSize: number;
+      connectionOverhead: number;
+    }>;
+    resetMetrics: () => Promise<void>;
+    validateConfiguration: (options: _uploadista_client_core0.UploadistaClientOptions<_uploadista_client_browser0.BrowserUploadInput>) => {
+      valid: boolean;
+      errors: string[];
+      warnings: string[];
+    };
+    validateConfigurationAsync: (options: _uploadista_client_core0.UploadistaClientOptions<_uploadista_client_browser0.BrowserUploadInput>) => Promise<{
+      valid: boolean;
+      errors: string[];
+      warnings: string[];
+      capabilities: _uploadista_core0.DataStoreCapabilities;
+    }>;
+    getCapabilities: () => Promise<_uploadista_core0.DataStoreCapabilities>;
+  };
+  subscribeToEvents: (handler: (event: UploadistaEvent) => void) => () => void;
+};
+type UseUploadistaClientReturn = ReturnType<typeof useUploadistaClient>;
+//#endregion
+//#region src/composables/useUploadMetrics.d.ts
+type ChunkMetrics$1 = any;
+type PerformanceInsights$1 = any;
+type UploadSessionMetrics$1 = any;
+interface UploadMetrics$1 {
+  /**
+   * Total bytes uploaded across all files
+   */
+  totalBytesUploaded: number;
+  /**
+   * Total bytes to upload across all files
+   */
+  totalBytes: number;
+  /**
+   * Overall upload speed in bytes per second
+   */
+  averageSpeed: number;
+  /**
+   * Current upload speed in bytes per second
+   */
+  currentSpeed: number;
+  /**
+   * Estimated time remaining in milliseconds
+   */
+  estimatedTimeRemaining: number | null;
+  /**
+   * Total number of files being tracked
+   */
+  totalFiles: number;
+  /**
+   * Number of files completed
+   */
+  completedFiles: number;
+  /**
+   * Number of files currently uploading
+   */
+  activeUploads: number;
+  /**
+   * Overall progress as percentage (0-100)
+   */
+  progress: number;
+  /**
+   * Peak upload speed achieved
+   */
+  peakSpeed: number;
+  /**
+   * Start time of the first upload
+   */
+  startTime: number | null;
+  /**
+   * End time of the last completed upload
+   */
+  endTime: number | null;
+  /**
+   * Total duration of all uploads
+   */
+  totalDuration: number | null;
+  /**
+   * Detailed performance insights from the upload client
+   */
+  insights: PerformanceInsights$1;
+  /**
+   * Session metrics for completed uploads
+   */
+  sessionMetrics: Partial<UploadSessionMetrics$1>[];
+  /**
+   * Detailed chunk metrics from recent uploads
+   */
+  chunkMetrics: ChunkMetrics$1[];
+}
+interface FileUploadMetrics {
+  id: string;
+  filename: string;
+  size: number;
+  bytesUploaded: number;
+  progress: number;
+  speed: number;
+  startTime: number;
+  endTime: number | null;
+  duration: number | null;
+  isComplete: boolean;
+}
+interface UseUploadMetricsOptions {
+  /**
+   * Interval for calculating current speed (in milliseconds)
+   */
+  speedCalculationInterval?: number;
+  /**
+   * Number of speed samples to keep for average calculation
+   */
+  speedSampleSize?: number;
+  /**
+   * Called when metrics are updated
+   */
+  onMetricsUpdate?: (metrics: UploadMetrics$1) => void;
+  /**
+   * Called when a file upload starts
+   */
+  onFileStart?: (fileMetrics: FileUploadMetrics) => void;
+  /**
+   * Called when a file upload progresses
+   */
+  onFileProgress?: (fileMetrics: FileUploadMetrics) => void;
+  /**
+   * Called when a file upload completes
+   */
+  onFileComplete?: (fileMetrics: FileUploadMetrics) => void;
+}
+/**
+ * Vue composable for tracking detailed upload metrics and performance statistics.
+ * Provides comprehensive monitoring of upload progress, speed, and timing data.
+ *
+ * @param options - Configuration and event handlers
+ * @returns Upload metrics state and control methods
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useUploadMetrics } from '@uploadista/vue';
+ *
+ * const uploadMetrics = useUploadMetrics({
+ *   speedCalculationInterval: 1000, // Update speed every second
+ *   speedSampleSize: 10, // Keep last 10 speed samples for average
+ *   onMetricsUpdate: (metrics) => {
+ *     console.log(`Overall progress: ${metrics.progress}%`);
+ *     console.log(`Speed: ${(metrics.currentSpeed / 1024).toFixed(1)} KB/s`);
+ *     console.log(`ETA: ${metrics.estimatedTimeRemaining}ms`);
+ *   },
+ *   onFileComplete: (fileMetrics) => {
+ *     console.log(`${fileMetrics.filename} completed in ${fileMetrics.duration}ms`);
+ *   },
+ * });
+ *
+ * // Start tracking a file
+ * const handleFileStart = (file: File) => {
+ *   uploadMetrics.startFileUpload(file.name, file.name, file.size);
+ * };
+ *
+ * // Update progress during upload
+ * const handleProgress = (fileId: string, bytesUploaded: number) => {
+ *   uploadMetrics.updateFileProgress(fileId, bytesUploaded);
+ * };
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <div>Overall Progress: {{ uploadMetrics.metrics.progress }}%</div>
+ *     <div>Speed: {{ (uploadMetrics.metrics.currentSpeed / 1024).toFixed(1) }} KB/s</div>
+ *     <div>Files: {{ uploadMetrics.metrics.completedFiles }}/{{ uploadMetrics.metrics.totalFiles }}</div>
+ *
+ *     <div v-if="uploadMetrics.metrics.estimatedTimeRemaining">
+ *       ETA: {{ Math.round(uploadMetrics.metrics.estimatedTimeRemaining / 1000) }}s
+ *     </div>
+ *
+ *     <div v-for="file in uploadMetrics.fileMetrics" :key="file.id">
+ *       {{ file.filename }}: {{ file.progress }}% ({{ (file.speed / 1024).toFixed(1) }} KB/s)
+ *     </div>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useUploadMetrics(options?: UseUploadMetricsOptions): {
+  metrics: Readonly<vue1.Ref<{
+    readonly totalBytesUploaded: number;
+    readonly totalBytes: number;
+    readonly averageSpeed: number;
+    readonly currentSpeed: number;
+    readonly estimatedTimeRemaining: number | null;
+    readonly totalFiles: number;
+    readonly completedFiles: number;
+    readonly activeUploads: number;
+    readonly progress: number;
+    readonly peakSpeed: number;
+    readonly startTime: number | null;
+    readonly endTime: number | null;
+    readonly totalDuration: number | null;
+    readonly insights: PerformanceInsights$1;
+    readonly sessionMetrics: readonly {
+      readonly [x: string]: any;
+    }[];
+    readonly chunkMetrics: readonly any[];
+  }, {
+    readonly totalBytesUploaded: number;
+    readonly totalBytes: number;
+    readonly averageSpeed: number;
+    readonly currentSpeed: number;
+    readonly estimatedTimeRemaining: number | null;
+    readonly totalFiles: number;
+    readonly completedFiles: number;
+    readonly activeUploads: number;
+    readonly progress: number;
+    readonly peakSpeed: number;
+    readonly startTime: number | null;
+    readonly endTime: number | null;
+    readonly totalDuration: number | null;
+    readonly insights: PerformanceInsights$1;
+    readonly sessionMetrics: readonly {
+      readonly [x: string]: any;
+    }[];
+    readonly chunkMetrics: readonly any[];
+  }>>;
+  fileMetrics: Readonly<vue1.Ref<readonly {
+    readonly id: string;
+    readonly filename: string;
+    readonly size: number;
+    readonly bytesUploaded: number;
+    readonly progress: number;
+    readonly speed: number;
+    readonly startTime: number;
+    readonly endTime: number | null;
+    readonly duration: number | null;
+    readonly isComplete: boolean;
+  }[], readonly {
+    readonly id: string;
+    readonly filename: string;
+    readonly size: number;
+    readonly bytesUploaded: number;
+    readonly progress: number;
+    readonly speed: number;
+    readonly startTime: number;
+    readonly endTime: number | null;
+    readonly duration: number | null;
+    readonly isComplete: boolean;
+  }[]>>;
+  startFileUpload: (id: string, filename: string, size: number) => void;
+  updateFileProgress: (id: string, bytesUploaded: number) => void;
+  completeFileUpload: (id: string) => void;
+  removeFile: (id: string) => void;
+  reset: () => void;
+  getFileMetrics: (id: string) => {
+    id: string;
+    filename: string;
+    size: number;
+    bytesUploaded: number;
+    progress: number;
+    speed: number;
+    startTime: number;
+    endTime: number | null;
+    duration: number | null;
+    isComplete: boolean;
+  } | undefined;
+  exportMetrics: () => {
+    overall: {
+      totalBytesUploaded: number;
+      totalBytes: number;
+      averageSpeed: number;
+      currentSpeed: number;
+      estimatedTimeRemaining: number | null;
+      totalFiles: number;
+      completedFiles: number;
+      activeUploads: number;
+      progress: number;
+      peakSpeed: number;
+      startTime: number | null;
+      endTime: number | null;
+      totalDuration: number | null;
+      insights: PerformanceInsights$1;
+      sessionMetrics: Partial<UploadSessionMetrics$1>[];
+      chunkMetrics: ChunkMetrics$1[];
+    };
+    files: {
+      id: string;
+      filename: string;
+      size: number;
+      bytesUploaded: number;
+      progress: number;
+      speed: number;
+      startTime: number;
+      endTime: number | null;
+      duration: number | null;
+      isComplete: boolean;
+    }[];
+    exportTime: number;
+  };
+};
+//#endregion
+export { DragDropState as C, UploadistaPluginOptions as D, UPLOADISTA_EVENT_SUBSCRIBERS_KEY as E, createUploadistaPlugin as O, DragDropOptions as S, UPLOADISTA_CLIENT_KEY as T, useUpload as _, useUploadistaClient as a, FlowUploadStatus as b, UploadItem as c, PerformanceInsights as d, UploadInput as f, UploadStatus as g, UploadState as h, UseUploadistaClientReturn as i, useMultiUpload as l, UploadSessionMetrics as m, UseUploadMetricsOptions as n, MultiUploadOptions as o, UploadMetrics as p, useUploadMetrics as r, MultiUploadState as s, FileUploadMetrics as t, ChunkMetrics as u, useMultiFlowUpload as v, useDragDrop as w, useFlowUpload as x, FlowUploadState as y };
+//# sourceMappingURL=index-DgHJHePD.d.mts.map