nucleus-core-ts 0.8.0

package/dist/src/Managers/Dapr/utils.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Utility functions for the Dapr manager
+ */
+/** biome-ignore-all lint/suspicious/noExplicitAny: <> */
+import type { DaprLogger } from "./types";
+/**
+ * Default logger implementation
+ */
+export declare const createDefaultLogger: () => DaprLogger;
+/**
+ * Create a no-op logger that doesn't log anything
+ */
+export declare const createNoopLogger: () => DaprLogger;
+/**
+ * Retry a function with exponential backoff
+ */
+export declare const retryWithBackoff: <T>(fn: () => Promise<T>, options?: {
+    retryCount?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    jitter?: number;
+    shouldRetry?: (error: unknown) => boolean;
+}) => Promise<T>;
+/**
+ * Execute a function with a timeout
+ */
+export declare const withTimeout: <T>(fn: () => Promise<T>, timeoutMs: number, errorMessage?: string) => Promise<T>;
+/**
+ * Validate that required parameters are provided
+ */
+export declare const validateRequired: <T extends Record<string, unknown>>(params: T, requiredKeys: Array<keyof T>, entityName: string) => void;
+/**
+ * Safely parse JSON string
+ */
+export declare const safeJsonParse: <T>(jsonString: string, defaultValue: T) => T;
+/**
+ * Create a memoized function that caches results
+ */
+export declare const memoize: <T extends (...args: any[]) => any>(fn: T, getKey?: (...args: Parameters<T>) => string) => T;
+/**
+ * Debounce a function
+ */
+export declare const debounce: <T extends (...args: any[]) => any>(fn: T, delayMs: number) => ((...args: Parameters<T>) => void);
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/Managers/File/atomic.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Bun File Manager - Atomic Operations
+ * Safe atomic file operations with backup and rollback support
+ */
+import type { AtomicOperationData, AtomicOperationResult, AtomicWriteOptions, BackupOptions, FileData } from "./types";
+/**
+ * Default atomic operation configuration
+ */
+export declare const DEFAULT_ATOMIC_CONFIG: {
+    readonly tempSuffix: ".tmp";
+    readonly backup: false;
+    readonly sync: true;
+    readonly timestamp: true;
+};
+/**
+ * Generates unique temporary file path
+ */
+export declare const generateTempPath: (originalPath: string, suffix?: string) => string;
+/**
+ * Generates backup file path with optional timestamp
+ */
+export declare const generateBackupPath: (originalPath: string, backupDir?: string, useTimestamp?: boolean) => string;
+/**
+ * Atomic write operation - writes to temp file then renames
+ */
+export declare const atomicWrite: ({ path, data, tempSuffix, backup, sync, }: AtomicWriteOptions) => Promise<AtomicOperationResult>;
+/**
+ * Atomic JSON write operation
+ */
+export declare const atomicJsonWrite: (path: string, data: Record<string, string | number | boolean | null>, options?: Partial<AtomicWriteOptions>) => Promise<AtomicOperationResult>;
+/**
+ * Creates backup of existing file
+ */
+export declare const createBackup: ({ sourcePath, backupDir, keepOriginal, timestamp, }: BackupOptions) => Promise<string>;
+/**
+ * Restores file from backup
+ */
+export declare const restoreFromBackup: (backupPath: string, targetPath: string, deleteBackup?: boolean) => Promise<boolean>;
+/**
+ * Safe file update with automatic rollback on error
+ */
+export declare const safeUpdate: (path: string, updateFunction: (currentData: string) => Promise<FileData> | FileData, options?: Partial<AtomicWriteOptions>) => Promise<AtomicOperationResult>;
+/**
+ * Batch atomic operations with rollback support
+ */
+export declare const batchAtomicWrite: (operations: ReadonlyArray<AtomicWriteOptions>) => Promise<{
+    successful: ReadonlyArray<AtomicOperationData>;
+    failed: ReadonlyArray<{
+        operation: AtomicWriteOptions;
+        error: Error;
+    }>;
+}>;
+/**
+ * Cleans up temporary and backup files
+ */
+export declare const cleanupFiles: (paths: ReadonlyArray<string>) => Promise<{
+    cleaned: ReadonlyArray<string>;
+    failed: ReadonlyArray<string>;
+}>;
+/**
+ * Verifies atomic operation integrity
+ */
+export declare const verifyAtomicWrite: (path: string, expectedSize?: number, checksumFunction?: (data: Uint8Array) => string, expectedChecksum?: string) => Promise<boolean>;
+//# sourceMappingURL=atomic.d.ts.map

package/dist/src/Managers/File/core.d.ts

@@ -0,0 +1,188 @@
+/**
+ * Bun File Manager - Core Singleton Class
+ * Type-safe CRUD operations using Bun's optimized APIs
+ */
+/** biome-ignore-all lint/correctness/noUnusedPrivateClassMembers: <> */
+import { type PERMISSION_MODES } from "./permissions";
+import type { AtomicOperationData, AtomicOperationResult, AtomicWriteOptions, BackupOptions, BulkDeleteResult, ConfigValidationResult, CreateOperationResult, DeleteOperationResult, DirectoryOptions, FileCreateOptions, FileInfo, FileManagerConfig, FilePermissionMode, FileReadOptions, FileSinkOptions, FileUpdateOptions, JsonData, PartialFileManagerConfig, PermissionInfo, PermissionOperationResult, PermissionOptions, ReadOperationResult, StreamChunk, StreamOperationResult, StreamWriter, UpdateOperationResult, UtilityOperationResult } from "./types";
+export declare class BunFileManager {
+    private static instance;
+    private readonly config;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): BunFileManager;
+    /**
+     * Create new file with automatic directory creation
+     */
+    createFile({ dir, name, data, options, }: FileCreateOptions): CreateOperationResult;
+    /**
+     * Create JSON file with automatic formatting
+     */
+    createJsonFile(dir: string, name: string, data: JsonData): CreateOperationResult;
+    /**
+     * Create directory with recursive option
+     */
+    createDirectory({ path }: DirectoryOptions): Promise<void>;
+    /**
+     * Read file in specified format
+     */
+    readFile<T = string>({ path, format, }: FileReadOptions): ReadOperationResult<T>;
+    /**
+     * Read JSON file with type safety
+     */
+    readJsonFile<T extends JsonData = JsonData>(path: string): ReadOperationResult<T>;
+    /**
+     * Get comprehensive file information
+     */
+    getFileInfo(path: string): ReadOperationResult<FileInfo>;
+    /**
+     * Read directory contents
+     */
+    readDirectory({ path, recursive, }: DirectoryOptions): ReadOperationResult<ReadonlyArray<string>>;
+    /**
+     * Get files by extension from directory
+     */
+    getFilesByExtension(dir: string, extension: string): ReadOperationResult<ReadonlyArray<string>>;
+    /**
+     * Update file with overwrite or append mode
+     */
+    updateFile({ path, data, mode, }: FileUpdateOptions): UpdateOperationResult;
+    /**
+     * Update JSON file with merge option
+     */
+    updateJsonFile(path: string, data: JsonData, merge?: boolean): UpdateOperationResult;
+    /**
+     * Append data to existing file
+     */
+    appendToFile(path: string, data: string): UpdateOperationResult;
+    /**
+     * Delete single file
+     */
+    deleteFile(path: string): DeleteOperationResult;
+    /**
+     * Delete directory
+     */
+    deleteDirectory({ path, recursive, }: DirectoryOptions): DeleteOperationResult;
+    /**
+     * Delete multiple files with result tracking
+     */
+    deleteFiles(paths: ReadonlyArray<string>): ReadOperationResult<BulkDeleteResult>;
+    /**
+     * Check if file exists
+     */
+    exists(path: string): UtilityOperationResult;
+    /**
+     * Copy file to new location
+     */
+    copyFile(sourcePath: string, destinationPath: string): UtilityOperationResult<number>;
+    /**
+     * Move file to new location
+     */
+    moveFile(sourcePath: string, destinationPath: string): DeleteOperationResult;
+    /**
+     * Get formatted file size
+     */
+    getFormattedFileSize(bytes: number): string;
+    /**
+     * Get configuration
+     */
+    getConfig(): FileManagerConfig;
+    /**
+     * Update configuration with validation
+     */
+    updateConfig(newConfig: PartialFileManagerConfig): ConfigValidationResult;
+    /**
+     * Validate configuration without applying
+     */
+    validateConfiguration(config: PartialFileManagerConfig): ConfigValidationResult;
+    /**
+     * Create file writer for streaming operations
+     */
+    createStreamWriter(path: string, options?: FileSinkOptions): Promise<StreamWriter>;
+    /**
+     * Write data using streaming (memory efficient for large data)
+     */
+    writeStream(path: string, chunks: ReadonlyArray<StreamChunk>, options?: FileSinkOptions): StreamOperationResult;
+    /**
+     * Append data using streaming
+     */
+    appendStream(path: string, chunks: ReadonlyArray<StreamChunk>, options?: FileSinkOptions): StreamOperationResult;
+    /**
+     * Copy file using streaming (efficient for large files)
+     */
+    copyFileStream(sourcePath: string, destinationPath: string, options?: FileSinkOptions): StreamOperationResult;
+    /**
+     * Read file in chunks using streaming
+     */
+    readFileStream(path: string, chunkProcessor: (chunk: Uint8Array) => Promise<void>): Promise<void>;
+    /**
+     * Set file permissions using octal mode
+     */
+    setPermissions(path: string, mode: FilePermissionMode): PermissionOperationResult;
+    /**
+     * Set permissions using options
+     */
+    setPermissionsAdvanced(options: PermissionOptions): PermissionOperationResult;
+    /**
+     * Get detailed file permission information
+     */
+    getPermissions(path: string): Promise<PermissionInfo>;
+    /**
+     * Check if file has specific permissions
+     */
+    checkPermissions(path: string, requiredMode: FilePermissionMode): Promise<boolean>;
+    /**
+     * Make file readable by owner
+     */
+    makeFileReadable(path: string): PermissionOperationResult;
+    /**
+     * Make file writable by owner
+     */
+    makeFileWritable(path: string): PermissionOperationResult;
+    /**
+     * Make file executable by owner
+     */
+    makeFileExecutable(path: string): PermissionOperationResult;
+    /**
+     * Make file read-only (remove write permissions)
+     */
+    makeFileReadOnly(path: string): PermissionOperationResult;
+    /**
+     * Set common permission patterns
+     */
+    setCommonPermission(path: string, pattern: keyof typeof PERMISSION_MODES): PermissionOperationResult;
+    /**
+     * Atomic file write (crash-safe)
+     */
+    atomicWrite(options: AtomicWriteOptions): AtomicOperationResult;
+    /**
+     * Atomic JSON file write
+     */
+    atomicJsonWrite(path: string, data: Record<string, string | number | boolean | null>, options?: Partial<AtomicWriteOptions>): AtomicOperationResult;
+    /**
+     * Create backup of file
+     */
+    createFileBackup(options: BackupOptions): Promise<string>;
+    /**
+     * Restore file from backup
+     */
+    restoreFileFromBackup(backupPath: string, targetPath: string, deleteBackup?: boolean): Promise<boolean>;
+    /**
+     * Safe file update with automatic rollback
+     */
+    safeFileUpdate(path: string, updateFunction: (currentData: string) => Promise<string> | string, options?: Partial<AtomicWriteOptions>): AtomicOperationResult;
+    /**
+     * Batch atomic operations
+     */
+    batchAtomicOperations(operations: ReadonlyArray<AtomicWriteOptions>): Promise<{
+        successful: ReadonlyArray<AtomicOperationData>;
+        failed: ReadonlyArray<{
+            operation: AtomicWriteOptions;
+            error: Error;
+        }>;
+    }>;
+}
+export default BunFileManager;
+//# sourceMappingURL=core.d.ts.map

package/dist/src/Managers/File/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bun File Manager - Main Export
+ * Clean exports for type-safe file operations
+ */
+export { BunFileManager } from "./core";
+export type { BulkDeleteResult, BulkOperationFunction, CreateOperationResult, DeleteOperationResult, DirectoryOptions, FileCreateOptions, FileData, FileFormat, FileInfo, FileManagerConfig, FileManagerError, FileOperationResult, FileReadOptions, FileSizeUnit, FileUpdateMode, FileUpdateOptions, JsonData, JsonPrimitive, ReadOperationResult, UpdateOperationResult, UtilityOperationResult, } from "./types";
+export { createFileManagerError, DEFAULT_CONFIG, ensureDirectoryExists, ensureFileExtension, executeBulkOperation, extractDirectoryPath, extractFailedResults, extractSuccessfulResults, FILE_SIZE_UNITS, formatFileSize, isValidJson, resolvePath, safeJsonParse, safeJsonStringify, validateFileExtension, } from "./utils";
+import { BunFileManager } from "./core";
+/**
+ * Ready-to-use singleton instance
+ * Use this for immediate file operations
+ */
+export declare const fileManager: BunFileManager;
+/**
+ * Default export - singleton instance
+ */
+export default fileManager;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/Managers/File/permissions.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Bun File Manager - Permissions Operations
+ * Cross-platform file permissions management
+ */
+import type { FilePermissionMode, PermissionInfo, PermissionOperationResult, PermissionOptions } from "./types";
+/**
+ * Common permission modes as constants
+ */
+export declare const PERMISSION_MODES: {
+    readonly OWNER_READ_WRITE: 384;
+    readonly OWNER_ALL: 448;
+    readonly GROUP_READ: 416;
+    readonly GROUP_READ_WRITE: 432;
+    readonly ALL_READ: 420;
+    readonly ALL_READ_WRITE: 438;
+    readonly ALL_READ_EXECUTE: 493;
+    readonly ALL_FULL: 511;
+    readonly READ_ONLY: 292;
+    readonly EXECUTABLE: 493;
+};
+/**
+ * Sets file permissions using octal mode
+ */
+export declare const setFilePermissions: (path: string, mode: FilePermissionMode) => PermissionOperationResult;
+/**
+ * Sets file permissions using permission options
+ */
+export declare const setPermissions: ({ path, mode, recursive, }: PermissionOptions) => PermissionOperationResult;
+/**
+ * Gets detailed file permission information
+ */
+export declare const getFilePermissions: (path: string) => Promise<PermissionInfo>;
+/**
+ * Checks if file has specific permissions
+ */
+export declare const hasPermissions: (path: string, requiredMode: FilePermissionMode) => Promise<boolean>;
+/**
+ * Makes file readable by owner
+ */
+export declare const makeReadable: (path: string) => PermissionOperationResult;
+/**
+ * Makes file writable by owner
+ */
+export declare const makeWritable: (path: string) => PermissionOperationResult;
+/**
+ * Makes file executable by owner
+ */
+export declare const makeExecutable: (path: string) => PermissionOperationResult;
+/**
+ * Removes write permissions (makes read-only)
+ */
+export declare const makeReadOnly: (path: string) => PermissionOperationResult;
+/**
+ * Sets common permission patterns
+ */
+export declare const setCommonPermissions: (path: string, pattern: keyof typeof PERMISSION_MODES) => PermissionOperationResult;
+/**
+ * Bulk permission operations
+ */
+export declare const setBulkPermissions: (paths: ReadonlyArray<string>, mode: FilePermissionMode) => Promise<{
+    success: string[];
+    failed: string[];
+}>;
+/**
+ * Creates permission mode from readable format
+ */
+export declare const createPermissionFromReadable: (ownerRead: boolean, ownerWrite: boolean, ownerExecute: boolean, groupRead?: boolean, groupWrite?: boolean, groupExecute?: boolean, othersRead?: boolean, othersWrite?: boolean, othersExecute?: boolean) => FilePermissionMode;
+/**
+ * Formats permission mode as human-readable string
+ */
+export declare const formatPermissions: (mode: FilePermissionMode) => string;
+//# sourceMappingURL=permissions.d.ts.map

package/dist/src/Managers/File/streaming.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Bun File Manager - Streaming Operations
+ * FileSink based streaming for large file operations
+ */
+import type { FileSinkOptions, StreamChunk, StreamOperationResult, StreamWriter } from "./types";
+/**
+ * Default streaming configuration
+ */
+export declare const DEFAULT_STREAM_CONFIG: Required<FileSinkOptions>;
+/**
+ * Creates a file writer using Bun's FileSink
+ */
+export declare const createFileWriter: (path: string, options?: FileSinkOptions) => Promise<StreamWriter>;
+/**
+ * Writes data to file using streaming
+ */
+export declare const writeStream: (path: string, chunks: ReadonlyArray<StreamChunk>, options?: FileSinkOptions) => StreamOperationResult;
+/**
+ * Appends data to file using streaming
+ */
+export declare const appendStream: (path: string, chunks: ReadonlyArray<StreamChunk>, options?: FileSinkOptions) => StreamOperationResult;
+/**
+ * Copies file using streaming (efficient for large files)
+ */
+export declare const copyFileStream: (sourcePath: string, destinationPath: string, options?: FileSinkOptions) => StreamOperationResult;
+/**
+ * Reads file in chunks using streaming
+ */
+export declare const readFileStream: (path: string, chunkProcessor: (chunk: Uint8Array) => Promise<void>) => Promise<void>;
+//# sourceMappingURL=streaming.d.ts.map

package/dist/src/Managers/File/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Bun File Manager - Type Definitions
+ * Fully type-safe definitions with dynamic type construction
+ */
+export type FileData = string | Blob | ArrayBuffer | Uint8Array;
+export type FileFormat = "text" | "json" | "buffer" | "bytes" | "stream";
+export type FileUpdateMode = "overwrite" | "append";
+export type FileCreateOptions = {
+    readonly dir: string;
+    readonly name: string;
+    readonly data: FileData;
+    readonly options?: {
+        readonly type?: string;
+        readonly createDir?: boolean;
+    };
+};
+export type FileReadOptions = {
+    readonly path: string;
+    readonly format?: FileFormat;
+};
+export type FileUpdateOptions = {
+    readonly path: string;
+    readonly data: FileData;
+    readonly mode?: FileUpdateMode;
+};
+export type DirectoryOptions = {
+    readonly path: string;
+    readonly recursive?: boolean;
+};
+export type FileInfo = {
+    readonly name: string;
+    readonly path: string;
+    readonly size: number;
+    readonly type: string;
+    readonly exists: boolean;
+    readonly extension: string;
+    readonly createdAt?: Date;
+    readonly modifiedAt?: Date;
+};
+export type BulkDeleteResult = {
+    readonly success: ReadonlyArray<string>;
+    readonly failed: ReadonlyArray<string>;
+};
+export type FileOperationResult<T> = {
+    readonly success: boolean;
+    readonly data?: T;
+    readonly error?: string;
+};
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonData = JsonPrimitive | object;
+export type BulkOperationFunction<T, R> = (item: T) => Promise<R>;
+export type FileSizeUnit = "B" | "KB" | "MB" | "GB" | "TB";
+export type FileManagerConfig = {
+    readonly defaultEncoding: string;
+    readonly defaultCreateDir: boolean;
+    readonly defaultRecursive: boolean;
+    readonly maxConcurrency: number;
+};
+export type FileManagerError = {
+    readonly code: string;
+    readonly message: string;
+    readonly path?: string;
+    readonly operation: string;
+};
+export type CreateOperationResult = Promise<number>;
+export type ReadOperationResult<T = string> = Promise<T>;
+export type UpdateOperationResult = Promise<number>;
+export type DeleteOperationResult = Promise<boolean>;
+export type UtilityOperationResult<T = boolean> = Promise<T>;
+export type FileSinkOptions = {
+    readonly highWaterMark?: number;
+    readonly autoFlush?: boolean;
+    readonly closeOnEnd?: boolean;
+};
+export type StreamChunk = string | ArrayBuffer | Uint8Array;
+export type StreamOperationResult = Promise<number>;
+export type StreamWriter = {
+    readonly write: (chunk: StreamChunk) => number | Promise<number>;
+    readonly flush: () => number | Promise<number>;
+    readonly end: (error?: Error) => number | Promise<number>;
+    readonly ref: () => void;
+    readonly unref: () => void;
+};
+export type FilePermissionMode = number;
+export type PermissionOptions = {
+    readonly path: string;
+    readonly mode: FilePermissionMode;
+    readonly recursive?: boolean;
+};
+export type PermissionInfo = {
+    readonly path: string;
+    readonly mode: FilePermissionMode;
+    readonly owner: {
+        readonly read: boolean;
+        readonly write: boolean;
+        readonly execute: boolean;
+    };
+    readonly group: {
+        readonly read: boolean;
+        readonly write: boolean;
+        readonly execute: boolean;
+    };
+    readonly others: {
+        readonly read: boolean;
+        readonly write: boolean;
+        readonly execute: boolean;
+    };
+};
+export type PermissionOperationResult = Promise<boolean>;
+export type AtomicWriteOptions = {
+    readonly path: string;
+    readonly data: FileData;
+    readonly tempSuffix?: string;
+    readonly backup?: boolean;
+    readonly sync?: boolean;
+};
+export type AtomicOperationResult = Promise<{
+    readonly success: boolean;
+    readonly bytesWritten: number;
+    readonly tempPath?: string;
+    readonly backupPath?: string;
+}>;
+export type AtomicOperationData = {
+    readonly success: boolean;
+    readonly bytesWritten: number;
+    readonly tempPath?: string;
+    readonly backupPath?: string;
+};
+export type BackupOptions = {
+    readonly sourcePath: string;
+    readonly backupDir?: string;
+    readonly keepOriginal?: boolean;
+    readonly timestamp?: boolean;
+};
+export type ConfigValidationResult = {
+    readonly isValid: boolean;
+    readonly errors: ReadonlyArray<string>;
+    readonly warnings: ReadonlyArray<string>;
+};
+export type PartialFileManagerConfig = Partial<FileManagerConfig>;
+export type ConfigValidationOptions = {
+    readonly strict?: boolean;
+    readonly allowUnknownKeys?: boolean;
+    readonly validatePaths?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/Managers/File/utils.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Bun File Manager - Utility Functions
+ * Type-safe helper functions for file operations
+ */
+import type { BulkOperationFunction, ConfigValidationOptions, ConfigValidationResult, FileManagerConfig, FileManagerError, FilePermissionMode, FileSizeUnit, JsonData, PartialFileManagerConfig } from "./types";
+export declare const DEFAULT_CONFIG: FileManagerConfig;
+export declare const FILE_SIZE_UNITS: ReadonlyArray<FileSizeUnit>;
+/**
+ * Resolves and validates file path
+ */
+export declare const resolvePath: (path: string) => string;
+/**
+ * Extracts directory path from file path
+ */
+export declare const extractDirectoryPath: (filePath: string) => string;
+/**
+ * Ensures directory exists, creates if not
+ */
+export declare const ensureDirectoryExists: (dirPath: string) => Promise<void>;
+/**
+ * Validates if path is accessible
+ */
+export declare const validatePathAccess: (path: string) => Promise<boolean>;
+/**
+ * Formats file size from bytes to human readable format
+ */
+export declare const formatFileSize: (bytes: number) => string;
+/**
+ * Validates file extension
+ */
+export declare const validateFileExtension: (fileName: string, expectedExtension: string) => boolean;
+/**
+ * Adds extension to filename if not present
+ */
+export declare const ensureFileExtension: (fileName: string, extension: string) => string;
+/**
+ * Creates standardized error object
+ */
+export declare const createFileManagerError: (code: string, message: string, path?: string, operation?: string) => FileManagerError;
+/**
+ * Safely parses JSON string with error handling
+ */
+export declare const safeJsonParse: <T = JsonData>(jsonString: string) => T | null;
+/**
+ * Safely stringifies JSON with error handling
+ */
+export declare const safeJsonStringify: (data: string | number | boolean | null | object) => string;
+/**
+ * Validates if string is valid JSON
+ */
+export declare const isValidJson: (str: string) => boolean;
+/**
+ * Executes bulk operations with concurrency control
+ */
+export declare const executeBulkOperation: <T, R>(items: ReadonlyArray<T>, operation: BulkOperationFunction<T, R>, concurrency?: number) => Promise<ReadonlyArray<PromiseSettledResult<R>>>;
+/**
+ * Creates array of successful results from bulk operation
+ */
+export declare const extractSuccessfulResults: <T>(results: ReadonlyArray<PromiseSettledResult<T>>) => ReadonlyArray<T>;
+/**
+ * Creates array of failed results from bulk operation
+ */
+export declare const extractFailedResults: <T>(results: ReadonlyArray<PromiseSettledResult<T>>) => ReadonlyArray<string>;
+/**
+ * Validates file manager configuration
+ */
+export declare const validateConfig: (config: PartialFileManagerConfig, options?: ConfigValidationOptions) => ConfigValidationResult;
+/**
+ * Merges partial config with defaults safely
+ */
+export declare const mergeConfig: (partial: PartialFileManagerConfig, base?: FileManagerConfig) => FileManagerConfig;
+/**
+ * Converts octal permission to readable format
+ */
+export declare const parsePermissions: (mode: FilePermissionMode) => {
+    owner: {
+        read: boolean;
+        write: boolean;
+        execute: boolean;
+    };
+    group: {
+        read: boolean;
+        write: boolean;
+        execute: boolean;
+    };
+    others: {
+        read: boolean;
+        write: boolean;
+        execute: boolean;
+    };
+};
+/**
+ * Converts readable permissions to octal
+ */
+export declare const createPermissionMode: (owner: {
+    read: boolean;
+    write: boolean;
+    execute: boolean;
+}, group: {
+    read: boolean;
+    write: boolean;
+    execute: boolean;
+}, others: {
+    read: boolean;
+    write: boolean;
+    execute: boolean;
+}) => FilePermissionMode;
+/**
+ * Validates permission mode
+ */
+export declare const validatePermissionMode: (mode: FilePermissionMode) => boolean;
+//# sourceMappingURL=utils.d.ts.map