@uploadista/react-native-core 0.0.3 → 0.0.4

package/dist/index.d.ts

@@ -0,0 +1,949 @@
+import * as react0 from "react";
+import { ReactNode } from "react";
+import { UploadFile } from "@uploadista/core/types";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as _uploadista_client_core0 from "@uploadista/client-core";
+import { Base64Service, ConnectionMetrics, ConnectionPoolConfig, ConnectionPoolConfig as ConnectionPoolConfig$1, DetailedConnectionMetrics, FileReaderService, HttpClient, IdGenerationService, ServiceContainer, ServiceContainer as ServiceContainer$1, StorageService, UploadistaClientOptions, UploadistaEvent } from "@uploadista/client-core";
+import * as _uploadista_core0 from "@uploadista/core";
+
+//#region src/types/types.d.ts
+/**
+ * Core types for React Native Uploadista client
+ */
+/**
+ * Options for file picker operations
+ */
+interface PickerOptions {
+  /** Allowed file types/MIME types */
+  allowedTypes?: string[];
+  /** Allow multiple selection */
+  allowMultiple?: boolean;
+  /** Maximum file size in bytes */
+  maxSize?: number;
+}
+/**
+ * Options for camera operations
+ */
+interface CameraOptions {
+  /** Camera to use: 'front' or 'back' */
+  cameraType?: "front" | "back";
+  /** Image quality (0-1) */
+  quality?: number;
+  /** Maximum width for captured image */
+  maxWidth?: number;
+  /** Maximum height for captured image */
+  maxHeight?: number;
+}
+/**
+ * Result from a file pick operation
+ */
+interface FilePickResult {
+  /** URI to the file (platform-specific format) */
+  uri: string;
+  /** File name with extension */
+  name: string;
+  /** File size in bytes */
+  size: number;
+  /** MIME type of the file (if available) */
+  mimeType?: string;
+  /** Local file path (if available) */
+  localPath?: string;
+}
+/**
+ * Information about a file
+ */
+interface FileInfo {
+  /** URI to the file */
+  uri: string;
+  /** File name */
+  name: string;
+  /** File size in bytes */
+  size: number;
+  /** MIME type (if available) */
+  mimeType?: string;
+  /** Last modified timestamp */
+  modificationTime?: number;
+}
+/**
+ * Interface for file system abstraction layer
+ * Provides pluggable access to file system APIs across different RN environments
+ */
+interface FileSystemProvider {
+  /**
+   * Opens a document picker for selecting files
+   * @param options - Configuration for the picker
+   * @returns Promise resolving to picked file information
+   */
+  pickDocument(options?: PickerOptions): Promise<FilePickResult>;
+  /**
+   * Opens an image picker for selecting images from gallery
+   * @param options - Configuration for the picker
+   * @returns Promise resolving to picked image information
+   */
+  pickImage(options?: PickerOptions): Promise<FilePickResult>;
+  /**
+   * Opens a video picker for selecting videos from gallery
+   * @param options - Configuration for the picker
+   * @returns Promise resolving to picked video information
+   */
+  pickVideo(options?: PickerOptions): Promise<FilePickResult>;
+  /**
+   * Captures a photo using the device camera
+   * @param options - Configuration for camera
+   * @returns Promise resolving to captured photo information
+   */
+  pickCamera(options?: CameraOptions): Promise<FilePickResult>;
+  /**
+   * Gets a URI for a document that can be read
+   * @param filePath - Path to the document
+   * @returns Promise resolving to accessible URI
+   */
+  getDocumentUri(filePath: string): Promise<string>;
+  /**
+   * Reads file contents as ArrayBuffer
+   * @param uri - URI to read from
+   * @returns Promise resolving to file contents as ArrayBuffer
+   */
+  readFile(uri: string): Promise<ArrayBuffer>;
+  /**
+   * Gets information about a file
+   * @param uri - URI of the file
+   * @returns Promise resolving to file information
+   */
+  getFileInfo(uri: string): Promise<FileInfo>;
+}
+/**
+ * Configuration for file system provider
+ */
+interface FileSystemProviderConfig {
+  /** Type of provider: 'expo' or 'native' */
+  type?: "expo" | "native";
+  /** Custom provider instance */
+  provider?: FileSystemProvider;
+}
+/**
+ * Upload state
+ */
+type UploadState$1 = "idle" | "pending" | "uploading" | "success" | "error" | "cancelled";
+/**
+ * Upload progress information
+ */
+interface UploadProgress$1 {
+  /** Current state of upload */
+  state: UploadState$1;
+  /** Progress percentage (0-100) */
+  progress: number;
+  /** Bytes uploaded */
+  uploadedBytes: number;
+  /** Total bytes to upload */
+  totalBytes: number;
+  /** Upload speed in bytes per second */
+  uploadSpeed?: number;
+  /** Estimated time remaining in milliseconds */
+  timeRemaining?: number;
+  /** Error message if state is 'error' */
+  error?: Error;
+}
+/**
+ * Multi-file upload item
+ */
+interface UploadItem {
+  /** Unique identifier for this upload */
+  id: string;
+  /** File information */
+  file: FilePickResult;
+  /** Upload progress */
+  progress: UploadProgress$1;
+  /** Result from server if successful */
+  result?: unknown;
+}
+/**
+ * Options for multi-upload hook
+ */
+interface UseMultiUploadOptions {
+  /** Max concurrent uploads */
+  maxConcurrent?: number;
+  /** Additional form data for all uploads */
+  metadata?: Record<string, string>;
+  /** Called when a file upload succeeds */
+  onSuccess?: (result: unknown) => void;
+  /** Called when a file upload fails */
+  onError?: (error: Error) => void;
+}
+/**
+ * Options for flow upload hook
+ */
+interface UseFlowUploadOptions {
+  /** Flow ID to execute */
+  flowId: string;
+  /** Storage ID for the upload */
+  storageId: string;
+  /** Output node ID for the flow */
+  outputNodeId?: string;
+  /** Metadata to pass to flow */
+  metadata?: Record<string, unknown>;
+  /** Called when upload succeeds */
+  onSuccess?: (result: unknown) => void;
+  /** Called when upload fails */
+  onError?: (error: Error) => void;
+  /** 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;
+}
+/**
+ * Options for camera upload hook
+ */
+interface UseCameraUploadOptions {
+  /** Flow ID to use */
+  flowId?: string;
+  /** Camera options */
+  cameraOptions?: CameraOptions;
+  /** Additional metadata */
+  metadata?: Record<string, string>;
+  /** Called when upload succeeds */
+  onSuccess?: (result: unknown) => void;
+  /** Called when upload fails */
+  onError?: (error: Error) => void;
+  /** Called when upload progress updates */
+  onProgress?: (progress: number, bytesUploaded: number, totalBytes: number | null) => void;
+}
+/**
+ * Options for gallery upload hook
+ */
+interface UseGalleryUploadOptions {
+  /** Flow ID to use */
+  flowId?: string;
+  /** Allow multiple selection */
+  allowMultiple?: boolean;
+  /** Media type: 'photo', 'video', or 'mixed' */
+  mediaType?: "photo" | "video" | "mixed";
+  /** Additional metadata */
+  metadata?: Record<string, string>;
+  /** Called when upload succeeds */
+  onSuccess?: (result: unknown) => void;
+  /** Called when upload fails */
+  onError?: (error: Error) => void;
+  /** Called when upload progress updates */
+  onProgress?: (progress: number, bytesUploaded: number, totalBytes: number | null) => void;
+}
+/**
+ * Options for file upload hook
+ */
+interface UseFileUploadOptions {
+  /** Flow ID to use */
+  flowId?: string;
+  /** Allowed file types */
+  allowedTypes?: string[];
+  /** Additional metadata */
+  metadata?: Record<string, string>;
+  /** Called when upload succeeds */
+  onSuccess?: (result: unknown) => void;
+  /** Called when upload fails */
+  onError?: (error: Error) => void;
+  /** Called when upload progress updates */
+  onProgress?: (progress: number, bytesUploaded: number, totalBytes: number | null) => void;
+}
+/**
+ * Metrics for upload performance
+ */
+interface UploadMetrics {
+  /** Total bytes uploaded */
+  totalBytes: number;
+  /** Total upload duration in milliseconds */
+  durationMs: number;
+  /** Average upload speed in bytes/second */
+  avgSpeed: number;
+  /** Peak upload speed in bytes/second */
+  peakSpeed: number;
+  /** Number of retries */
+  retries: number;
+}
+//#endregion
+//#region src/types/upload-input.d.ts
+type ReactNativeUploadInput = Blob | File | string | {
+  uri: string;
+};
+//#endregion
+//#region src/components/CameraUploadButton.d.ts
+interface CameraUploadButtonProps {
+  /** Options for camera upload */
+  options?: UseCameraUploadOptions;
+  /** Button label text */
+  label?: string;
+  /** Custom button content */
+  children?: ReactNode;
+  /** Callback when upload completes successfully */
+  onSuccess?: (result: unknown) => void;
+  /** Callback when upload fails */
+  onError?: (error: Error) => void;
+  /** Callback when upload is cancelled */
+  onCancel?: () => void;
+  /** Whether to show progress inline */
+  showProgress?: boolean;
+}
+/**
+ * Button component for camera capture and upload
+ * Triggers camera on press and handles upload with progress display
+ */
+declare function CameraUploadButton({
+  options,
+  label,
+  children,
+  onSuccess,
+  onError,
+  onCancel,
+  showProgress
+}: CameraUploadButtonProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/FileUploadButton.d.ts
+interface FileUploadButtonProps {
+  /** Options for file upload */
+  options?: UseFileUploadOptions;
+  /** Button label text */
+  label?: string;
+  /** Custom button content */
+  children?: ReactNode;
+  /** Callback when upload completes successfully */
+  onSuccess?: (result: unknown) => void;
+  /** Callback when upload fails */
+  onError?: (error: Error) => void;
+  /** Callback when upload is cancelled */
+  onCancel?: () => void;
+  /** Whether to show progress inline */
+  showProgress?: boolean;
+}
+/**
+ * Button component for document/file selection and upload
+ * Generic file picker with progress display
+ */
+declare function FileUploadButton({
+  options,
+  label,
+  children,
+  onSuccess,
+  onError,
+  onCancel,
+  showProgress
+}: FileUploadButtonProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/GalleryUploadButton.d.ts
+interface GalleryUploadButtonProps {
+  /** Options for gallery upload */
+  options?: UseGalleryUploadOptions;
+  /** Button label text */
+  label?: string;
+  /** Custom button content */
+  children?: ReactNode;
+  /** Callback when all uploads complete successfully */
+  onSuccess?: (results: unknown[]) => void;
+  /** Callback when any upload fails */
+  onError?: (error: Error) => void;
+  /** Callback when upload is cancelled */
+  onCancel?: () => void;
+  /** Whether to show individual progress for each file */
+  showProgress?: boolean;
+}
+/**
+ * Button component for gallery selection and batch upload
+ * Triggers gallery picker on press and handles concurrent uploads
+ */
+declare function GalleryUploadButton({
+  options,
+  label,
+  children,
+  onSuccess,
+  onError,
+  onCancel,
+  showProgress
+}: GalleryUploadButtonProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/components/UploadList.d.ts
+interface UploadListProps {
+  /** List of upload items to display */
+  items: UploadItem[];
+  /** Callback when remove item is pressed */
+  onRemove?: (id: string) => void;
+  /** Callback when item is pressed */
+  onItemPress?: (item: UploadItem) => void;
+  /** Whether to show remove button */
+  showRemoveButton?: boolean;
+}
+/**
+ * Component to display a list of upload items with individual progress
+ * Shows status indicators and allows removal of items
+ */
+declare function UploadList({
+  items,
+  onRemove,
+  onItemPress,
+  showRemoveButton
+}: UploadListProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/hooks/use-upload.d.ts
+type UploadStatus = "idle" | "uploading" | "success" | "error" | "aborted";
+interface UploadState {
+  status: UploadStatus;
+  progress: number;
+  bytesUploaded: number;
+  totalBytes: number | null;
+  error: Error | null;
+  result: UploadFile | null;
+}
+//#endregion
+//#region src/components/UploadProgress.d.ts
+interface UploadProgressProps {
+  /**  Upload state information */
+  state: UploadState;
+  /** Optional custom label */
+  label?: string;
+}
+/**
+ * Component to display upload progress with percentage, size, and speed
+ */
+declare function UploadProgress({
+  state,
+  label
+}: UploadProgressProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/client/create-uploadista-client.d.ts
+interface UploadistaClientOptions$1 extends Omit<UploadistaClientOptions<ReactNativeUploadInput>, "webSocketFactory" | "abortControllerFactory" | "generateId" | "clientStorage" | "logger" | "httpClient" | "fileReader" | "base64"> {
+  connectionPooling?: ConnectionPoolConfig$1;
+  /**
+   * Whether to use AsyncStorage for persistence
+   * If false, uses in-memory storage
+   * @default true
+   */
+  useAsyncStorage?: boolean;
+}
+/**
+ * Creates an upload client instance with React Native-specific service implementations
+ *
+ * @param options - Client configuration options
+ * @returns Configured UploadistaClient instance
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaClient } from '@uploadista/react-native'
+ *
+ * const client = createUploadistaClient({
+ *   baseUrl: 'https://api.example.com',
+ *   storageId: 'my-storage',
+ *   chunkSize: 1024 * 1024, // 1MB
+ *   useAsyncStorage: true,
+ * });
+ * ```
+ */
+declare function createUploadistaClient(options: UploadistaClientOptions$1, services: ServiceContainer$1<ReactNativeUploadInput>): {
+  upload: (file: ReactNativeUploadInput, {
+    uploadLengthDeferred,
+    uploadSize,
+    onProgress,
+    onChunkComplete,
+    onSuccess,
+    onShouldRetry,
+    onError
+  }?: _uploadista_client_core0.UploadistaUploadOptions) => Promise<{
+    abort: () => void;
+  }>;
+  uploadWithFlow: (file: ReactNativeUploadInput, 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<typeof void 0>[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: UploadistaClientOptions<ReactNativeUploadInput>) => {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+  };
+  validateConfigurationAsync: (options: UploadistaClientOptions<ReactNativeUploadInput>) => Promise<{
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    capabilities: _uploadista_core0.DataStoreCapabilities;
+  }>;
+  getCapabilities: () => Promise<_uploadista_core0.DataStoreCapabilities>;
+};
+//#endregion
+//#region src/hooks/use-uploadista-client.d.ts
+interface UseUploadistaClientOptions extends UploadistaClientOptions$1 {
+  /**
+   * Global event handler for all upload and flow events from this client
+   */
+  onEvent?: UploadistaClientOptions$1["onEvent"];
+}
+interface UseUploadistaClientReturn {
+  /**
+   * The uploadista client instance
+   */
+  client: ReturnType<typeof createUploadistaClient>;
+  /**
+   * Current configuration of the client
+   */
+  config: UseUploadistaClientOptions;
+}
+//#endregion
+//#region src/hooks/uploadista-context.d.ts
+interface UploadistaContextType extends UseUploadistaClientReturn {
+  fileSystemProvider: FileSystemProvider;
+  /**
+   * Subscribe to events (used internally by hooks)
+   * @internal
+   */
+  subscribeToEvents: (handler: (event: UploadistaEvent) => void) => () => void;
+}
+declare const UploadistaContext: react0.Context<UploadistaContextType | undefined>;
+//#endregion
+//#region src/hooks/use-camera-upload.d.ts
+/**
+ * Hook for capturing photos and uploading them
+ * Handles camera permissions and capture flow
+ * @param options - Camera upload configuration
+ * @returns Upload state and camera capture/upload function
+ */
+declare function useCameraUpload(options?: UseCameraUploadOptions): {
+  captureAndUpload: () => Promise<void>;
+  state: UploadState;
+  upload: (file: FilePickResult) => Promise<void>;
+  abort: () => void;
+  reset: () => void;
+  retry: () => void;
+  isUploading: boolean;
+  canRetry: boolean;
+};
+//#endregion
+//#region src/hooks/use-file-upload.d.ts
+/**
+ * Hook for selecting and uploading generic files (documents, etc.)
+ * @param options - File upload configuration
+ * @returns Upload state and file picker/upload function
+ */
+declare function useFileUpload(options?: UseFileUploadOptions): {
+  pickAndUpload: () => Promise<void>;
+  state: UploadState;
+  upload: (file: FilePickResult) => Promise<void>;
+  abort: () => void;
+  reset: () => void;
+  retry: () => void;
+  isUploading: boolean;
+  canRetry: boolean;
+};
+//#endregion
+//#region src/hooks/use-flow-upload.d.ts
+type FlowUploadStatus = "idle" | "uploading" | "processing" | "success" | "error" | "aborted";
+interface FlowUploadState {
+  status: FlowUploadStatus;
+  progress: number;
+  bytesUploaded: number;
+  totalBytes: number | null;
+  jobId: string | null;
+  error: Error | null;
+  result: unknown | null;
+}
+/**
+ * Hook for uploading files through a flow pipeline with full state management.
+ * Provides upload progress tracking, flow execution monitoring, error handling, and abort functionality.
+ *
+ * Must be used within an UploadistaProvider.
+ *
+ * @param options - Flow upload configuration
+ * @returns Flow upload state and control methods
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const flowUpload = useFlowUpload({
+ *     flowId: 'image-processing-flow',
+ *     storageId: 'my-storage',
+ *     onSuccess: (result) => console.log('Flow complete:', result),
+ *     onError: (error) => console.error('Flow failed:', error),
+ *     onProgress: (progress) => console.log('Progress:', progress + '%'),
+ *   });
+ *
+ *   const handlePickFile = async () => {
+ *     const file = await fileSystemProvider.pickDocument();
+ *     if (file) {
+ *       await flowUpload.upload(file);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Button title="Pick File" onPress={handlePickFile} />
+ *       {flowUpload.isUploading && <Text>Progress: {flowUpload.state.progress}%</Text>}
+ *       {flowUpload.state.jobId && <Text>Job ID: {flowUpload.state.jobId}</Text>}
+ *       {flowUpload.state.error && <Text>Error: {flowUpload.state.error.message}</Text>}
+ *       <Button title="Abort" onPress={flowUpload.abort} disabled={!flowUpload.isActive} />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useFlowUpload(options: UseFlowUploadOptions): {
+  state: FlowUploadState;
+  upload: (file: FilePickResult) => Promise<void>;
+  abort: () => void;
+  reset: () => void;
+  retry: () => void;
+  isActive: boolean;
+  canRetry: boolean;
+};
+//#endregion
+//#region src/hooks/use-multi-upload.d.ts
+interface UploadItemState {
+  id: string;
+  file: FilePickResult;
+  status: "idle" | "uploading" | "success" | "error" | "aborted";
+  progress: number;
+  bytesUploaded: number;
+  totalBytes: number;
+  error: Error | null;
+  result: UploadFile | null;
+}
+interface MultiUploadState {
+  items: UploadItemState[];
+  totalProgress: number;
+  totalUploaded: number;
+  totalBytes: number;
+  activeCount: number;
+  completedCount: number;
+  failedCount: number;
+}
+/**
+ * Hook for managing multiple concurrent file uploads with progress tracking.
+ * Each file is uploaded independently using the core upload client.
+ *
+ * Must be used within an UploadistaProvider.
+ *
+ * @param options - Multi-upload configuration options
+ * @returns Multi-upload state and control methods
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const multiUpload = useMultiUpload({
+ *     maxConcurrent: 3,
+ *     onSuccess: (result) => console.log('File uploaded:', result),
+ *     onError: (error) => console.error('Upload failed:', error),
+ *   });
+ *
+ *   const handlePickFiles = async () => {
+ *     const files = await fileSystemProvider.pickImage({ allowMultiple: true });
+ *     multiUpload.addFiles(files);
+ *     await multiUpload.startUploads();
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Button title="Pick Files" onPress={handlePickFiles} />
+ *       <Text>Progress: {multiUpload.state.totalProgress}%</Text>
+ *       <Text>Active: {multiUpload.state.activeCount}</Text>
+ *       <Text>Completed: {multiUpload.state.completedCount}/{multiUpload.state.items.length}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useMultiUpload(options?: UseMultiUploadOptions): {
+  state: MultiUploadState;
+  addFiles: (files: FilePickResult[]) => string[];
+  startUploads: () => Promise<void>;
+  removeItem: (id: string) => void;
+  abortItem: (id: string) => void;
+  retryItem: (id: string) => Promise<void>;
+  clear: () => void;
+};
+//#endregion
+//#region src/hooks/use-gallery-upload.d.ts
+/**
+ * Hook for selecting and uploading photos/videos from gallery
+ * Handles batch selection and concurrent uploads
+ * @param options - Gallery upload configuration
+ * @returns Upload state and gallery selection/upload function
+ */
+declare function useGalleryUpload(options?: UseGalleryUploadOptions): {
+  selectAndUpload: () => Promise<string[]>;
+  state: MultiUploadState;
+  addFiles: (files: FilePickResult[]) => string[];
+  startUploads: () => Promise<void>;
+  removeItem: (id: string) => void;
+  abortItem: (id: string) => void;
+  retryItem: (id: string) => Promise<void>;
+  clear: () => void;
+};
+//#endregion
+//#region src/hooks/use-upload-metrics.d.ts
+/**
+ * Hook for tracking upload performance metrics
+ * @returns Metrics object and methods to track uploads
+ */
+declare function useUploadMetrics(): {
+  metrics: UploadMetrics;
+  start: () => void;
+  update: (uploadedBytes: number, _totalBytes: number, currentRetries?: number) => void;
+  end: () => UploadMetrics;
+  reset: () => void;
+};
+//#endregion
+//#region src/hooks/use-uploadista-context.d.ts
+/**
+ * Hook to access the Uploadista client instance
+ * Must be used within an UploadistaProvider
+ * @throws Error if used outside of UploadistaProvider
+ * @returns The Uploadista client and file system provider
+ */
+declare function useUploadistaContext(): UploadistaContextType;
+//#endregion
+//#region src/utils/fileHelpers.d.ts
+/**
+ * File utility functions for React Native uploads
+ */
+/**
+ * Format file size to human readable string
+ * @param bytes - Size in bytes
+ * @returns Formatted size string (e.g., "1.5 MB")
+ */
+declare function formatFileSize(bytes: number): string;
+/**
+ * Get MIME type from file name
+ * @param fileName - File name with extension
+ * @returns MIME type or 'application/octet-stream' as fallback
+ */
+declare function getMimeTypeFromFileName(fileName: string): string;
+/**
+ * Check if file type is allowed
+ * @param fileName - File name to check
+ * @param allowedTypes - Array of allowed MIME types (e.g., ['image/jpeg', 'image/png'])
+ * @returns True if file type is allowed
+ */
+declare function isFileTypeAllowed(fileName: string, allowedTypes: string[]): boolean;
+/**
+ * Check if file size is within limits
+ * @param fileSize - File size in bytes
+ * @param maxSize - Maximum allowed size in bytes (optional)
+ * @param minSize - Minimum allowed size in bytes (optional)
+ * @returns True if file size is within limits
+ */
+declare function isFileSizeValid(fileSize: number, maxSize?: number, minSize?: number): boolean;
+/**
+ * Get file extension
+ * @param fileName - File name
+ * @returns File extension without dot (e.g., 'pdf' for 'document.pdf')
+ */
+declare function getFileExtension(fileName: string): string;
+/**
+ * Get file name without extension
+ * @param fileName - File name
+ * @returns File name without extension
+ */
+declare function getFileNameWithoutExtension(fileName: string): string;
+/**
+ * Check if file is an image
+ * @param fileName - File name
+ * @returns True if file is an image
+ */
+declare function isImageFile(fileName: string): boolean;
+/**
+ * Check if file is a video
+ * @param fileName - File name
+ * @returns True if file is a video
+ */
+declare function isVideoFile(fileName: string): boolean;
+/**
+ * Check if file is a document
+ * @param fileName - File name
+ * @returns True if file is a document
+ */
+declare function isDocumentFile(fileName: string): boolean;
+//#endregion
+//#region src/utils/permissions.d.ts
+/**
+ * Permission utility functions for React Native uploads
+ * Handles camera, gallery, and file access permissions
+ */
+/**
+ * Permission types
+ */
+declare enum PermissionType {
+  CAMERA = "CAMERA",
+  PHOTO_LIBRARY = "PHOTO_LIBRARY",
+  WRITE_STORAGE = "WRITE_STORAGE",
+  READ_STORAGE = "READ_STORAGE",
+}
+/**
+ * Permission status
+ */
+declare enum PermissionStatus {
+  GRANTED = "granted",
+  DENIED = "denied",
+  NOT_DETERMINED = "not_determined",
+  RESTRICTED = "restricted",
+}
+/**
+ * Request camera permission
+ * This is primarily used to check if we should attempt camera operations
+ * Actual permission requests are handled by the file system providers
+ *
+ * @returns Promise resolving to true if permission is granted or already granted
+ */
+declare function requestCameraPermission(): Promise<boolean>;
+/**
+ * Request photo library permission
+ * @returns Promise resolving to true if permission is granted
+ */
+declare function requestPhotoLibraryPermission(): Promise<boolean>;
+/**
+ * Request storage read permission
+ * @returns Promise resolving to true if permission is granted
+ */
+declare function requestStorageReadPermission(): Promise<boolean>;
+/**
+ * Request storage write permission
+ * @returns Promise resolving to true if permission is granted
+ */
+declare function requestStorageWritePermission(): Promise<boolean>;
+/**
+ * Request multiple permissions at once
+ * @param permissions - Array of permission types to request
+ * @returns Promise resolving to true if all permissions are granted
+ */
+declare function requestPermissions(permissions: PermissionType[]): Promise<boolean>;
+/**
+ * Check if all required permissions are granted
+ * @param permissions - Array of permission types to check
+ * @returns Promise resolving to true if all permissions are granted
+ */
+declare function hasPermissions(_permissions: PermissionType[]): Promise<boolean>;
+/**
+ * Get permission status
+ * @param permission - Permission type to check
+ * @returns Promise resolving to permission status
+ */
+declare function getPermissionStatus(_permission: PermissionType): Promise<PermissionStatus>;
+/**
+ * Open app settings to request permissions
+ * Guides user to app settings where they can manually enable permissions
+ */
+declare function openAppSettings(): void;
+//#endregion
+//#region src/utils/uriHelpers.d.ts
+/**
+ * URI utility functions for React Native file handling
+ */
+/**
+ * Extract file name from URI
+ * @param uri - File URI
+ * @returns File name extracted from URI
+ */
+declare function getFileNameFromUri(uri: string): string;
+/**
+ * Convert file path to file URI
+ * @param filePath - File path
+ * @returns File URI
+ */
+declare function pathToUri(filePath: string): string;
+/**
+ * Convert file URI to file path
+ * @param uri - File URI
+ * @returns File path
+ */
+declare function uriToPath(uri: string): string;
+/**
+ * Get directory from URI
+ * @param uri - File URI
+ * @returns Directory path
+ */
+declare function getDirectoryFromUri(uri: string): string;
+/**
+ * Check if URI is a content URI (Android specific)
+ * @param uri - URI to check
+ * @returns True if URI is a content URI
+ */
+declare function isContentUri(uri: string): boolean;
+/**
+ * Check if URI is a file URI
+ * @param uri - URI to check
+ * @returns True if URI is a file URI
+ */
+declare function isFileUri(uri: string): boolean;
+/**
+ * Normalize URI for cross-platform compatibility
+ * @param uri - URI to normalize
+ * @returns Normalized URI
+ */
+declare function normalizeUri(uri: string): string;
+/**
+ * Get MIME type hint from URI
+ * @param uri - File URI
+ * @returns MIME type hint based on file extension
+ */
+declare function getMimeTypeFromUri(uri: string): string;
+//#endregion
+export { type Base64Service, type CameraOptions, CameraUploadButton, type CameraUploadButtonProps, type ConnectionMetrics, type ConnectionPoolConfig, type DetailedConnectionMetrics, type FileInfo, type FilePickResult, type FileReaderService, type FileSystemProvider, type FileSystemProviderConfig, FileUploadButton, type FileUploadButtonProps, type FlowUploadState, type FlowUploadStatus, GalleryUploadButton, type GalleryUploadButtonProps, type HttpClient, type IdGenerationService, type MultiUploadState, PermissionStatus, PermissionType, type PickerOptions, type ReactNativeUploadInput, type ServiceContainer, type StorageService, type UploadItemState, UploadList, type UploadListProps, type UploadMetrics, UploadProgress, type UploadProgressProps, type UploadState, type UploadStatus, UploadistaContext, type UploadistaContextType, type UseCameraUploadOptions, type UseFileUploadOptions, type UseFlowUploadOptions, type UseGalleryUploadOptions, type UseMultiUploadOptions, formatFileSize, getDirectoryFromUri, getFileExtension, getFileNameFromUri, getFileNameWithoutExtension, getMimeTypeFromFileName, getMimeTypeFromUri, getPermissionStatus, hasPermissions, isContentUri, isDocumentFile, isFileSizeValid, isFileTypeAllowed, isFileUri, isImageFile, isVideoFile, normalizeUri, openAppSettings, pathToUri, requestCameraPermission, requestPermissions, requestPhotoLibraryPermission, requestStorageReadPermission, requestStorageWritePermission, uriToPath, useCameraUpload, useFileUpload, useFlowUpload, useGalleryUpload, useMultiUpload, useUploadMetrics, useUploadistaContext };
+//# sourceMappingURL=index.d.ts.map