@plyaz/types 1.15.20 → 1.16.1

package/dist/storage/interfaces.d.ts

@@ -0,0 +1,2242 @@
+/**
+ * Storage Package Interfaces
+ * @module @plyaz/types/storage
+ */
+import type { LoggerInterface } from '../logger/types';
+import type { StorageErrorCode } from '../errors/codes';
+import type { ADAPTER_HEALTH_STATUS, ENTITY_TYPE, FILE_ACCESS_LEVEL, FILE_CATEGORY, OUTPUT_FORMAT, PATH_GENERATION_STRATEGY, RETRY_STRATEGY, STORAGE_ADAPTER_TYPE, STORAGE_DEVICE_TYPE, STORAGE_EVENT_TYPE, STORAGE_QUEUE_PRIORITY, STORAGE_RENDERER_TYPE, TEMPLATE_OUTPUT_FORMAT, UPLOAD_STATUS, DOCUMENT_TYPE, MEDIA_ENTITY, STORAGE_VISIBILITY, STORAGE_ENVIRONMENT, BUSINESS_MODEL, ORGANIZATION_TIER, BUCKET_PURPOSE, PATH_STRATEGY } from './enums';
+import type { StorageSoftDeleteMetadata, StorageDeleteComplianceOptions, StorageComplianceConfig } from './compliance';
+import type { PluginRegistryConfig, StorageKnownPluginName, StoragePlugin } from './plugins';
+import type { StorageBaseWebhookAdapterConfig, StorageWebhookAdapter, StorageWebhookManagerConfig } from './webhooks';
+/**
+ * Simplified API client configuration for storage adapters
+ * Avoids direct dependency on full ApiConfig to prevent version conflicts
+ */
+export type StorageApiClientConfig = {
+    /** Base URL for the API (required) */
+    baseURL: string;
+} & Partial<Record<string, unknown>>;
+/**
+ * Generic Result type for storage operations
+ * Type-safe error handling without try-catch in happy path
+ */
+export type StorageResult<T, E = Error> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: E;
+};
+/**
+ * Event callback type for storage events
+ */
+export type StorageEventCallback = (payload: StorageEventPayload) => void | Promise<void>;
+/**
+ * Hash algorithm type for path generation
+ * Note: MD5 is included ONLY for non-security uses (deduplication, checksums).
+ * For security/compliance, use SHA-256 or higher.
+ */
+export type StoragePathHashAlgorithm = 'sha256' | 'sha384' | 'sha512' | 'md5';
+/**
+ * Hash algorithm type for signed URL generation
+ * Note: MD5 is NOT included as it's cryptographically broken and not compliant
+ */
+export type StorageHashAlgorithm = 'sha256' | 'sha384' | 'sha512';
+/**
+ * Signed URL permission type
+ */
+export type StorageSignedUrlPermission = 'read' | 'write' | 'delete';
+/**
+ * Adapter capability interface
+ * Defines what purposes an adapter can handle
+ */
+export interface StorageAdapterCapability {
+    /** Adapter name */
+    name: string;
+    /** Bucket purposes this adapter can handle */
+    supportedPurposes: BUCKET_PURPOSE[];
+    /** Priority for this adapter (higher = preferred) */
+    priority?: number;
+}
+/**
+ * File metadata interface
+ */
+export interface FileMetadata {
+    /** Unique identifier for the file */
+    fileId: string;
+    /** Original filename */
+    filename: string;
+    /** MIME type of the file */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+    /** File category */
+    category: FILE_CATEGORY;
+    /** Entity type that owns this file */
+    entityType: ENTITY_TYPE;
+    /** Entity ID that owns this file */
+    entityId: string;
+    /** Access level */
+    accessLevel: FILE_ACCESS_LEVEL;
+    /** Storage path */
+    path: string;
+    /** Public URL (if applicable) */
+    url?: string;
+    /** Upload status */
+    status: UPLOAD_STATUS;
+    /** File extension */
+    extension?: string;
+    /** File hash (for deduplication) */
+    hash?: string;
+    /** Custom metadata */
+    customMetadata?: Record<string, unknown>;
+    /** Extracted metadata (dimensions, duration, etc.) */
+    extractedMetadata?: {
+        width?: number;
+        height?: number;
+        duration?: number;
+        format?: string;
+        codec?: string;
+        bitrate?: number;
+        [key: string]: unknown;
+    };
+    /** Upload timestamp */
+    uploadedAt: Date;
+    /** Uploaded by user ID */
+    uploadedBy?: string;
+    /** Expiry timestamp (for temporary files) */
+    expiresAt?: Date;
+    /** Whether the file is immutable */
+    immutable?: boolean;
+    /** Retention policy ID */
+    retentionPolicyId?: string;
+    /** Tags for categorization */
+    tags?: string[];
+    /** Storage adapter name that stored this file */
+    adapter?: string;
+    /** Bucket name where file is stored */
+    bucket?: string;
+    /** Bucket purpose (for routing) */
+    bucketPurpose?: BUCKET_PURPOSE;
+}
+/**
+ * Upload parameters
+ */
+export interface UploadParams {
+    /** File buffer or stream (optional if templateId is provided) */
+    file?: globalThis.Buffer | globalThis.NodeJS.ReadableStream;
+    /** Original filename */
+    filename?: string;
+    /** MIME type (optional if templateId is provided) */
+    mimeType?: string;
+    /** File category */
+    category: FILE_CATEGORY;
+    /** Entity type */
+    entityType: ENTITY_TYPE;
+    /** Entity ID */
+    entityId: string;
+    /** Access level */
+    accessLevel?: FILE_ACCESS_LEVEL;
+    /** Custom metadata */
+    customMetadata?: Record<string, unknown>;
+    /** Whether to extract metadata */
+    extractMetadata?: boolean;
+    /** Whether to scan for viruses */
+    virusScan?: boolean;
+    /** Whether to process media (resize, transcode, etc.) */
+    processMedia?: boolean;
+    /** Media processing options */
+    mediaOptions?: MediaProcessingOptions;
+    /** Skip specific plugins by name for this operation (e.g., ['virus-scanner', 'cdn-invalidator']) */
+    skipPlugins?: readonly StorageKnownPluginName[];
+    /** Only run these specific plugins for this operation (e.g., ['metadata-enricher']) */
+    onlyPlugins?: readonly StorageKnownPluginName[];
+    /** Custom path (overrides path generation) */
+    customPath?: string;
+    /** Tags */
+    tags?: string[];
+    /** TTL in seconds (for temporary files) */
+    ttl?: number;
+    /** Whether the file is immutable */
+    immutable?: boolean;
+    /** Retention policy ID */
+    retentionPolicyId?: string;
+    /** Tenant/organization slug (for multi-tenancy) */
+    tenant?: string;
+    /** Document type (for compliance documents in R2) */
+    documentType?: DOCUMENT_TYPE;
+    /** Document ID (for compliance documents) */
+    documentId?: string;
+    /** Document slug (for human-readable names) */
+    documentSlug?: string;
+    /** Media entity type (for media files in Supabase) */
+    mediaEntity?: MEDIA_ENTITY;
+    /** Visibility level (for Supabase media) */
+    visibility?: STORAGE_VISIBILITY;
+    /** Storage environment (prod/stg/dev) */
+    environment?: STORAGE_ENVIRONMENT;
+    /** Region code (e.g., 'weur', 'use1') */
+    region?: string;
+    /** Business model (B2B/B2C/B2B2C/Internal) */
+    businessModel?: BUSINESS_MODEL;
+    /** Organization tier (for dedicated resources) */
+    organizationTier?: ORGANIZATION_TIER;
+    /** Organization ID (for org-specific isolation) */
+    organizationId?: string;
+    /** Variant name (for media: original, thumb, sm, md, lg, etc.) */
+    variantName?: string;
+    /** Bucket selection override (use specific bucket) */
+    bucketOverride?: string;
+    /** Adapter selection override (use specific adapter) */
+    adapterOverride?: string;
+    /** Locale for document generation (overrides service default) */
+    locale?: string;
+    /** Template data for document generation */
+    templateData?: Record<string, unknown>;
+    /** Template ID for document generation (e.g., 'invoices/standard-invoice') */
+    templateId?: string;
+    /** Output format (pdf, excel, word, png, etc.) - defaults to pdf */
+    outputFormat?: string;
+    /** Specific renderer to use by name (optional, registry selects best if not specified) */
+    rendererName?: string;
+    /** PDF render options (when outputFormat === 'pdf') */
+    pdfOptions?: PDFRenderOptions;
+    /** Excel render options (when outputFormat === 'excel') */
+    excelOptions?: StorageExcelRenderOptions;
+    /** Word render options (when outputFormat === 'word') */
+    wordOptions?: StorageWordRenderOptions;
+    /** Use queue for this operation (requires queue to be enabled in service config) */
+    useQueue?: boolean;
+    /** Queue priority (only used if useQueue is true) */
+    queuePriority?: STORAGE_QUEUE_PRIORITY;
+    /** Queue operation metadata (only used if useQueue is true) */
+    queueMetadata?: Record<string, unknown>;
+    /** Custom variants to generate (e.g., ['thumbnail', 'mobile', 'desktop'] or full config objects) */
+    variants?: string[] | StorageVariantConfig[];
+    /** Preset name(s) to use (e.g., 'profile-picture' or ['profile-picture', 'social-share']) */
+    presets?: string | string[];
+    /** Target device type for optimization (auto-detected if not specified) */
+    device?: string;
+    /** Generate variants for all devices (ignores device parameter, generates all optimized variants) */
+    allDevices?: boolean;
+    /** Progress callback for chunked/multipart uploads */
+    onProgress?: (progress: UploadProgressEvent) => void;
+    /** AbortSignal to cancel the upload */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Upload result
+ */
+export interface UploadResult {
+    /** File metadata */
+    metadata: FileMetadata;
+    /** Public URL (if applicable) */
+    url?: string;
+    /** Signed URL (for private files) */
+    signedUrl?: string;
+    /** Generated variants (device-optimized, thumbnails, resized versions, etc.) */
+    variants?: Record<string, StorageResolvedVariant>;
+    /** Legacy variants array (deprecated, use variants object instead) */
+    variantsArray?: Array<{
+        type: string;
+        url: string;
+        metadata: Partial<FileMetadata>;
+    }>;
+    /** Warnings (e.g., virus scan skipped) */
+    warnings?: string[];
+    /** Applied presets */
+    appliedPresets?: string[];
+    /** Target device (if specified) */
+    targetDevice?: string;
+}
+/**
+ * Download parameters
+ */
+export interface DownloadParams {
+    /** File ID or path */
+    fileId: string;
+    /** Whether to return a signed URL instead of the file */
+    signedUrl?: boolean;
+    /** Signed URL expiry in seconds */
+    signedUrlExpiry?: number;
+    /** Download filename (for Content-Disposition header) */
+    downloadFilename?: string;
+    /** Optional: Bucket name (if known, skips metadata lookup) */
+    bucket?: string;
+    /** Optional: Adapter name (if known, skips routing) */
+    adapter?: string;
+    /** Optional: Bucket purpose (for routing) */
+    bucketPurpose?: BUCKET_PURPOSE;
+}
+/**
+ * Download result
+ */
+export interface DownloadResult {
+    /** File buffer (if signedUrl is false) */
+    file?: globalThis.Buffer;
+    /** Signed URL (if signedUrl is true) */
+    url?: string;
+    /** File metadata */
+    metadata: FileMetadata;
+}
+/**
+ * Delete parameters
+ */
+export interface DeleteParams {
+    /** File ID or path */
+    fileId: string;
+    /** Whether to permanently delete (bypass soft delete) */
+    permanent?: boolean;
+    /** Delete reason (for audit logs) */
+    reason?: string;
+    /** Soft delete metadata (for tracking soft-deleted files) */
+    softDeleteMetadata?: StorageSoftDeleteMetadata;
+    /** Compliance options for this delete operation */
+    complianceOptions?: StorageDeleteComplianceOptions;
+    /** Optional: Bucket name (if known, skips metadata lookup) */
+    bucket?: string;
+    /** Optional: Adapter name (if known, skips routing) */
+    adapter?: string;
+    /** Optional: Bucket purpose (for routing) */
+    bucketPurpose?: BUCKET_PURPOSE;
+    /** Custom metadata for plugins and tracking */
+    customMetadata?: Record<string, unknown>;
+    /** Skip specific plugins by name for this operation */
+    skipPlugins?: readonly StorageKnownPluginName[];
+    /** Only run these specific plugins for this operation */
+    onlyPlugins?: readonly StorageKnownPluginName[];
+}
+/**
+ * File delete result
+ */
+export interface FileDeleteResult {
+    /** Whether the delete was successful */
+    success: boolean;
+    /** File metadata */
+    metadata?: FileMetadata;
+    /** Deletion timestamp */
+    deletedAt: Date;
+    /** Soft delete metadata (if soft deleted) */
+    softDelete?: {
+        deletedBy: string;
+        deletedAt: Date;
+        reason?: string;
+        gracePeriodDays?: number;
+        gracePeriodUntil?: Date;
+        canRestore: boolean;
+    };
+}
+/**
+ * Media processing options
+ */
+export interface MediaProcessingOptions {
+    /** Image resize options */
+    resize?: {
+        width?: number;
+        height?: number;
+        fit?: 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+        position?: 'center' | 'top' | 'bottom' | 'left' | 'right';
+    };
+    /** Image format conversion */
+    format?: 'jpeg' | 'png' | 'webp' | 'avif';
+    /** Image quality (1-100) */
+    quality?: number;
+    /** Video transcode options */
+    transcode?: {
+        codec?: string;
+        resolution?: string;
+        bitrate?: number;
+    };
+    /** Generate thumbnail */
+    thumbnail?: boolean;
+    /** Thumbnail size */
+    thumbnailSize?: {
+        width: number;
+        height: number;
+    };
+    /** Generate variants */
+    variants?: Array<{
+        name: string;
+        width?: number;
+        height?: number;
+        format?: string;
+        quality?: number;
+    }>;
+}
+/**
+ * Comprehensive variant configuration for images and videos
+ * Supports device-aware optimization and multiple formats
+ */
+export interface StorageVariantConfig {
+    /** Variant identifier (use StorageVariantName enum values) */
+    name: string;
+    /** Target width in pixels */
+    width?: number;
+    /** Target height in pixels */
+    height?: number;
+    /** Output format (webp, jpeg, png, avif for images; mp4, webm for videos) */
+    format?: 'webp' | 'jpeg' | 'png' | 'avif' | 'mp4' | 'webm' | 'hls';
+    /** Quality (1-100, default: 85 for images) */
+    quality?: number;
+    /** Aspect ratio ('16:9', '1:1', '4:3', 'preserve') */
+    aspectRatio?: string | 'preserve';
+    /** Video codec (h264, h265, vp9, av1) */
+    codec?: string;
+    /** Video bitrate (e.g., '1000k', '2500k') */
+    bitrate?: string;
+    /** Target device types for this variant (use StorageDeviceType enum values) */
+    devices?: STORAGE_DEVICE_TYPE[];
+    /** Fit mode for resizing (cover, contain, fill, inside, outside) */
+    fit?: 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+    /** Position for cropping (center, top, bottom, left, right) */
+    position?: 'center' | 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    /** Enable progressive rendering (for JPEG) */
+    progressive?: boolean;
+    /** Optimization level (0-100, higher = more compression time but smaller files) */
+    optimizationLevel?: number;
+    /** Maximum file size in bytes (will adjust quality to meet target) */
+    maxFileSize?: number;
+    /** Custom metadata for this variant */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Preset configuration for reusable transformation sets
+ * Presets bundle multiple variants with common settings
+ */
+export interface StoragePresetConfig {
+    /** Preset identifier (e.g., 'profile-picture', 'post-image', 'hero-banner') */
+    name: string;
+    /** Description of this preset */
+    description?: string;
+    /** Variants included in this preset (use StorageVariantName enum values or full config) */
+    variants: string[] | StorageVariantConfig[];
+    /** Default format for all variants (can be overridden per variant) */
+    format?: 'webp' | 'jpeg' | 'png' | 'avif' | 'mp4' | 'webm' | 'hls';
+    /** Default quality for all variants (can be overridden per variant) */
+    quality?: number;
+    /** Default aspect ratio for all variants */
+    aspectRatio?: string | 'preserve';
+    /** Default codec for video variants */
+    codec?: string;
+    /** File categories this preset applies to */
+    categories?: FILE_CATEGORY[];
+    /** Device types this preset optimizes for (use StorageDeviceType enum values) */
+    devices?: STORAGE_DEVICE_TYPE[];
+    /** Priority (lower = higher priority when multiple presets match) */
+    priority?: number;
+    /** Whether this preset is enabled (default: true) */
+    enabled?: boolean;
+    /** Custom metadata for this preset */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Device-aware variant selection result
+ * Contains the resolved variant URL and metadata
+ */
+export interface StorageResolvedVariant {
+    /** Variant name (STORAGE_VARIANT_NAME enum value) */
+    name: string;
+    /** Variant URL */
+    url: string;
+    /** File ID */
+    fileId?: string;
+    /** Width in pixels */
+    width?: number;
+    /** Height in pixels */
+    height?: number;
+    /** File size in bytes */
+    size?: number;
+    /** Format */
+    format?: string;
+    /** Device types this variant is optimized for (STORAGE_DEVICE_TYPE enum values) */
+    devices?: STORAGE_DEVICE_TYPE[];
+    /** Custom metadata */
+    metadata?: Partial<FileMetadata>;
+}
+/**
+ * Variant resolution options for PresetManager
+ * Used to resolve variants from presets, custom variants, and device context
+ */
+export interface StorageResolveVariantsOptions {
+    /** Preset names to apply */
+    presets?: string | string[];
+    /** Custom variants (overrides presets) */
+    variants?: string[] | StorageVariantConfig[];
+    /** Target device type */
+    device?: string;
+    /** File category for default variants */
+    category?: FILE_CATEGORY;
+    /** Generate for all devices (ignores device parameter) */
+    allDevices?: boolean;
+}
+/**
+ * Generate file parameters (to buffer, without uploading)
+ */
+export interface GenerateFileParams {
+    /** Template ID */
+    templateId: string;
+    /** Template data */
+    templateData: Record<string, unknown>;
+    /** Output format (default: 'pdf') */
+    outputFormat?: OUTPUT_FORMAT | string;
+    /** Locale for generation */
+    locale?: string;
+    /** Specific renderer to use by name */
+    rendererName?: STORAGE_RENDERER_TYPE | string;
+    /** PDF render options */
+    pdfOptions?: PDFRenderOptions;
+}
+/**
+ * Generate file to path parameters
+ */
+export interface GenerateFileToPathParams extends GenerateFileParams {
+    /** Output path (local file system) */
+    outputPath: string;
+}
+/**
+ * Generate file to path result
+ */
+export interface GenerateFileToPathResult {
+    /** Output path */
+    path: string;
+    /** File size in bytes */
+    size: number;
+    /** Output format */
+    format: string;
+    /** Renderer used */
+    renderer: string;
+}
+/**
+ * Update file parameters
+ */
+export interface UpdateFileParams {
+    /** Existing file ID to update */
+    fileId: string;
+    /** New file buffer (if replacing with buffer) */
+    file?: globalThis.Buffer;
+    /** Template ID (if regenerating from template) */
+    templateId?: string;
+    /** Template data (if regenerating from template) */
+    templateData?: Record<string, unknown>;
+    /** Output format (if regenerating) */
+    outputFormat?: string;
+    /** Locale (if regenerating) */
+    locale?: string;
+    /** Custom metadata to merge with existing */
+    customMetadata?: Record<string, unknown>;
+    /** Reason for update (audit trail) */
+    reason?: string;
+    /** Skip specific plugins by name for this operation */
+    skipPlugins?: readonly StorageKnownPluginName[];
+    /** Only run these specific plugins for this operation */
+    onlyPlugins?: readonly StorageKnownPluginName[];
+}
+/**
+ * Validation rule
+ */
+export interface ValidationRule {
+    /** Allowed MIME types */
+    allowedMimeTypes?: string[];
+    /** Allowed file extensions */
+    allowedExtensions?: string[];
+    /** Maximum file size in bytes */
+    maxSize?: number;
+    /** Minimum file size in bytes */
+    minSize?: number;
+    /** Whether to allow executables */
+    allowExecutables?: boolean;
+    /** Custom validation function */
+    customValidation?: (file: globalThis.Buffer, metadata: Partial<FileMetadata>) => Promise<boolean>;
+}
+/**
+ * File validation result
+ */
+export interface FileValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Error code (if validation failed) */
+    errorCode?: StorageErrorCode;
+    /** Error message */
+    errorMessage?: string;
+    /** Additional context */
+    context?: Record<string, unknown>;
+}
+/**
+ * Adapter health check result
+ */
+export interface AdapterHealthCheck {
+    /** Health status */
+    status: ADAPTER_HEALTH_STATUS;
+    /** Response time in milliseconds */
+    responseTime?: number;
+    /** Error message (if unhealthy) */
+    error?: string;
+    /** Last check timestamp */
+    lastChecked: Date;
+    /** Additional details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Storage event payload base
+ */
+export interface StorageEventPayload {
+    /** Event type */
+    type: STORAGE_EVENT_TYPE;
+    /** Timestamp */
+    timestamp: Date;
+    /** File metadata */
+    metadata?: FileMetadata;
+    /** Additional data */
+    data?: Record<string, unknown>;
+}
+/**
+ * Storage retry configuration
+ */
+export interface StorageRetryConfig {
+    /** Retry strategy */
+    strategy: RETRY_STRATEGY;
+    /** Maximum retry attempts */
+    maxAttempts: number;
+    /** Initial delay in milliseconds */
+    initialDelay: number;
+    /** Maximum delay in milliseconds */
+    maxDelay?: number;
+    /** Backoff multiplier */
+    backoffMultiplier?: number;
+}
+/**
+ * Path generation configuration
+ */
+export interface PathGenerationConfig {
+    /** Path generation strategy */
+    strategy: PATH_GENERATION_STRATEGY;
+    /** Custom path template */
+    template?: string;
+    /** Whether to include file hash in path */
+    includeHash?: boolean;
+    /** Whether to include timestamp in path */
+    includeTimestamp?: boolean;
+}
+/**
+ * Bucket configuration (provider-agnostic)
+ * Describes what a bucket is used for, not how it's named
+ */
+export interface BucketConfiguration {
+    /** Bucket purpose */
+    purpose: BUCKET_PURPOSE;
+    /** Business model context (optional) */
+    businessModel?: BUSINESS_MODEL;
+    /** Organization tier (optional) */
+    tier?: ORGANIZATION_TIER;
+    /** Organization ID (for dedicated buckets) */
+    organizationId?: string;
+    /** Environment context */
+    environment?: string;
+    /** Region context */
+    region?: string;
+}
+/**
+ * Storage category metadata
+ * Provider-agnostic bucket organization
+ */
+export interface StorageCategory {
+    /** Unique category identifier */
+    purpose: BUCKET_PURPOSE;
+    /** Human-readable description */
+    description: string;
+    /** Typical use cases */
+    useCases: string[];
+    /** Recommended retention period (days) */
+    recommendedRetention?: number;
+    /** Whether this requires compliance logging */
+    requiresCompliance: boolean;
+    /** Whether this supports public access */
+    supportsPublicAccess: boolean;
+    /** Recommended access level */
+    defaultVisibility: STORAGE_VISIBILITY;
+}
+/**
+ * Routing decision result
+ */
+export interface RoutingDecision {
+    /** Adapter name to use */
+    adapterName: string;
+    /** Bucket purpose (adapter translates to actual name) */
+    bucketPurpose: BUCKET_PURPOSE;
+    /** Bucket configuration */
+    bucketConfig: BucketConfiguration;
+    /** Generated path (if auto-generated) */
+    path?: string;
+    /** Path generation strategy used */
+    pathStrategy?: PATH_STRATEGY;
+    /** Reason for routing decision (for logging) */
+    reason: string;
+}
+/**
+ * Routing rule condition function
+ */
+export type RoutingCondition = (params: UploadParams, purpose: BUCKET_PURPOSE) => boolean;
+/**
+ * Routing rule definition
+ */
+export interface RoutingRule {
+    /** Rule name (for debugging/logging) */
+    name: string;
+    /** Condition function */
+    condition: RoutingCondition;
+    /** Adapter name to route to */
+    adapterName: string;
+    /** Priority (higher = checked first) */
+    priority?: number;
+    /** Whether to auto-generate path */
+    generatePath?: boolean;
+}
+/**
+ * Bucket Router Configuration
+ */
+export interface BucketRouterConfig {
+    /** Custom routing rules */
+    customRules?: RoutingRule[];
+    /** Enable default routing rules */
+    enableDefaultRules?: boolean;
+    /** Logger instance */
+    logger?: LoggerInterface;
+    /** User preferences: which adapter to use for each purpose */
+    adapterPreferences?: Partial<Record<BUCKET_PURPOSE, string>>;
+    /** Available adapters (passed from StorageService) */
+    availableAdapters?: string[];
+}
+/**
+ * Options for compliance document paths
+ * Works on ANY storage provider (R2, S3, Supabase, etc.)
+ */
+export interface CompliancePathOptions {
+    /** Tenant/organization slug */
+    tenant: string;
+    /** Document type (invoice, receipt, tax, etc.) */
+    documentType: DOCUMENT_TYPE;
+    /** Document ID (UUID or system ID) */
+    documentId: string;
+    /** Human-readable slug (optional) */
+    slug?: string;
+    /** File extension (with dot, e.g., '.pdf') */
+    extension: string;
+    /** Date for path (defaults to now) */
+    date?: Date;
+    /** Business model for sub-tenant separation */
+    businessModel?: BUSINESS_MODEL;
+    /** Organization ID for multi-org */
+    organizationId?: string;
+}
+/**
+ * Options for media paths
+ * Works on ANY storage provider
+ */
+export interface MediaPathOptions {
+    /** Visibility level (public/private) */
+    visibility: STORAGE_VISIBILITY;
+    /** Media entity type (team, club, athlete, etc.) */
+    entity: MEDIA_ENTITY;
+    /** Entity ID (UUID or system ID) */
+    entityId: string;
+    /** Variant name (original, thumb, sm, md, lg, etc.) */
+    variant: string;
+    /** Filename with extension */
+    filename: string;
+    /** Date for path (defaults to now) */
+    date?: Date;
+    /** Business model for routing */
+    businessModel?: BUSINESS_MODEL;
+}
+/**
+ * Options for general paths
+ * Works on ANY storage provider
+ */
+export interface GeneralPathOptions {
+    /** File category */
+    category: string;
+    /** Entity type */
+    entityType: string;
+    /** Entity ID */
+    entityId: string;
+    /** Filename */
+    filename: string;
+    /** Date for path (defaults to now) */
+    date?: Date;
+    /** Include UUID in filename */
+    includeUuid?: boolean;
+}
+/**
+ * Storage service configuration
+ */
+/**
+ * Storage template engine configuration
+ */
+export interface StorageTemplateEngineConfig<TTemplateService = unknown, TTranslationService = unknown, TRendererRegistry = unknown, TLayoutEngine = unknown> {
+    /** Template service for loading templates (markdown files for PDFs) */
+    templateService?: TTemplateService;
+    /** Translation service for loading translation strings (JSON files for i18n) - optional */
+    translationService?: TTranslationService;
+    /** Renderer registry for converting HTML to PDF/PNG/etc. - optional */
+    rendererRegistry?: TRendererRegistry;
+    /** Layout engine for applying headers/footers/wrappers - optional */
+    layoutEngine?: TLayoutEngine;
+    /** Logger instance */
+    logger?: LoggerInterface;
+    /** Default locale (default: 'en') */
+    defaultLocale?: string;
+    /** Base path for templates (default: process.cwd() + '/templates') */
+    templateBasePath?: string;
+    /** Enable template caching (default: true) */
+    cacheEnabled?: boolean;
+    /** Cache TTL in milliseconds (default: 5 minutes) */
+    cacheTTL?: number;
+    /** Custom Handlebars helpers */
+    helpers?: Record<string, unknown>;
+    /** Renderer configuration */
+    renderer?: {
+        /** Renderer to use (e.g., 'pdfkit', 'puppeteer', 'playwright', 'exceljs', 'officegen') */
+        use?: string;
+        /** Default output format (default: 'pdf') */
+        defaultFormat?: string;
+        /** Custom renderer options passed to the renderer adapter */
+        options?: Record<string, unknown>;
+    };
+}
+/**
+ * Storage service configuration
+ */
+/**
+ * Cleaner event handler interface with camelCase method names
+ * Provides intuitive naming instead of enum-based syntax
+ *
+ * @example
+ * ```typescript
+ * const handlers: StorageEventHandlers = {
+ *   onFileUploaded: async (payload) => { ... },
+ *   onFileDeleted: async (payload) => { ... },
+ *   onQueueStarted: async (payload) => { ... },
+ * };
+ * ```
+ */
+export interface StorageEventHandlers {
+    onFileUploaded?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileUploadFailed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onUploadProgress?: (payload: StorageEventPayload) => void | Promise<void>;
+    onUploadAborted?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileDeleted?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileDeleteFailed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileAccessed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onSignedUrlGenerated?: (payload: StorageEventPayload) => void | Promise<void>;
+    onMetadataExtracted?: (payload: StorageEventPayload) => void | Promise<void>;
+    onMediaProcessingStarted?: (payload: StorageEventPayload) => void | Promise<void>;
+    onMediaProcessingCompleted?: (payload: StorageEventPayload) => void | Promise<void>;
+    onMediaProcessingFailed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onVirusDetected?: (payload: StorageEventPayload) => void | Promise<void>;
+    onVirusScanCompleted?: (payload: StorageEventPayload) => void | Promise<void>;
+    onAdapterHealthCheck?: (payload: StorageEventPayload) => void | Promise<void>;
+    onAdapterFailed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onRetentionPolicyApplied?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileMarkedForDeletion?: (payload: StorageEventPayload) => void | Promise<void>;
+    onImmutabilityEnforced?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileReplaced?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileReplaceFailed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileMoved?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileMoveFailed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileCopied?: (payload: StorageEventPayload) => void | Promise<void>;
+    onFileCopyFailed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onAuditLogCreated?: (payload: StorageEventPayload) => void | Promise<void>;
+    onQueueStarted?: (payload: StorageEventPayload) => void | Promise<void>;
+    onQueueStopped?: (payload: StorageEventPayload) => void | Promise<void>;
+    onOperationProcessing?: (payload: StorageEventPayload) => void | Promise<void>;
+    onOperationCompleted?: (payload: StorageEventPayload) => void | Promise<void>;
+    onOperationRetry?: (payload: StorageEventPayload) => void | Promise<void>;
+    onOperationFailed?: (payload: StorageEventPayload) => void | Promise<void>;
+    onStorageError?: (payload: StorageEventPayload) => void | Promise<void>;
+}
+/**
+ * Preset manager configuration
+ * Manages variant presets and device-aware optimization
+ */
+export interface StoragePresetManagerConfig {
+    /** Custom presets to register */
+    presets?: StoragePresetConfig[];
+    /** Default variants by file category */
+    defaultVariants?: Partial<Record<FILE_CATEGORY, string[]>>;
+    /** Enable built-in presets (profile-picture, post-image, hero-banner, video-streaming) */
+    enableBuiltInPresets?: boolean;
+    /** Default device type when not specified */
+    defaultDevice?: string;
+    /** Enable device detection from user agent */
+    enableDeviceDetection?: boolean;
+    /** Logger instance */
+    logger?: unknown;
+}
+/**
+ * Storage service configuration
+ */
+export interface StorageServiceConfig<BaseStorageAdapter = unknown> {
+    /** Storage adapters to register */
+    adapters: BaseStorageAdapter[];
+    /** Logger instance */
+    logger?: LoggerInterface;
+    /** Event handlers (enum-based syntax) */
+    eventHandlers?: Partial<Record<STORAGE_EVENT_TYPE, (payload: StorageEventPayload) => void | Promise<void>>>;
+    /** Event handlers (cleaner camelCase syntax - recommended) */
+    handlers?: StorageEventHandlers;
+    /** Adapter registry configuration */
+    adapterRegistryConfig?: Omit<StorageAdapterRegistryConfig, 'logger'>;
+    /** Event manager configuration */
+    eventManagerConfig?: Omit<StorageEventManagerConfig, 'logger'>;
+    /** Maximum retry attempts for failover */
+    maxFailoverAttempts?: number;
+    /** Template engine configuration (for PDF generation) */
+    template?: StorageTemplateEngineConfig;
+    /** Custom template service (defaults to FileSystemTemplateService) */
+    templateService?: TemplateService;
+    /** Queue configuration (for background operations) */
+    queue?: StorageQueueConfig;
+    /** Compliance configuration (retention policies, immutability, etc.) */
+    compliance?: StorageComplianceConfig;
+    /** Plugins to register (extends storage functionality with lifecycle hooks) */
+    plugins?: StoragePlugin[];
+    /** Plugin registry configuration */
+    pluginRegistryConfig?: Omit<PluginRegistryConfig, 'logger'>;
+    /** Webhook configuration (for external service integrations) */
+    webhooks?: StorageWebhookManagerConfig;
+    /** Webhook adapters to register */
+    webhookAdapters?: StorageWebhookAdapter[];
+    /** Preset manager configuration (variant presets and device-aware optimization) */
+    presets?: StoragePresetManagerConfig;
+    /** Bucket router configuration (content-based routing to adapters) */
+    bucketRouterConfig?: Omit<BucketRouterConfig, 'logger' | 'availableAdapters'>;
+}
+/**
+ * File validation rules per bucket purpose
+ */
+export interface BucketPurposeValidationRules {
+    /** Maximum file size in bytes */
+    maxFileSize?: number;
+    /** Minimum file size in bytes */
+    minFileSize?: number;
+    /** Allowed MIME types (supports wildcards like 'image/*') */
+    allowedMimeTypes?: string[];
+    /** Disallowed MIME types */
+    disallowedMimeTypes?: string[];
+    /** Allow executable files (default: false) */
+    allowExecutables?: boolean;
+}
+/**
+ * Storage validation configuration
+ * Defines file size limits and MIME type restrictions per bucket purpose
+ */
+export interface StorageValidationConfig {
+    /** Validation rules per bucket purpose */
+    rules?: Partial<Record<BUCKET_PURPOSE, BucketPurposeValidationRules>>;
+    /** Default rules for buckets without specific rules */
+    defaultRules?: BucketPurposeValidationRules;
+}
+/**
+ * Base storage adapter configuration
+ */
+export interface BaseStorageAdapterConfig {
+    /** Adapter name */
+    name: string;
+    /** Adapter type */
+    type: STORAGE_ADAPTER_TYPE;
+    /** Whether this adapter is enabled */
+    enabled?: boolean;
+    /** Adapter priority (higher = preferred) */
+    priority?: number;
+    /** Health check interval in milliseconds */
+    healthCheckInterval?: number;
+    /** Retry configuration */
+    retry?: StorageRetryConfig;
+    /** API client configuration (for custom adapters) */
+    apiClientConfig?: StorageApiClientConfig;
+    /** Auto-create buckets if they don't exist (default: true) */
+    autoCreateBuckets?: boolean;
+    /** Default environment for bucket naming (prod/stg/dev) */
+    defaultEnvironment?: STORAGE_ENVIRONMENT;
+    /** Default region for bucket naming */
+    defaultRegion?: string;
+    /** Validation configuration (file size limits, MIME types per bucket purpose) */
+    validation?: StorageValidationConfig;
+    /** Progress callback for all uploads through this adapter */
+    onProgress?: (progress: UploadProgressEvent) => void;
+    /** Global abort signal for this adapter (can be used to cancel all operations) */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Cloudflare R2 adapter configuration
+ */
+export interface CloudflareR2Config extends BaseStorageAdapterConfig {
+    type: STORAGE_ADAPTER_TYPE.CloudflareR2;
+    /** AWS S3-compatible credentials */
+    credentials: {
+        accountId: string;
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+    /** Bucket name (optional when autoCreateBuckets is enabled - will use dynamic buckets) */
+    bucket?: string;
+    /** Region */
+    region?: string;
+    /** Public URL domain (for public files) */
+    publicDomain?: string;
+    /** Endpoint URL */
+    endpoint?: string;
+}
+/**
+ * Supabase Storage adapter configuration
+ */
+export interface SupabaseStorageConfig extends BaseStorageAdapterConfig {
+    type: STORAGE_ADAPTER_TYPE.SupabaseStorage;
+    /** Supabase URL */
+    supabaseUrl: string;
+    /** Supabase service role key */
+    serviceRoleKey: string;
+    /** Default bucket name (optional when autoCreateBuckets is enabled - will use dynamic buckets) */
+    bucket?: string;
+    /** Public URL (for public files) */
+    publicUrl?: string;
+}
+/**
+ * Custom adapter configuration
+ */
+export interface CustomAdapterConfig extends BaseStorageAdapterConfig {
+    type: STORAGE_ADAPTER_TYPE.CUSTOM;
+    /** API client configuration */
+    apiClientConfig: StorageApiClientConfig;
+    /** Upload endpoint */
+    uploadEndpoint: string;
+    /** Download endpoint */
+    downloadEndpoint: string;
+    /** Delete endpoint */
+    deleteEndpoint: string;
+    /** Signed URL endpoint */
+    signedUrlEndpoint?: string;
+    /** Health check endpoint */
+    healthCheckEndpoint?: string;
+}
+/**
+ * Mock adapter configuration (for testing)
+ */
+export interface MockAdapterConfig extends BaseStorageAdapterConfig {
+    type: STORAGE_ADAPTER_TYPE.MOCK;
+    /** Whether to simulate failures */
+    simulateFailures?: boolean;
+    /** Failure rate (0-1) */
+    failureRate?: number;
+    /** Simulated latency in milliseconds */
+    latency?: number;
+}
+/**
+ * Base storage plugin configuration
+ */
+export interface BaseStoragePluginConfig {
+    /** Plugin name */
+    name: string;
+    /** Whether the plugin is enabled */
+    enabled?: boolean;
+    /** Plugin priority (higher = runs first) */
+    priority?: number;
+    /** Plugin hooks */
+    hooks?: {
+        beforeUpload?: boolean;
+        afterUpload?: boolean;
+        afterDelete?: boolean;
+    };
+}
+/**
+ * Queue item
+ */
+export interface QueueItem<T = unknown> {
+    /** Item ID */
+    id: string;
+    /** Item data */
+    data: T;
+    /** Priority */
+    priority: STORAGE_QUEUE_PRIORITY;
+    /** Retry count */
+    retryCount: number;
+    /** Maximum retries */
+    maxRetries: number;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Scheduled execution time */
+    scheduledAt?: Date;
+}
+/**
+ * Storage queue configuration
+ */
+export interface StorageQueueConfig {
+    /** Enable queue processing */
+    enabled?: boolean;
+    /** Maximum queue size */
+    maxSize?: number;
+    /** Maximum concurrent workers */
+    concurrency?: number;
+    /** Processing interval in milliseconds */
+    interval?: number;
+    /** Default priority */
+    defaultPriority?: STORAGE_QUEUE_PRIORITY;
+    /** Default max retries */
+    maxRetries?: number;
+    /** Retry delay in milliseconds */
+    retryDelay?: number;
+    /** Auto-start queue processor */
+    autoStart?: boolean;
+}
+/**
+ * Storage file operation type for queue
+ */
+export type StorageFileOperationType = 'upload' | 'download' | 'delete' | 'render' | 'transform';
+/**
+ * Queued storage file operation
+ */
+export interface StorageQueuedOperation {
+    /** Operation ID */
+    id: string;
+    /** Operation type */
+    type: StorageFileOperationType;
+    /** File ID (for download/delete operations) */
+    fileId?: string;
+    /** Upload parameters (for upload operations) */
+    uploadParams?: UploadParams;
+    /** Template ID (for render operations) */
+    templateId?: string;
+    /** Template data (for render operations) */
+    templateData?: Record<string, unknown>;
+    /** Priority */
+    priority: STORAGE_QUEUE_PRIORITY;
+    /** Retry count */
+    retryCount: number;
+    /** Maximum retries */
+    maxRetries: number;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Scheduled execution time */
+    scheduledAt?: Date;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Process function for storage queue processor
+ */
+export type StorageQueueProcessFunction = (operation: StorageQueuedOperation) => Promise<void>;
+/**
+ * Storage queue statistics
+ */
+export interface StorageQueueStatistics {
+    /** Total operations queued */
+    totalQueued: number;
+    /** Operations currently in queue */
+    currentSize: number;
+    /** Operations processed successfully */
+    processedCount: number;
+    /** Operations that failed */
+    failedCount: number;
+    /** Queue is currently processing */
+    isProcessing: boolean;
+}
+/**
+ * Retention policy
+ */
+export interface RetentionPolicy {
+    /** Policy ID */
+    id: string;
+    /** Policy name */
+    name: string;
+    /** Retention duration in days */
+    retentionDays: number;
+    /** File categories this policy applies to */
+    categories?: FILE_CATEGORY[];
+    /** Entity types this policy applies to */
+    entityTypes?: ENTITY_TYPE[];
+    /** Whether files are immutable during retention */
+    immutable?: boolean;
+    /** Whether to auto-delete after retention expires */
+    autoDelete?: boolean;
+}
+/**
+ * Storage compliance rule
+ */
+export interface StorageComplianceRule {
+    /** Rule ID */
+    id: string;
+    /** Rule name */
+    name: string;
+    /** Rule type */
+    type: 'retention' | 'immutability' | 'encryption' | 'access-control';
+    /** Validation function */
+    validate: (metadata: FileMetadata) => Promise<boolean>;
+    /** Enforcement action */
+    enforce?: (metadata: FileMetadata) => Promise<void>;
+}
+/**
+ * Template configuration
+ */
+export interface TemplateConfig {
+    /** Template name */
+    name: string;
+    /** Template source (Handlebars) */
+    source: string;
+    /** Template type */
+    type: 'html' | 'markdown';
+    /** Output format */
+    outputFormat: TEMPLATE_OUTPUT_FORMAT;
+    /** Partials */
+    partials?: Record<string, string>;
+    /** Helpers */
+    helpers?: Record<string, (...args: unknown[]) => string>;
+}
+/**
+ * PDF render options (used by renderer adapters)
+ */
+export interface PDFRenderOptions {
+    /** Page format (alias for pageSize) */
+    format?: 'A4' | 'Letter' | 'Legal';
+    /** Page size (preferred over format) */
+    pageSize?: 'A4' | 'Letter' | 'Legal';
+    /** Page orientation */
+    orientation?: 'portrait' | 'landscape';
+    /** Margins (alias for margin) */
+    margins?: {
+        top?: string;
+        right?: string;
+        bottom?: string;
+        left?: string;
+    };
+    /** Margin (deprecated, use margins) */
+    margin?: {
+        top?: string;
+        right?: string;
+        bottom?: string;
+        left?: string;
+    };
+    /** Header template (HTML) */
+    headerTemplate?: string;
+    /** Footer template (HTML) */
+    footerTemplate?: string;
+    /** Display header/footer */
+    displayHeaderFooter?: boolean;
+    /** Print background colors/images */
+    printBackground?: boolean;
+    /** Scale/zoom level (0.1 to 2) */
+    scale?: number;
+    /** Use CSS page size instead of format */
+    preferCSSPageSize?: boolean;
+    /** PDF metadata */
+    metadata?: {
+        author?: string;
+        subject?: string;
+        keywords?: string;
+        title?: string;
+    };
+    /** CSS styles to inject */
+    css?: string;
+    /** Watermark configuration */
+    watermark?: {
+        enabled: boolean;
+        text?: string;
+        opacity?: number;
+    };
+}
+/**
+ * Storage Excel render options (used by ExcelJS renderer)
+ */
+export interface StorageExcelRenderOptions {
+    /** Sheet name */
+    sheetName?: string;
+    /** Creator name */
+    creator?: string;
+    /** Last modified by */
+    lastModifiedBy?: string;
+    /** Whether to freeze the header row */
+    freezeHeader?: boolean;
+    /** Auto-filter columns */
+    autoFilter?: boolean;
+    /** Column widths (array of widths or 'auto') */
+    columnWidths?: number[] | 'auto';
+    /** Cell styles */
+    styles?: {
+        headerStyle?: Record<string, unknown>;
+        dataStyle?: Record<string, unknown>;
+    };
+    /** Protect worksheet */
+    protection?: {
+        password?: string;
+        options?: Record<string, unknown>;
+    };
+}
+/**
+ * Storage Word document render options (used by DocxTemplater renderer)
+ */
+export interface StorageWordRenderOptions {
+    /** Creator name */
+    creator?: string;
+    /** Title */
+    title?: string;
+    /** Subject */
+    subject?: string;
+    /** Page size */
+    pageSize?: 'A4' | 'Letter' | 'Legal';
+    /** Orientation */
+    orientation?: 'portrait' | 'landscape';
+    /** Margins (in inches) */
+    margins?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    /** Header text */
+    header?: string;
+    /** Footer text */
+    footer?: string;
+    /** Line spacing */
+    lineSpacing?: number;
+    /** Font family */
+    fontFamily?: string;
+    /** Font size */
+    fontSize?: number;
+}
+/**
+ * Template service interface (for loading templates)
+ */
+export interface TemplateService {
+    /** Get template content by path */
+    getTemplate(path: string): Promise<string>;
+    /** Check if template exists */
+    hasTemplate(path: string): Promise<boolean>;
+}
+/**
+ * Storage translation service interface (for loading translation strings)
+ * Separate from TemplateService for Separation of Concerns:
+ * - TemplateService: Loads markdown templates for PDFs (invoices, receipts)
+ * - StorageTranslationService: Loads translation strings for UI/messages (i18n)
+ */
+export interface StorageTranslationService {
+    /** Get translation content by path (e.g., 'en/storage.json') */
+    getTranslation(path: string): Promise<string>;
+    /** Check if translation file exists */
+    hasTranslation(path: string): Promise<boolean>;
+}
+/**
+ * Storage template frontmatter (YAML metadata in markdown for PDFs)
+ */
+export interface StorageTemplateFrontmatter {
+    /** Template name (identifier) */
+    name?: string;
+    /** Display title */
+    title?: string;
+    /** Template description */
+    description?: string;
+    /** Template version */
+    version?: string;
+    /** Locale */
+    locale?: string;
+    /** Category (invoices, receipts, etc.) */
+    category?: string;
+    /** Layout to use (full wrapper template) */
+    layout?: string;
+    /** Header template to use */
+    header?: string;
+    /** Footer template to use */
+    footer?: string;
+    /** Wrapper template to use */
+    wrapper?: string;
+    /** PDF configuration */
+    pageSize?: 'A4' | 'Letter' | 'Legal';
+    orientation?: 'portrait' | 'landscape';
+    margins?: {
+        top?: string;
+        right?: string;
+        bottom?: string;
+        left?: string;
+    };
+    /** PDF metadata */
+    metadata?: {
+        author?: string;
+        subject?: string;
+        keywords?: string;
+    };
+    /** Security & compliance */
+    watermark?: {
+        enabled: boolean;
+        text?: string;
+    };
+    requiresSignature?: boolean;
+    archival?: boolean;
+    expiration?: {
+        enabled: boolean;
+        days?: number;
+    };
+    /** Custom CSS */
+    css?: string;
+    /** Additional custom fields */
+    [key: string]: unknown;
+}
+/**
+ * Storage template render result
+ */
+export interface StorageTemplateRenderResult {
+    /** Rendered HTML */
+    html: string;
+    /** Parsed frontmatter */
+    frontmatter: StorageTemplateFrontmatter;
+    /** CSS to inject */
+    css?: string;
+}
+/**
+ * Storage layout configuration
+ */
+export interface StorageLayoutConfig {
+    /** Layout name */
+    name: string;
+    /** Header template */
+    header?: string;
+    /** Footer template */
+    footer?: string;
+    /** Wrapper template */
+    wrapper?: string;
+}
+/**
+ * Storage template cache entry
+ */
+export interface StorageTemplateCacheEntry {
+    /** Raw template content */
+    content: string;
+    /** Parsed frontmatter */
+    frontmatter: StorageTemplateFrontmatter;
+    /** Template body (without frontmatter) */
+    body: string;
+    /** Cached timestamp */
+    cachedAt: number;
+    /** TTL in milliseconds */
+    ttl: number;
+}
+/**
+ * Storage renderer adapter configuration
+ * Similar to BaseStorageAdapterConfig but for document rendering
+ */
+export interface StorageRendererAdapterConfig {
+    /** Renderer name (unique identifier) */
+    name: string;
+    /** Renderer type */
+    type: STORAGE_RENDERER_TYPE;
+    /** Whether this renderer is enabled */
+    enabled?: boolean;
+    /** Priority (higher = preferred, 0-1000) */
+    priority?: number;
+    /** Supported output formats */
+    supportedFormats?: string[];
+    /** Logger instance */
+    logger?: unknown;
+    /** Custom configuration per renderer */
+    config?: Record<string, unknown>;
+}
+/**
+ * Storage renderer health check result
+ */
+export interface StorageRendererHealthCheck {
+    /** Renderer name */
+    name: string;
+    /** Health status */
+    status: string;
+    /** Last check timestamp */
+    lastCheck: Date;
+    /** Response time in ms */
+    responseTime?: number;
+    /** Error message if unhealthy */
+    error?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Storage render options (generic for all renderers)
+ */
+export interface StorageRenderOptions {
+    /** Output format */
+    format: string;
+    /** Template ID or path */
+    templateId?: string;
+    /** Template data/variables */
+    data?: Record<string, unknown>;
+    /** Locale for multi-language support */
+    locale?: string;
+    /** PDF-specific options (when format === 'pdf') */
+    pdfOptions?: PDFRenderOptions;
+    /** Excel-specific options (when format === 'excel') */
+    excelOptions?: StorageExcelRenderOptions;
+    /** Word-specific options (when format === 'word') */
+    wordOptions?: StorageWordRenderOptions;
+    /** Additional renderer-specific options */
+    options?: Record<string, unknown>;
+}
+/**
+ * Storage render result (generic)
+ */
+export interface StorageRenderResult {
+    /** Rendered content as Buffer */
+    content: globalThis.Buffer;
+    /** Output format */
+    format: string;
+    /** MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    size: number;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Share link configuration
+ */
+export interface ShareLinkConfig {
+    /** Link ID */
+    id: string;
+    /** File ID */
+    fileId: string;
+    /** Password protection */
+    password?: string;
+    /** Expiry timestamp */
+    expiresAt?: Date;
+    /** Maximum download count */
+    maxDownloads?: number;
+    /** Current download count */
+    downloadCount?: number;
+    /** Created by user ID */
+    createdBy: string;
+    /** Created timestamp */
+    createdAt: Date;
+}
+/**
+ * Presigned URL options
+ */
+export interface PresignedUrlOptions {
+    /** Operation type */
+    operation: 'upload' | 'download' | 'get';
+    /** File ID or path */
+    fileId?: string;
+    /** Expiry in seconds */
+    expiresIn: number;
+    /** Content type (for upload) */
+    contentType?: string;
+    /** File size (for upload) */
+    fileSize?: number;
+    /** Metadata (for upload) */
+    metadata?: Partial<FileMetadata>;
+    /** Custom metadata for plugins and tracking */
+    customMetadata?: Record<string, unknown>;
+    /** Skip specific plugins by name for this operation */
+    skipPlugins?: readonly StorageKnownPluginName[];
+    /** Only run these specific plugins for this operation */
+    onlyPlugins?: readonly StorageKnownPluginName[];
+    /** Optional: Bucket name (if known, skips metadata lookup) */
+    bucket?: string;
+    /** Optional: Adapter name (if known, skips routing) */
+    adapter?: string;
+    /** Optional: Bucket purpose (for routing) */
+    bucketPurpose?: BUCKET_PURPOSE;
+}
+/**
+ * Presigned URL result
+ */
+export interface PresignedUrlResult {
+    /** Presigned URL */
+    url: string;
+    /** Upload/download ID */
+    id: string;
+    /** Expiry timestamp */
+    expiresAt: Date;
+    /** Additional fields required for upload */
+    fields?: Record<string, string>;
+}
+/**
+ * S3/R2 multipart upload part
+ * Used for tracking uploaded parts in multipart upload
+ */
+export interface MultipartUploadPart {
+    /** Part number (1-indexed) */
+    PartNumber: number;
+    /** ETag returned by S3/R2 after part upload */
+    ETag: string;
+}
+/**
+ * Bucket deletion result
+ */
+export interface BucketDeletionResult {
+    /** Successfully deleted bucket names */
+    deleted: string[];
+    /** Failed deletions with error details */
+    failed: Array<{
+        bucket: string;
+        error: string;
+    }>;
+}
+/**
+ * Upload progress event
+ */
+export interface UploadProgressEvent {
+    /** File ID */
+    fileId: string;
+    /** Filename */
+    filename: string;
+    /** Bytes uploaded */
+    loaded: number;
+    /** Total bytes */
+    total: number;
+    /** Progress percentage (0-100) */
+    percentage: number;
+    /** Upload speed in bytes/second */
+    speed?: number;
+    /** Estimated time remaining in seconds */
+    estimatedTimeRemaining?: number;
+    /** Current chunk/part number (for chunked uploads) */
+    currentChunk?: number;
+    /** Total number of chunks/parts (for chunked uploads) */
+    totalChunks?: number;
+    /** MIME type */
+    mimeType?: string;
+    /** Entity type */
+    entityType?: ENTITY_TYPE;
+    /** Entity ID */
+    entityId?: string;
+    /** Adapter name */
+    adapter?: string;
+}
+/**
+ * CORS configuration
+ */
+export interface CorsConfig {
+    /** Allowed origins */
+    allowedOrigins: string[];
+    /** Allowed methods */
+    allowedMethods: string[];
+    /** Allowed headers */
+    allowedHeaders?: string[];
+    /** Exposed headers */
+    exposedHeaders?: string[];
+    /** Max age in seconds */
+    maxAge?: number;
+    /** Allow credentials */
+    allowCredentials?: boolean;
+}
+/**
+ * Storage adapter registry configuration
+ */
+export interface StorageAdapterRegistryConfig {
+    /** Logger instance */
+    logger?: LoggerInterface;
+    /** Health check interval in milliseconds */
+    healthCheckInterval?: number;
+    /** Whether to enable automatic health checks */
+    enableAutoHealthCheck?: boolean;
+}
+/**
+ * Storage event manager configuration
+ */
+export interface StorageEventManagerConfig {
+    /** Logger instance */
+    logger?: LoggerInterface;
+    /** Whether to buffer events in bulk operations */
+    enableBuffering?: boolean;
+    /** Buffer flush interval in milliseconds */
+    bufferFlushInterval?: number;
+}
+/**
+ * Storage queue processor configuration
+ */
+export interface StorageQueueProcessorConfig<TEventManager = unknown> {
+    /** Number of concurrent workers (default: 1) */
+    concurrency?: number;
+    /** Poll interval in milliseconds (default: 100) */
+    interval?: number;
+    /** Maximum retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Event manager for emitting operation events */
+    eventManager?: TEventManager;
+    /** Logger instance */
+    logger?: LoggerInterface;
+}
+/**
+ * Storage compliance manager configuration
+ */
+export interface StorageComplianceManagerConfig {
+    /** Compliance configuration */
+    compliance: StorageComplianceConfig;
+    /** Logger instance */
+    logger?: LoggerInterface;
+}
+/**
+ * Storage renderer registry configuration
+ */
+export interface StorageRendererRegistryConfig {
+    /** Logger instance */
+    logger?: LoggerInterface;
+    /** Auto health check interval (ms, 0 to disable) */
+    healthCheckInterval?: number;
+}
+/**
+ * Storage layout engine configuration
+ */
+export interface StorageLayoutEngineConfig {
+    /** Base path for layouts (default: ./templates/layouts) */
+    basePath?: string;
+    /** Default locale (default: 'en') */
+    defaultLocale?: string;
+    /** Enable layout caching (default: true) */
+    cacheEnabled?: boolean;
+    /** Cache TTL in milliseconds (default: 300000 = 5 minutes) */
+    cacheTTL?: number;
+    /** Logger instance */
+    logger?: LoggerInterface;
+}
+/**
+ * Storage applied layout result
+ */
+export interface StorageAppliedLayout {
+    /** Content with layout applied */
+    html: string;
+    /** Layout name used */
+    layoutName: string;
+    /** Locale used */
+    locale: string;
+}
+/**
+ * Storage translation service configuration
+ */
+export interface StorageTranslationServiceConfig {
+    /** Base path for translations (default: process.cwd() + '/translations') */
+    basePath?: string;
+    /** Logger instance */
+    logger?: LoggerInterface;
+}
+/**
+ * File system template service configuration
+ */
+export interface FileSystemTemplateServiceConfig {
+    /** Base directory for templates */
+    baseDir: string;
+    /** Whether to watch for file changes */
+    watch?: boolean;
+    /** Logger instance */
+    logger?: LoggerInterface;
+}
+/**
+ * Storage file system template service configuration
+ */
+export interface StorageFileSystemTemplateServiceConfig {
+    /** Base path for templates (default: process.cwd() + '/templates') */
+    basePath?: string;
+    /** Logger instance */
+    logger?: LoggerInterface;
+}
+/**
+ * Storage DocxTemplater renderer configuration
+ */
+export interface StorageDocxTemplaterRendererConfig extends StorageRendererAdapterConfig {
+    config?: {
+        /** Base path for .docx templates */
+        templateBasePath?: string;
+        /** Default Word options */
+        defaultOptions?: Record<string, unknown>;
+    };
+}
+/**
+ * Storage Word document data structure
+ */
+export interface StorageWordDocumentData {
+    /** Template path (relative to templateBasePath or absolute) */
+    templatePath?: string;
+    /** Template data (variables to replace) */
+    data: Record<string, unknown>;
+    /** Document metadata */
+    metadata?: {
+        creator?: string;
+        title?: string;
+        subject?: string;
+    };
+}
+/**
+ * Storage Playwright renderer configuration
+ */
+export interface StoragePlaywrightRendererConfig extends StorageRendererAdapterConfig {
+    config?: {
+        /** Browser type to use */
+        browserType?: 'chromium' | 'firefox' | 'webkit';
+        /** Launch options */
+        launchOptions?: Record<string, unknown>;
+        /** Keep browser alive between renders */
+        keepAlive?: boolean;
+        /** Default timeout for page loads (ms) */
+        timeout?: number;
+    };
+}
+/**
+ * Storage PDFKit renderer configuration
+ */
+export interface StoragePDFKitRendererConfig extends StorageRendererAdapterConfig {
+    config?: {
+        /** Default PDF options */
+        defaultOptions?: {
+            size?: string | [number, number];
+            margin?: number;
+            bufferPages?: boolean;
+        };
+    };
+}
+/**
+ * Storage PDFKit document data structure
+ */
+export interface StoragePDFKitDocumentData {
+    /** Document title */
+    title?: string;
+    /** Document content (array of sections) */
+    content: Array<{
+        type: 'text' | 'heading' | 'image' | 'line' | 'table';
+        data: unknown;
+        options?: Record<string, unknown>;
+    }>;
+    /** PDF metadata */
+    metadata?: {
+        author?: string;
+        subject?: string;
+        keywords?: string;
+    };
+}
+/**
+ * Storage ExcelJS renderer configuration
+ */
+export interface StorageExcelJSRendererConfig extends StorageRendererAdapterConfig {
+    config?: {
+        /** Default Excel options */
+        defaultOptions?: Record<string, unknown>;
+    };
+}
+/**
+ * Storage Excel data structure
+ */
+export interface StorageExcelData {
+    /** Worksheet data */
+    sheets: Array<{
+        /** Sheet name */
+        name: string;
+        /** Table data (array of rows) */
+        data: Array<Record<string, unknown>>;
+        /** Column configuration */
+        columns?: Array<{
+            header: string;
+            key: string;
+            width?: number;
+        }>;
+    }>;
+    /** Workbook metadata */
+    metadata?: {
+        creator?: string;
+        lastModifiedBy?: string;
+        created?: Date;
+        modified?: Date;
+    };
+}
+/**
+ * Storage Puppeteer renderer configuration
+ */
+export interface StoragePuppeteerRendererConfig extends StorageRendererAdapterConfig {
+    config?: {
+        /** Puppeteer launch options */
+        launchOptions?: Record<string, unknown>;
+        /** Keep browser alive between renders (better performance) */
+        keepAlive?: boolean;
+        /** Default timeout for page loads (ms) */
+        timeout?: number;
+    };
+}
+/**
+ * Storage media processing webhook configuration
+ */
+export interface StorageMediaProcessingWebhookConfig extends StorageBaseWebhookAdapterConfig {
+    /** Provider name (e.g., 'aws-mediaconvert', 'mux', 'cloudinary') */
+    providerName?: string;
+    /** Whether to enable strict validation */
+    strictValidation?: boolean;
+}
+/**
+ * Storage retry options for operations
+ */
+export interface StorageRetryOptions {
+    /** Maximum number of retry attempts */
+    maxAttempts: number;
+    /** Initial delay in milliseconds */
+    initialDelay: number;
+    /** Maximum delay in milliseconds */
+    maxDelay?: number;
+    /** Backoff multiplier */
+    backoffMultiplier?: number;
+    /** Callback function to call on retry */
+    onRetry?: (attempt: number, error: Error) => void;
+}
+/**
+ * Storage hash-based path generation options
+ */
+export interface StorageHashPathOptions {
+    /** Hash algorithm to use */
+    algorithm?: 'md5' | 'sha1' | 'sha256';
+    /** Number of directory levels */
+    levels?: number;
+    /** Characters per level */
+    charsPerLevel?: number;
+    /** File extension */
+    extension?: string;
+    /** Path prefix */
+    prefix?: string;
+}
+/**
+ * Storage entity-based path generation options
+ */
+export interface StorageEntityPathOptions {
+    /** Entity type */
+    entityType: ENTITY_TYPE;
+    /** Entity ID */
+    entityId: string;
+    /** File category */
+    category: FILE_CATEGORY;
+    /** Filename */
+    filename: string;
+    /** Whether to include timestamp */
+    includeTimestamp?: boolean;
+    /** Additional path segments */
+    segments?: string[];
+}
+/**
+ * Storage date-based path generation options
+ */
+export interface StorageDatePathOptions {
+    /** File category */
+    category: FILE_CATEGORY;
+    /** Filename */
+    filename: string;
+    /** Base directory */
+    baseDir?: string;
+    /** Whether to include UUID */
+    includeUuid?: boolean;
+    /** Date to use for path */
+    date?: Date;
+    /** Date format pattern */
+    format?: string;
+}
+/**
+ * Storage category-based path generation options
+ */
+export interface StorageCategoryPathOptions {
+    /** File category */
+    category: FILE_CATEGORY;
+    /** Filename */
+    filename: string;
+    /** Entity ID */
+    entityId?: string;
+    /** Additional path segments */
+    segments?: string[];
+}
+/**
+ * Storage flat path generation options
+ */
+export interface StorageFlatPathOptions {
+    /** Filename */
+    filename: string;
+    /** Base directory */
+    baseDir?: string;
+    /** Whether to include UUID */
+    includeUuid?: boolean;
+    /** Optional prefix */
+    prefix?: string;
+}
+/**
+ * Storage template variables for path generation
+ */
+export interface StorageTemplateVariables {
+    /** Variable values */
+    [key: string]: string | number | undefined;
+}
+/**
+ * Storage signed URL generation options
+ */
+export interface StorageSignedUrlOptions {
+    /** Expiration time in seconds */
+    expiresIn: number;
+    /** Optional IP address restriction */
+    ipAddress?: string;
+    /** Optional permissions (default: ['read']) */
+    permissions?: Array<'read' | 'write' | 'delete'>;
+    /** Hash algorithm for HMAC signature (default: 'sha256') */
+    algorithm?: 'sha256' | 'sha384' | 'sha512';
+    /** Content type */
+    contentType?: string;
+    /** Content disposition */
+    contentDisposition?: string;
+    /** Additional metadata */
+    metadata?: Record<string, string>;
+}
+/**
+ * Storage URL signature verification result
+ */
+export interface StorageVerificationResult {
+    /** Whether the signature is valid */
+    valid: boolean;
+    /** Error message if invalid */
+    error?: string;
+    /** Extracted permissions if valid */
+    permissions?: Array<'read' | 'write' | 'delete'>;
+    /** Expiration timestamp if valid */
+    expiresAt?: number;
+}
+/**
+ * Storage bucket information
+ */
+export interface StorageBucketInfo {
+    /** Bucket name */
+    name: string;
+    /** Bucket ID (if applicable) */
+    id?: string;
+    /** Whether bucket is public */
+    public: boolean;
+    /** Creation date */
+    createdAt: Date;
+    /** Last updated date */
+    updatedAt?: Date;
+    /** File size limit (bytes) */
+    fileSizeLimit?: number;
+    /** Allowed MIME types */
+    allowedMimeTypes?: string[];
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Storage list buckets result
+ */
+export interface StorageListBucketsResult {
+    /** List of buckets */
+    buckets: StorageBucketInfo[];
+    /** Total count */
+    count: number;
+}
+/**
+ * Storage update bucket parameters
+ */
+export interface StorageUpdateBucketParams {
+    /** Bucket name */
+    bucketName: string;
+    /** Whether bucket is public */
+    public?: boolean;
+    /** File size limit (bytes) */
+    fileSizeLimit?: number;
+    /** Allowed MIME types */
+    allowedMimeTypes?: string[];
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Storage list files parameters
+ */
+export interface StorageListFilesParams {
+    /** Bucket name */
+    bucket: string;
+    /** Path prefix to filter by */
+    prefix?: string;
+    /** Maximum number of files to return */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+    /** Sort field */
+    sortBy?: 'name' | 'size' | 'createdAt' | 'updatedAt';
+    /** Sort direction */
+    sortOrder?: 'asc' | 'desc';
+    /** Search query */
+    search?: string;
+}
+/**
+ * Storage file info for list results
+ */
+export interface StorageFileInfo {
+    /** File ID/path */
+    id: string;
+    /** File name */
+    name: string;
+    /** File size in bytes */
+    size: number;
+    /** MIME type */
+    mimeType: string;
+    /** Creation date */
+    createdAt: Date;
+    /** Last updated date */
+    updatedAt?: Date;
+    /** File metadata */
+    metadata?: Record<string, unknown>;
+    /** Public URL (if public) */
+    publicUrl?: string;
+}
+/**
+ * Storage list files result
+ */
+export interface StorageListFilesResult {
+    /** List of files */
+    files: StorageFileInfo[];
+    /** Total count */
+    count: number;
+    /** Has more files */
+    hasMore: boolean;
+    /** Next offset for pagination */
+    nextOffset?: number;
+}
+/**
+ * Storage move file parameters
+ */
+export interface StorageMoveFileParams {
+    /** Source bucket */
+    sourceBucket: string;
+    /** Source file path */
+    sourcePath: string;
+    /** Destination bucket */
+    destinationBucket: string;
+    /** Destination file path */
+    destinationPath: string;
+    /** Optional: Source adapter name */
+    sourceAdapter?: string;
+    /** Optional: Destination adapter name */
+    destinationAdapter?: string;
+    /** Skip specific plugins by name for this operation (e.g., ['virus-scanner', 'cdn-invalidator']) */
+    skipPlugins?: readonly StorageKnownPluginName[];
+    /** Only run these specific plugins for this operation (e.g., ['metadata-enricher']) */
+    onlyPlugins?: readonly StorageKnownPluginName[];
+    /** Custom metadata for plugins and tracking */
+    customMetadata?: Record<string, unknown>;
+    /** Bypass retention policy checks (requires admin privileges) */
+    bypassRetention?: boolean;
+}
+/**
+ * Storage copy file parameters
+ */
+export interface StorageCopyFileParams {
+    /** Source bucket */
+    sourceBucket: string;
+    /** Source file path */
+    sourcePath: string;
+    /** Destination bucket */
+    destinationBucket: string;
+    /** Destination file path */
+    destinationPath: string;
+    /** Optional: Source adapter name */
+    sourceAdapter?: string;
+    /** Optional: Destination adapter name */
+    destinationAdapter?: string;
+    /** Skip specific plugins by name for this operation (e.g., ['virus-scanner', 'cdn-invalidator']) */
+    skipPlugins?: readonly StorageKnownPluginName[];
+    /** Only run these specific plugins for this operation (e.g., ['metadata-enricher']) */
+    onlyPlugins?: readonly StorageKnownPluginName[];
+    /** Custom metadata for plugins and tracking */
+    customMetadata?: Record<string, unknown>;
+}
+/**
+ * Storage replace file parameters
+ */
+export interface StorageReplaceFileParams {
+    /** File ID or path to replace */
+    fileId: string;
+    /** New file buffer */
+    file: globalThis.Buffer | globalThis.NodeJS.ReadableStream;
+    /** Bucket name */
+    bucket?: string;
+    /** Adapter name */
+    adapter?: string;
+    /** Optional: New MIME type */
+    mimeType?: string;
+    /** Optional: Update metadata */
+    metadata?: Record<string, unknown>;
+    /** Skip specific plugins by name for this operation (e.g., ['virus-scanner', 'cdn-invalidator']) */
+    skipPlugins?: readonly StorageKnownPluginName[];
+    /** Only run these specific plugins for this operation (e.g., ['metadata-enricher']) */
+    onlyPlugins?: readonly StorageKnownPluginName[];
+    /** Custom metadata for plugins and tracking */
+    customMetadata?: Record<string, unknown>;
+    /** Bypass retention policy checks (requires admin privileges) */
+    bypassRetention?: boolean;
+}
+/**
+ * Storage signed upload URL parameters
+ */
+export interface StorageSignedUploadUrlParams {
+    /** Bucket name */
+    bucket: string;
+    /** File path */
+    path: string;
+    /** Expiry in seconds */
+    expiresIn?: number;
+    /** Content type */
+    contentType?: string;
+    /** File size limit */
+    fileSizeLimit?: number;
+    /** Optional: Adapter name */
+    adapter?: string;
+    /** Upsert (replace if exists) - WARNING: Bypasses immutability and retention checks */
+    upsert?: boolean;
+    /** User ID for audit trail (REQUIRED for compliance) */
+    userId?: string;
+    /** Additional metadata for compliance tracking */
+    metadata?: Record<string, unknown>;
+    /** Entity type (for compliance classification) */
+    entityType?: string;
+    /** Entity ID (for compliance classification) */
+    entityId?: string;
+}
+/**
+ * Storage signed upload URL result
+ */
+export interface StorageSignedUploadUrlResult {
+    /** Signed URL for upload */
+    url: string;
+    /** Upload token/ID */
+    token: string;
+    /** Expiry timestamp */
+    expiresAt: Date;
+    /** Additional fields for upload (e.g., form fields for S3) */
+    fields?: Record<string, string>;
+}
+/**
+ * Storage public URL parameters
+ */
+export interface StoragePublicUrlParams {
+    /** Bucket name */
+    bucket: string;
+    /** File path */
+    path: string;
+    /** Optional: Adapter name */
+    adapter?: string;
+    /** Optional: Download filename (for Content-Disposition) */
+    download?: string;
+}
+/**
+ * Storage bucket deletion result for batch operations
+ */
+export interface StorageBucketDeletionResult {
+    /** Whether the bucket has more objects to delete */
+    hasMore: boolean;
+    /** Continuation token for next batch */
+    nextToken: string | undefined;
+}
+/**
+ * Storage chunk extraction result
+ */
+export interface StorageChunkExtractionResult {
+    /** Extracted chunk buffer */
+    chunk: globalThis.Buffer;
+    /** End position in original buffer */
+    end: number;
+}
+/**
+ * Storage chunk upload part result
+ */
+export interface StorageChunkUploadPartResult {
+    /** ETag from upload */
+    ETag: string;
+}