stratal 0.0.13 → 0.0.15

package/dist/storage/index.d.mts

@@ -0,0 +1,743 @@
+import { it as DynamicModule, nt as AsyncModuleOptions, s as ApplicationError } from "../index-D69rxo8H.mjs";
+import { o as z } from "../index-CpAN9ENH.mjs";
+import { PutObjectCommandInput } from "@aws-sdk/client-s3";
+
+//#region src/storage/types.d.ts
+/**
+ * Storage entry configuration
+ * Represents a single storage disk with its credentials
+ */
+interface StorageEntry {
+  disk: string;
+  provider: 's3' | 'gcs';
+  endpoint: string;
+  bucket: string;
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  root: string;
+  visibility: 'public' | 'private';
+}
+/**
+ * Presigned URL configuration
+ */
+interface PresignedUrlConfig {
+  defaultExpiry: number;
+  maxExpiry: number;
+}
+/**
+ * Storage configuration used by framework
+ */
+interface StorageConfig {
+  storage: StorageEntry[];
+  defaultStorageDisk: string;
+  presignedUrl: PresignedUrlConfig;
+}
+//#endregion
+//#region src/storage/storage.module.d.ts
+/**
+ * Storage module options
+ * Same as StorageConfig from types.ts
+ */
+type StorageModuleOptions = StorageConfig;
+declare class StorageModule {
+  /**
+   * Configure StorageModule with static options
+   *
+   * @param options - Storage configuration options
+   * @returns Dynamic module with storage infrastructure
+   *
+   * @example
+   * ```typescript
+   * StorageModule.forRoot({
+   *   storage: [{ disk: 'uploads', provider: 's3', ... }],
+   *   defaultStorageDisk: 'uploads',
+   *   presignedUrl: { defaultExpiry: 3600, maxExpiry: 86400 }
+   * })
+   * ```
+   */
+  static forRoot(options: StorageModuleOptions): DynamicModule;
+  /**
+   * Configure StorageModule with async factory
+   *
+   * Use when configuration depends on other services.
+   *
+   * @param options - Async configuration with factory and inject tokens
+   * @returns Dynamic module with storage infrastructure
+   *
+   * @example
+   * ```typescript
+   * StorageModule.forRootAsync({
+   *   inject: [storageConfig.KEY],
+   *   useFactory: (storage) => ({
+   *     storage: storage.storage,
+   *     defaultStorageDisk: storage.defaultStorageDisk,
+   *     presignedUrl: storage.presignedUrl
+   *   })
+   * })
+   * ```
+   */
+  static forRootAsync(options: AsyncModuleOptions<StorageModuleOptions>): DynamicModule;
+}
+//#endregion
+//#region src/storage/storage.tokens.d.ts
+/**
+ * Dependency injection tokens for the Storage module
+ * Using Symbol-based tokens to avoid magic strings
+ */
+declare const STORAGE_TOKENS: {
+  readonly Options: symbol;
+  readonly StorageService: symbol;
+  readonly StorageManager: symbol;
+};
+//#endregion
+//#region src/storage/contracts/delete-file.input.d.ts
+declare const deleteFileInputSchema: z.ZodObject<{
+  path: z.ZodString;
+  disk: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type DeleteFileInput = z.infer<typeof deleteFileInputSchema>;
+//#endregion
+//#region src/storage/contracts/download-result.d.ts
+/**
+ * Download Result
+ *
+ * Result of downloading a file from storage.
+ * Includes the file stream and metadata.
+ */
+interface DownloadResult {
+  /**
+   * ReadableStream of file contents
+   */
+  toStream(): undefined | ReadableStream<Uint8Array>;
+  toString(): undefined | Promise<string>;
+  toArrayBuffer(): undefined | Promise<Uint8Array>;
+  /**
+   * MIME type of the file (e.g., 'application/pdf', 'image/png')
+   */
+  contentType: string;
+  /**
+   * Size of the file in bytes
+   */
+  size: number;
+  /**
+   * Custom object metadata (S3-specific)
+   * Key-value pairs stored with the object
+   */
+  metadata?: Record<string, string>;
+}
+//#endregion
+//#region src/storage/contracts/file-exists.input.d.ts
+declare const fileExistsInputSchema: z.ZodObject<{
+  path: z.ZodString;
+  disk: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type FileExistsInput = z.infer<typeof fileExistsInputSchema>;
+//#endregion
+//#region src/storage/contracts/get-presigned-url.input.d.ts
+declare const getPresignedUrlInputSchema: z.ZodObject<{
+  path: z.ZodString;
+  method: z.ZodDefault<z.ZodEnum<{
+    GET: "GET";
+    PUT: "PUT";
+    DELETE: "DELETE";
+    HEAD: "HEAD";
+  }>>;
+  expiresIn: z.ZodOptional<z.ZodNumber>;
+  disk: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type GetPresignedUrlInput = z.infer<typeof getPresignedUrlInputSchema>;
+declare const presignedUrlResultSchema: z.ZodObject<{
+  url: z.ZodString;
+  expiresIn: z.ZodNumber;
+  expiresAt: z.ZodDate;
+  method: z.ZodEnum<{
+    GET: "GET";
+    PUT: "PUT";
+    DELETE: "DELETE";
+    HEAD: "HEAD";
+  }>;
+}, z.core.$strip>;
+type PresignedUrlResult = z.infer<typeof presignedUrlResultSchema>;
+//#endregion
+//#region src/storage/contracts/upload-file.input.d.ts
+/**
+ * Upload options for streaming uploads
+ */
+interface UploadOptions {
+  /**
+   * Size of the content in bytes
+   */
+  size: number;
+  /**
+   * MIME type of the content
+   */
+  mimeType?: string;
+  /**
+   * Custom metadata to store with the object (S3-specific)
+   * Stored as S3 object metadata headers
+   */
+  metadata?: Record<string, string>;
+  /**
+   * Object tagging for lifecycle policies (S3-specific)
+   * Format: key=value (e.g., "Tus-Completed=true")
+   */
+  tagging?: string;
+}
+declare const uploadResultSchema: z.ZodObject<{
+  path: z.ZodString;
+  disk: z.ZodString;
+  fullPath: z.ZodString;
+  size: z.ZodNumber;
+  mimeType: z.ZodString;
+  uploadedAt: z.ZodDate;
+}, z.core.$strip>;
+type UploadResult = z.infer<typeof uploadResultSchema>;
+//#endregion
+//#region src/storage/providers/storage-provider.interface.d.ts
+/**
+ * Streaming blob payload input types from AWS SDK
+ * Represents the types that can be used as the Body of a PutObjectCommand
+ */
+type StreamingBlobPayloadInputTypes = PutObjectCommandInput['Body'];
+/**
+ * Storage provider interface
+ * Defines the contract for storage implementations (R2, S3, GCS, etc.)
+ */
+interface IStorageProvider {
+  /**
+   * Upload content to storage
+   * @param body - Content to upload (stream, buffer, or string)
+   * @param path - Full path including disk root
+   * @param options - Upload options including size and mime type
+   * @returns Upload result with metadata
+   */
+  upload(body: StreamingBlobPayloadInputTypes, path: string, options: UploadOptions): Promise<UploadResult>;
+  /**
+   * Download a file from storage
+   * @param path - Full path to the file
+   * @returns Download result with stream and metadata
+   */
+  download(path: string): Promise<DownloadResult>;
+  /**
+   * Delete a file from storage
+   * @param path - Full path to the file
+   */
+  delete(path: string): Promise<void>;
+  /**
+   * Check if a file exists in storage
+   * @param path - Full path to the file
+   * @returns True if file exists, false otherwise
+   */
+  exists(path: string): Promise<boolean>;
+  /**
+   * Generate a presigned URL for temporary access
+   * @param path - Full path to the file
+   * @param method - HTTP method (GET, PUT, DELETE, HEAD)
+   * @param expiresIn - Expiry time in seconds (1-604800)
+   * @returns Presigned URL result
+   */
+  getPresignedUrl(path: string, method: 'GET' | 'PUT' | 'DELETE' | 'HEAD', expiresIn: number): Promise<PresignedUrlResult>;
+  /**
+   * Chunked upload for streaming data without known size
+   * Uses multipart upload under the hood for reliability
+   * @param body - Content to upload (stream or buffer)
+   * @param path - Full path including disk root
+   * @param options - Upload options (mimeType required, size optional)
+   * @returns Upload result with metadata
+   */
+  chunkedUpload(body: StreamingBlobPayloadInputTypes, path: string, options: Omit<UploadOptions, 'size'> & {
+    size?: number;
+  }): Promise<UploadResult>;
+}
+//#endregion
+//#region src/storage/services/storage-manager.service.d.ts
+/**
+ * Storage Manager Service
+ * Manages multiple storage providers (one per disk)
+ * Handles lazy initialization and caching of S3Clients
+ */
+declare class StorageManagerService {
+  private readonly options;
+  private readonly providers;
+  private readonly diskConfigs;
+  constructor(options: StorageConfig);
+  /**
+   * Initialize disk configurations from options
+   */
+  private initializeDiskConfigs;
+  /**
+   * Get provider for a specific disk
+   * Lazily initializes provider on first access
+   * @param diskName - Name of the disk
+   * @returns Storage provider instance
+   */
+  getProvider(diskName: string): IStorageProvider;
+  /**
+   * Create a provider instance based on configuration
+   * @param config - Storage entry configuration
+   * @returns Storage provider instance
+   */
+  private createProvider;
+  /**
+   * Get disk configuration
+   * @param diskName - Name of the disk
+   * @returns Storage entry configuration
+   */
+  getDiskConfig(diskName: string): StorageEntry;
+  /**
+   * Check if a disk exists
+   * @param diskName - Name of the disk
+   * @returns True if disk exists, false otherwise
+   */
+  hasDisk(diskName: string): boolean;
+  /**
+   * Get all available disk names
+   * @returns Array of disk names
+   */
+  getAvailableDisks(): string[];
+}
+//#endregion
+//#region src/storage/services/storage.service.d.ts
+/**
+ * Storage Service
+ *
+ * Main facade for storage operations.
+ * Request-scoped for proper isolation.
+ *
+ * @example
+ * ```typescript
+ * @inject(STORAGE_TOKENS.StorageService)
+ * private readonly storage: StorageService
+ *
+ * await this.storage.upload(file, 'documents/report.pdf')
+ * ```
+ */
+declare class StorageService {
+  protected readonly storageManager: StorageManagerService;
+  protected readonly options: StorageConfig;
+  constructor(storageManager: StorageManagerService, options: StorageConfig);
+  /**
+   * Upload content to storage
+   * @param body - Content to upload (stream, buffer, or string)
+   * @param relativePath - Relative path within the disk
+   * @param options - Upload options including size and mime type
+   * @param disk - Optional disk name (uses default if not provided)
+   * @returns Upload result with metadata
+   */
+  upload(body: StreamingBlobPayloadInputTypes, relativePath: string, options: UploadOptions, disk?: string): Promise<UploadResult>;
+  /**
+   * Download a file from storage
+   * @param relativePath - Relative path within the disk
+   * @param disk - Optional disk name (uses default if not provided)
+   * @returns Download result with stream and metadata
+   */
+  download(relativePath: string, disk?: string): Promise<DownloadResult>;
+  /**
+   * Delete a file from storage
+   * @param relativePath - Relative path within the disk
+   * @param disk - Optional disk name (uses default if not provided)
+   */
+  delete(relativePath: string, disk?: string): Promise<void>;
+  /**
+   * Check if a file exists in storage
+   * @param relativePath - Relative path within the disk
+   * @param disk - Optional disk name (uses default if not provided)
+   * @returns True if file exists, false otherwise
+   */
+  exists(relativePath: string, disk?: string): Promise<boolean>;
+  /**
+   * Generate a presigned download URL
+   * @param relativePath - Relative path within the disk
+   * @param expiresIn - Optional expiry time in seconds (uses default if not provided)
+   * @param disk - Optional disk name (uses default if not provided)
+   * @returns Presigned URL result
+   */
+  getPresignedDownloadUrl(relativePath: string, expiresIn?: number, disk?: string): Promise<PresignedUrlResult>;
+  /**
+   * Generate a presigned upload URL
+   * @param relativePath - Relative path within the disk
+   * @param expiresIn - Optional expiry time in seconds (uses default if not provided)
+   * @param disk - Optional disk name (uses default if not provided)
+   * @returns Presigned URL result
+   */
+  getPresignedUploadUrl(relativePath: string, expiresIn?: number, disk?: string): Promise<PresignedUrlResult>;
+  /**
+   * Generate a presigned delete URL
+   * @param relativePath - Relative path within the disk
+   * @param expiresIn - Optional expiry time in seconds (uses default if not provided)
+   * @param disk - Optional disk name (uses default if not provided)
+   * @returns Presigned URL result
+   */
+  getPresignedDeleteUrl(relativePath: string, expiresIn?: number, disk?: string): Promise<PresignedUrlResult>;
+  /**
+   * Generate a presigned URL for any method
+   * @param relativePath - Relative path within the disk
+   * @param method - HTTP method (GET, PUT, DELETE, HEAD)
+   * @param expiresIn - Optional expiry time in seconds (uses default if not provided)
+   * @param disk - Optional disk name (uses default if not provided)
+   * @returns Presigned URL result
+   */
+  protected getPresignedUrl(relativePath: string, method: 'GET' | 'PUT' | 'DELETE' | 'HEAD', expiresIn?: number, disk?: string): Promise<PresignedUrlResult>;
+  /**
+   * Resolve disk name (use default if not provided)
+   * @param disk - Optional disk name
+   * @returns Resolved disk name
+   */
+  protected resolveDisk(disk?: string): string;
+  /**
+   * Build full path with disk root and path template substitution
+   * @param relativePath - Relative path within the disk
+   * @param diskName - Name of the disk
+   * @returns Full path including disk root
+   */
+  protected buildFullPath(relativePath: string, diskName: string): string;
+  /**
+   * Substitute template variables in path
+   * Override this method in subclasses to add custom substitutions
+   *
+   * @param path - Path with template variables
+   * @returns Path with substituted variables
+   */
+  protected substituteTemplateVariables(path: string): string;
+  /**
+   * Validate expiry time for presigned URLs
+   * @param expiresIn - Optional expiry time in seconds
+   * @returns Validated expiry time
+   */
+  protected validateExpiresIn(expiresIn?: number): number;
+  /**
+   * Get all available disk names
+   * @returns Array of disk names
+   */
+  getAvailableDisks(): string[];
+  /**
+   * Chunked upload for streaming data without known size
+   * Uses multipart upload under the hood - handles retries and large files
+   *
+   * Use this method when:
+   * - Content-Length is unknown or unreliable
+   * - Uploading from streams that can't be rewound
+   * - Need automatic retry handling for transient failures
+   *
+   * @param body - Content to upload (stream or buffer)
+   * @param relativePath - Relative path within the disk
+   * @param options - Upload options (mimeType required, size optional)
+   * @param disk - Optional disk name (uses default if not provided)
+   * @returns Upload result with metadata
+   */
+  chunkedUpload(body: StreamingBlobPayloadInputTypes, relativePath: string, options: Omit<UploadOptions, 'size'> & {
+    size?: number;
+  }, disk?: string): Promise<UploadResult>;
+}
+//#endregion
+//#region src/storage/errors/disk-not-configured.error.d.ts
+declare class DiskNotConfiguredError extends ApplicationError {
+  constructor(disk: string);
+}
+//#endregion
+//#region src/storage/errors/file-not-found.error.d.ts
+declare class FileNotFoundError extends ApplicationError {
+  constructor(path: string);
+}
+//#endregion
+//#region src/storage/errors/file-too-large.error.d.ts
+declare class FileTooLargeError extends ApplicationError {
+  constructor(size: number, maxSize: number);
+}
+//#endregion
+//#region src/storage/errors/invalid-disk.error.d.ts
+declare class InvalidDiskError extends ApplicationError {
+  constructor(disk: string);
+}
+//#endregion
+//#region src/storage/errors/invalid-file-type.error.d.ts
+declare class InvalidFileTypeError extends ApplicationError {
+  constructor(mimeType: string);
+}
+//#endregion
+//#region src/storage/errors/presigned-url-invalid-expiry.error.d.ts
+declare class PresignedUrlInvalidExpiryError extends ApplicationError {
+  constructor(expiresIn: number, min: number, max: number);
+}
+//#endregion
+//#region src/storage/errors/storage-provider-not-supported.error.d.ts
+declare class StorageProviderNotSupportedError extends ApplicationError {
+  constructor(provider: string);
+}
+//#endregion
+//#region src/storage/errors/storage-response-body-missing.error.d.ts
+declare class StorageResponseBodyMissingError extends ApplicationError {
+  constructor(path: string);
+}
+//#endregion
+//#region src/storage/providers/s3-multipart-provider.interface.d.ts
+/**
+ * Options for creating a multipart upload
+ */
+interface CreateMultipartOptions {
+  /** Content type (MIME type) */
+  contentType?: string;
+  /** Cache control header */
+  cacheControl?: string;
+  /** Custom S3 metadata */
+  metadata?: Record<string, string>;
+  /** S3 object tagging (key=value format) */
+  tagging?: string;
+}
+/**
+ * Result of creating a multipart upload
+ */
+interface CreateMultipartResult {
+  /** S3 upload ID for subsequent part uploads */
+  uploadId: string;
+  /** Object key */
+  key: string;
+}
+/**
+ * Result of uploading a part
+ */
+interface UploadPartResult {
+  /** ETag returned by S3 */
+  etag: string;
+  /** Part number */
+  partNumber: number;
+}
+/**
+ * Part info for completing multipart upload
+ */
+interface CompletedPart {
+  /** ETag from uploadPart */
+  etag: string;
+  /** Part number */
+  partNumber: number;
+}
+/**
+ * Result of completing a multipart upload
+ */
+interface CompleteMultipartResult {
+  /** S3 location URL */
+  location?: string;
+  /** Object key */
+  key: string;
+}
+/**
+ * Individual part info from listParts
+ */
+interface PartInfo {
+  /** Part number */
+  partNumber: number;
+  /** ETag */
+  etag: string;
+  /** Part size in bytes */
+  size: number;
+}
+/**
+ * Result of listing parts
+ */
+interface ListPartsResult {
+  /** List of uploaded parts */
+  parts: PartInfo[];
+  /** Whether there are more parts */
+  isTruncated: boolean;
+  /** Marker for next page */
+  nextPartNumberMarker?: string;
+}
+/**
+ * Individual upload info from listMultipartUploads
+ */
+interface MultipartUploadInfo {
+  /** Object key */
+  key: string;
+  /** Upload ID */
+  uploadId: string;
+  /** When the upload was initiated */
+  initiated?: Date;
+}
+/**
+ * Result of listing multipart uploads
+ */
+interface ListMultipartUploadsResult {
+  /** List of in-progress uploads */
+  uploads: MultipartUploadInfo[];
+  /** Whether there are more uploads */
+  isTruncated: boolean;
+  /** Marker for next page (key) */
+  nextKeyMarker?: string;
+  /** Marker for next page (uploadId) */
+  nextUploadIdMarker?: string;
+}
+/**
+ * Result of headObject
+ */
+interface HeadObjectResult {
+  /** Object size in bytes */
+  size: number;
+  /** Content type */
+  contentType?: string;
+  /** Custom metadata */
+  metadata?: Record<string, string>;
+}
+/**
+ * Result of batch delete
+ */
+interface DeleteObjectsResult {
+  /** Number of objects deleted */
+  deleted: number;
+  /** Errors that occurred */
+  errors: {
+    key: string;
+    code: string;
+    message: string;
+  }[];
+}
+/**
+ * S3-specific storage provider interface with multipart upload support
+ *
+ * Extends the generic IStorageProvider with S3 multipart upload operations.
+ * This interface is S3-specific - other providers (GCS, local) would have
+ * their own resumable upload interfaces if needed.
+ */
+interface IS3MultipartProvider extends IStorageProvider {
+  /**
+   * Create a multipart upload
+   * @param key - Object key
+   * @param options - Upload options
+   * @returns Upload ID and key
+   */
+  createMultipartUpload(key: string, options?: CreateMultipartOptions): Promise<CreateMultipartResult>;
+  /**
+   * Upload a part to an existing multipart upload
+   * @param key - Object key
+   * @param uploadId - Upload ID from createMultipartUpload
+   * @param partNumber - Part number (1-10000)
+   * @param body - Part data
+   * @returns ETag and part number
+   */
+  uploadPart(key: string, uploadId: string, partNumber: number, body: Uint8Array): Promise<UploadPartResult>;
+  /**
+   * Complete a multipart upload
+   * @param key - Object key
+   * @param uploadId - Upload ID
+   * @param parts - List of completed parts with ETags
+   * @returns Location and key
+   */
+  completeMultipartUpload(key: string, uploadId: string, parts: CompletedPart[]): Promise<CompleteMultipartResult>;
+  /**
+   * Abort a multipart upload
+   * @param key - Object key
+   * @param uploadId - Upload ID
+   */
+  abortMultipartUpload(key: string, uploadId: string): Promise<void>;
+  /**
+   * List parts of a multipart upload
+   * @param key - Object key
+   * @param uploadId - Upload ID
+   * @param partNumberMarker - Optional marker for pagination
+   * @returns List of parts
+   */
+  listParts(key: string, uploadId: string, partNumberMarker?: string): Promise<ListPartsResult>;
+  /**
+   * List all in-progress multipart uploads
+   * @param keyMarker - Optional key marker for pagination
+   * @param uploadIdMarker - Optional upload ID marker for pagination
+   * @returns List of uploads
+   */
+  listMultipartUploads(keyMarker?: string, uploadIdMarker?: string): Promise<ListMultipartUploadsResult>;
+  /**
+   * Get object metadata without downloading the body
+   * Unlike exists() which returns boolean, this returns actual metadata
+   * @param key - Object key
+   * @returns Object metadata or null if not found
+   */
+  headObject(key: string): Promise<HeadObjectResult | null>;
+  /**
+   * Delete multiple objects in a single request
+   * More efficient than individual delete() calls
+   * @param keys - Array of object keys
+   * @returns Delete results
+   */
+  deleteObjects(keys: string[]): Promise<DeleteObjectsResult>;
+  /**
+   * Get the bucket name
+   * @returns Bucket name from configuration
+   */
+  getBucket(): string;
+}
+//#endregion
+//#region src/storage/providers/s3-storage.provider.d.ts
+/**
+ * S3 Storage Provider
+ * Implements storage operations using AWS SDK for S3-compatible storage
+ * Works with AWS S3, Cloudflare R2, MinIO, and other S3-compatible services
+ *
+ * Implements IS3MultipartProvider for multipart upload support needed by TUS
+ */
+declare class S3StorageProvider implements IS3MultipartProvider {
+  private readonly client;
+  private readonly bucket;
+  private readonly disk;
+  constructor(config: StorageEntry);
+  upload(body: StreamingBlobPayloadInputTypes, path: string, options: UploadOptions): Promise<UploadResult>;
+  download(path: string): Promise<DownloadResult>;
+  delete(path: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  getPresignedUrl(path: string, method: 'GET' | 'PUT' | 'DELETE' | 'HEAD', expiresIn: number): Promise<PresignedUrlResult>;
+  /**
+   * Chunked upload for streaming data without known size
+   * Uses @aws-sdk/lib-storage for multipart upload handling
+   *
+   * Benefits:
+   * - Handles unknown Content-Length automatically
+   * - Automatic retry on transient failures
+   * - Cleanup of partial uploads on error
+   * - Works with S3-compatible storage (R2, MinIO, RustFS)
+   *
+   * @param body - Content to upload (stream or buffer)
+   * @param path - Full path including disk root
+   * @param options - Upload options (mimeType required, size optional)
+   * @returns Upload result with metadata
+   */
+  chunkedUpload(body: StreamingBlobPayloadInputTypes, path: string, options: Omit<UploadOptions, 'size'> & {
+    size?: number;
+  }): Promise<UploadResult>;
+  /**
+   * Get the bucket name
+   */
+  getBucket(): string;
+  /**
+   * Get object metadata without downloading the body
+   */
+  headObject(key: string): Promise<HeadObjectResult | null>;
+  /**
+   * Delete multiple objects in a single request
+   */
+  deleteObjects(keys: string[]): Promise<DeleteObjectsResult>;
+  /**
+   * Create a multipart upload
+   */
+  createMultipartUpload(key: string, options?: CreateMultipartOptions): Promise<CreateMultipartResult>;
+  /**
+   * Upload a part to an existing multipart upload
+   */
+  uploadPart(key: string, uploadId: string, partNumber: number, body: Uint8Array): Promise<UploadPartResult>;
+  /**
+   * Complete a multipart upload
+   */
+  completeMultipartUpload(key: string, uploadId: string, parts: CompletedPart[]): Promise<CompleteMultipartResult>;
+  /**
+   * Abort a multipart upload
+   */
+  abortMultipartUpload(key: string, uploadId: string): Promise<void>;
+  /**
+   * List parts of a multipart upload
+   */
+  listParts(key: string, uploadId: string, partNumberMarker?: string): Promise<ListPartsResult>;
+  /**
+   * List all in-progress multipart uploads
+   */
+  listMultipartUploads(keyMarker?: string, uploadIdMarker?: string): Promise<ListMultipartUploadsResult>;
+}
+//#endregion
+export { type CompleteMultipartResult, type CompletedPart, type CreateMultipartOptions, type CreateMultipartResult, DeleteFileInput, type DeleteObjectsResult, DiskNotConfiguredError, DownloadResult, FileExistsInput, FileNotFoundError, FileTooLargeError, GetPresignedUrlInput, type HeadObjectResult, type IS3MultipartProvider, type IStorageProvider, InvalidDiskError, InvalidFileTypeError, type ListMultipartUploadsResult, type ListPartsResult, type MultipartUploadInfo, type PartInfo, type PresignedUrlConfig, PresignedUrlInvalidExpiryError, PresignedUrlResult, S3StorageProvider, STORAGE_TOKENS, type StorageConfig, type StorageEntry, StorageManagerService, StorageModule, StorageProviderNotSupportedError, StorageResponseBodyMissingError, StorageService, type StreamingBlobPayloadInputTypes, UploadOptions, type UploadPartResult, UploadResult, deleteFileInputSchema, fileExistsInputSchema, getPresignedUrlInputSchema, presignedUrlResultSchema, uploadResultSchema };
+//# sourceMappingURL=index.d.mts.map