@epam/ai-dial-react-file-manager 0.1.0-dev.13

package/dist/src/components/FileManager/components/FoldersTree/FoldersTree.d.ts

@@ -0,0 +1,132 @@
+import { FC, ReactNode } from '../../../../../node_modules/react';
+import { DialFile } from '../../../../models/file';
+import { DropdownItem } from '@epam/ai-dial-ui-kit';
+export interface DialFoldersTreeProps {
+    items: DialFile[];
+    expandedPaths?: Set<string>;
+    loadingPaths?: Set<string>;
+    loadedPaths?: Set<string>;
+    sharedByMePaths?: Set<string>;
+    selectedPath?: string;
+    renamedPath?: string;
+    createdFolderPath?: string | null;
+    showFiles?: boolean;
+    rootItemPath?: string;
+    rootItemLabel?: string;
+    emptyStateTitle?: string;
+    emptyStateDescription?: string;
+    emptyStateIcon?: ReactNode;
+    onItemClick?: (item: DialFile) => void;
+    onRenameSave?: (value: string) => void;
+    onRenameCancel?: () => void;
+    onRenameValidate?: (value: string, item: DialFile) => string | null;
+    onCreateFolderSave?: (value: string) => void;
+    onCreateFolderCancel?: () => void;
+    getContextMenuItems?: (item: DialFile) => DropdownItem[];
+    areHiddenFilesVisible?: boolean;
+    onExpandedPathsChange?: (expandedPaths: Set<string>) => void;
+    forbiddenSymbolsRegExp?: RegExp;
+    forbiddenSymbolsTooltip?: ReactNode;
+    newFolderDefaultName?: string;
+}
+/**
+ * DialFoldersTree — A hierarchical folder tree component with nested expand/collapse support, selection highlighting,
+ * and optional file display.
+ *
+ * Provides a fully interactive, recursive folder structure with:
+ * - Expandable and collapsible items
+ * - Optional file visibility
+ * - Loading state indicators for specific paths
+ * - Inline renaming support for folders or files
+ * - Multi-item selection highlighting
+ * - Context menu integration via `DialDropdown`
+ * - Recursive rendering with indentation and icons
+ * - Customizable empty state (title, description, and icon)
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with folders and files
+ * const items: DialFile[] = [
+ *   {
+ *     path: '/documents',
+ *     name: 'Documents',
+ *     nodeType: DialFileNodeType.FOLDER,
+ *     items: [
+ *       {
+ *         path: '/documents/file.txt',
+ *         name: 'file.txt',
+ *         nodeType: DialFileNodeType.FILE,
+ *       },
+ *     ],
+ *   },
+ * ];
+ *
+ * <DialFoldersTree items={items} showFiles />
+ *
+ * // With expanded and selected items
+ * const expandedPaths = new Set(['/documents']);
+ *
+ * <DialFoldersTree
+ *   items={items}
+ *   expandedPaths={expandedPaths}
+ *   selectedPath="/documents/file.txt"
+ *   onItemClick={(item) => console.log('Clicked:', item.path)}
+ * />
+ *
+ * // With inline renaming and validation
+ * <DialFoldersTree
+ *   items={items}
+ *   renamedPath="/documents"
+ *   onRenameValidate={(value) => (value.trim() ? null : 'Name cannot be empty')}
+ *   onRenameSave={(newValue) => console.log('Saved new name:', newValue)}
+ *   onRenameCancel={() => console.log('Edit cancelled')}
+ * />
+ *
+ * // With custom empty state and context menu
+ * const getContextMenuItems = (item: DialFile): DropdownItem[] => [
+ *   { key: 'rename', label: 'Rename' },
+ *   { key: 'delete', label: 'Delete', danger: true },
+ * ];
+ *
+ * <DialFoldersTree
+ *   items={[]}
+ *   emptyStateTitle="No Content"
+ *   emptyStateDescription="Upload files or create a new folder to get started."
+ *   emptyStateIcon={<IconFolderPlus />}
+ *   getContextMenuItems={getContextMenuItems}
+ * />
+ * ```
+ *
+ * @param [items] - Array of folder and file nodes to display in the tree.
+ * @param [expandedPaths] - Set of folder paths that should be expanded.
+ * @param [loadingPaths] - Set of folder paths currently loading (shows spinner or placeholder).
+ * @param [loadedPaths] - Set of folder paths that have loaded.
+ * @param [sharedByMePaths] - Set of items paths that the user has shared with others. Enables UI indicators (icons/badges).
+ * @param [selectedPath] - Path representing the currently selected folder or file.
+ * @param [renamedPath] - Path of the folder or file currently being edited.
+ * @param [showFiles=false] - Whether to show files in addition to folders.
+ * @param [emptyStateTitle='No Folders'] - Title text displayed when there are no items.
+ * @param [emptyStateDescription] - Optional description text for the empty state.
+ * @param [emptyStateIcon] - Optional icon to display in the empty state.
+ * @param [onItemClick] - Callback fired when a folder or file is clicked (receives the corresponding `DialFile` node).
+ * @param [onRenameSave] - Callback fired when editing is confirmed with a valid name (receives the new name).
+ * @param [onRenameCancel] - Callback fired when editing is cancelled.
+ * @param [onRenameValidate] - Function to validate the new name during editing. Should return an error string or `null` if valid.
+ * @param [getContextMenuItems] - Function returning context menu items for a given node.
+ * @param [areHiddenFilesVisible=false] - Whether hidden files (dotfiles) should be visible in the tree.
+ * @param [rootItemPath] - Path of the folder to treat as the custom root node (no context menu, special label).
+ * @param [rootItemLabel] - Label to display for the root node instead of its actual name.
+ * @param [forbiddenSymbolsRegExp] - Optional RegExp used to validate folder and file names for forbidden characters.
+ * @param [forbiddenSymbolsTooltip] - Optional tooltip content displayed when a name contains forbidden characters.
+ * @param [createdFolderPath] - Optional Path of the new created folder.
+ * @param [onCreateFolderSave] - Optional Callback fired when create new folder is confirmed
+ * @param [onCreateFolderCancel] - Optional Callback fired when create new folder is cancelled
+ * @param [newFolderDefaultName] - Optional new folder default name.
+ * @remarks
+ * - Folder and file data must follow the `DialFile` model.
+ * - The `expandedPaths`, `loadingPaths`, `selectedPath`, and `renamedPath` props are externally controlled.
+ * - Inline renaming is fully customizable using `onRenameSave`, `onRenameCancel`, and `onRenameValidate`.
+ * - Context menus can be attached to both folders and files using `getContextMenuItems`.
+ * - Use `showFiles={false}` to render only folders for a simplified tree.
+ */
+export declare const DialFoldersTree: FC<DialFoldersTreeProps>;

package/dist/src/components/FileManager/components/FoldersTree/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const CARET_ICON_PROPS: {
+    size: number;
+    stroke: number;
+};
+export declare const FOLDER_LEVEL_PADDING = 26;
+export declare const NEW_FOLDER_TEMP_NAME = "__new_folder";

package/dist/src/components/FileManager/components/FoldersTree/hooks/use-expanded-paths.d.ts

@@ -0,0 +1,13 @@
+export interface UseExpandedPathsOptions {
+    expandedPaths?: Set<string>;
+    onExpandedPathsChange?: (expandedPaths: Set<string>) => void;
+}
+export declare const useExpandedPaths: (options?: UseExpandedPathsOptions) => {
+    expandedPaths: Set<string>;
+    setExpandedPaths: (newSet: Set<string>) => void;
+    togglePath: (path: string) => void;
+    collapseAll: () => void;
+    expandPath: (path: string) => void;
+    collapsePath: (path: string) => void;
+    isControlled: boolean;
+};

package/dist/src/components/FileManager/constants.d.ts

@@ -0,0 +1,21 @@
+import { FileManagerColumnKey } from '../../types/file-manager.ts';
+export declare const containerBaseClassName = "w-full h-full grid grid-rows-[auto_1fr] gap-5 p-6 overflow-hidden min-w-0 bg-layer-1";
+export declare const toolbarBaseClassName = "w-full text-secondary flex items-center gap-2";
+export declare const mainGridClassName = "flex min-h-0 min-w-0 h-full gap-4 overflow-hidden";
+export declare const contentGridClassName = "flex flex-col flex-1 min-h-0 min-w-0 h-full gap-4";
+export declare const contentHeaderClassName = "items-center";
+export declare const treeBaseClassName = "h-full rounded bg-layer-3 text-secondary min-w-0";
+export declare const gridBaseClassName = "flex-1 w-full rounded text-secondary overflow-auto min-h-0 min-w-0";
+export declare const actionsColumnButtonClassName = "opacity-0 pointer-events-none group-hover/grid-row:opacity-100 group-hover/grid-row:pointer-events-auto";
+export declare const sidebarWidth = 280;
+export declare const sidebarTitleDefault = "Files";
+export declare const BASE_FILE_MANAGER_ICON_SIZE = 20;
+export declare const FILES_DATA_TRANSFER_TYPE = "Files";
+export declare const FOLDER_PLACEHOLDER_FILE_NAME = ".dial_folder";
+export declare const DEFAULT_FOLDER_BASE_NAME = "New folder";
+export declare const FOLDERS_TREE_PANEL_MIN_WIDTH = 280;
+export declare const FOLDERS_TREE_PANEL_MAX_WIDTH = 460;
+export declare const COMPACT_VIEW_HEADER_HEIGHT = 44;
+export declare const COMPACT_VIEW_FILE_ROW_HEIGHT = 56;
+export declare const DEFAULT_COMPACT_VIEW_WIDTH_BREAKPOINT = 800;
+export declare const DEFAULT_VISIBLE_COLUMN: FileManagerColumnKey[];

package/dist/src/components/FileManager/errors.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_WARNINGS: {
+    hiddenItemWarning: string;
+};
+export declare const DEFAULT_ERRORS: {
+    consecutiveDotsError: string;
+};

package/dist/src/components/FileManager/hooks/use-bulk-actions.d.ts

@@ -0,0 +1,30 @@
+import { DialFile } from '../../../models/file';
+import { DialFileManagerActions } from '../../../types/file-manager';
+import { DialActionDropdownItem } from '../components/FileManagerBulkActionsToolbar/FileManagerBulkActionsToolbar';
+export interface UseBulkActionsProps {
+    selectedFiles: Map<string, DialFile>;
+    actionLabels?: {
+        [DialFileManagerActions.Duplicate]?: string;
+        [DialFileManagerActions.Copy]?: string;
+        [DialFileManagerActions.Rename]?: string;
+        [DialFileManagerActions.Download]?: string;
+        [DialFileManagerActions.Unshare]?: string;
+        [DialFileManagerActions.Delete]?: string;
+        [DialFileManagerActions.Move]?: string;
+        [DialFileManagerActions.RemoveAccess]?: string;
+    };
+    onDuplicate: (files: DialFile[]) => void;
+    onCopy: (files: DialFile[]) => void;
+    onMove: (files: DialFile[]) => void;
+    onDownload: (files: DialFile[]) => void;
+    onUnshare?: (files: DialFile[]) => void;
+    onRemoveAccess?: (files: DialFile[]) => void;
+    onRename: (filePath: string) => void;
+    onDelete: (files: DialFile[], parentFolderPath: string) => void;
+    getCurrentFolderPath: () => string;
+    sharedWithMeIds?: string[];
+    sharedByMePaths?: Set<string>;
+    onClearSelection: () => void;
+    forbiddenSymbolsRegExp?: RegExp;
+}
+export declare const useBulkActions: ({ selectedFiles, actionLabels, onDuplicate, onCopy, onMove, onDownload, onUnshare, onRemoveAccess, onDelete, getCurrentFolderPath, sharedWithMeIds, sharedByMePaths, onClearSelection, forbiddenSymbolsRegExp, }: UseBulkActionsProps) => DialActionDropdownItem[];

package/dist/src/components/FileManager/hooks/use-collapse-tree.d.ts

@@ -0,0 +1,9 @@
+export interface UseCollapseTreeOptions {
+    collapsed?: boolean;
+    onCollapseChange?: (collapsed: boolean) => void;
+}
+export declare const useCollapseTree: (options?: UseCollapseTreeOptions) => {
+    isTreeCollapsed: boolean;
+    toggleTreeCollapse: () => void;
+    setIsTreeCollapsed: (value: boolean) => void;
+};

package/dist/src/components/FileManager/hooks/use-conflict-resolution.d.ts

@@ -0,0 +1,27 @@
+import { DialFile } from '../../../models/file';
+import { DialCopiedItem } from '../../../models/file-manager';
+import { FileConflictDecision } from '../components/ConflictResolutionPopup/ConflictResolutionPopup';
+import { DialFileManagerConflictActions } from '../../../types/file-manager';
+export interface UseConflictResolutionOptions {
+    getDestinationFiles: (path: string) => DialFile[];
+    onResolve?: (items: DialCopiedItem[], destinationFolder: string) => void;
+}
+export interface ConflictResolutionResult {
+    hasConflicts: boolean;
+    conflicts: DialFile[];
+}
+export declare const useConflictResolution: ({ getDestinationFiles, onResolve, }: UseConflictResolutionOptions) => {
+    conflictingFiles: DialFile[];
+    conflictResolutionOpen: boolean;
+    hasActiveConflictRef: import('../../../../node_modules/react').RefObject<boolean>;
+    checkForConflicts: (destinationFolder: string, files: DialFile[]) => ConflictResolutionResult;
+    startConflictResolution: (destinationFolder: string, files: DialFile[], metadata?: Record<string, unknown>) => ConflictResolutionResult;
+    resolveConflictsWithStrategy: (destinationFolder: string, files: DialFile[], overwrite: boolean, metadata?: Record<string, unknown>) => DialCopiedItem[];
+    resolveConflictsWithDecisions: (destinationFolder: string, files: DialFile[], decisions: Map<string, DialFileManagerConflictActions>, metadata?: Record<string, unknown>) => DialCopiedItem[];
+    openConflictResolution: (files: DialFile[]) => void;
+    closeConflictResolution: () => void;
+    handleReplaceAll: () => void;
+    handleDuplicateAll: () => void;
+    handleCancelAll: () => void;
+    handleDecideForEach: (decisions: FileConflictDecision[]) => void;
+};

package/dist/src/components/FileManager/hooks/use-current-path.d.ts

@@ -0,0 +1,13 @@
+export interface UseCurrentPathOptions {
+    path?: string;
+    defaultPath?: string;
+    onPathChange?: (nextPath?: string) => void;
+    onSelectionClear?: () => void;
+}
+interface UseCurrentPathResult {
+    currentPath?: string;
+    setCurrentPath: (nextPath?: string) => void;
+    handlePathChange: (nextPath?: string) => void;
+}
+export declare const useCurrentPath: ({ path, defaultPath, onPathChange, onSelectionClear, }: UseCurrentPathOptions) => UseCurrentPathResult;
+export {};

package/dist/src/components/FileManager/hooks/use-file-clipboard.d.ts

@@ -0,0 +1,37 @@
+import { DialFile } from '../../../models/file';
+import { DialCopiedItem } from '../../../models/file-manager';
+import { FileConflictDecision } from '../components/ConflictResolutionPopup/ConflictResolutionPopup';
+import { DestinationFolderMode } from '../../../types/file-manager';
+export interface UseFileClipboardOptions {
+    getDestinationFiles: (path: string) => DialFile[];
+    getSourceFiles: () => DialFile[];
+    onCopyFiles?: (items: DialCopiedItem[], destinationFolder: string) => void;
+    onMoveToFiles?: (items: DialCopiedItem[], sourceFolder: string, destinationFolder: string) => void;
+    onCopySuccess?: () => void;
+    onMoveSuccess?: () => void;
+    onDuplicateSuccess?: () => void;
+    getCopyHeader?: (itemsCount: number, itemName?: string) => string;
+    getMoveHeader?: (itemsCount: number, itemName?: string) => string;
+}
+export declare const useFileClipboard: ({ getDestinationFiles, onCopyFiles, onMoveToFiles, onCopySuccess, onMoveSuccess, onDuplicateSuccess, getCopyHeader, getMoveHeader, }: UseFileClipboardOptions) => {
+    handleDuplicate: (files: DialFile[]) => void;
+    handleCloseDestinationFolderPopup: () => void;
+    handleOpenDestinationFolderPopup: (mode: DestinationFolderMode) => void;
+    handleCopyTo: (destinationFolder: string) => void;
+    handleMoveTo: (destinationFolder: string, sourceFolder?: string) => void;
+    openDestinationFolderPopup: boolean;
+    destinationFolderMode: DestinationFolderMode;
+    destinationFolderTitle: string | undefined;
+    handleSetCopiedFiles: (files: DialFile[]) => void;
+    handleSetMovedFiles: (files: DialFile[]) => void;
+    clearState: () => void;
+    conflictingFiles: DialFile[];
+    conflictResolutionOpen: boolean;
+    openConflictResolution: (files: DialFile[]) => void;
+    closeConflictResolution: () => void;
+    handleConflictReplace: () => void;
+    handleConflictCancel: () => void;
+    handleConflictDuplicate: () => void;
+    handleConflictDecideForEach: (decisions: FileConflictDecision[]) => void;
+    sourceFolder: string | undefined;
+};

package/dist/src/components/FileManager/hooks/use-file-delete.d.ts

@@ -0,0 +1,13 @@
+import { DialFile } from '../../../models/file';
+import { DialDeletedItem } from '../../../models/file-manager';
+export interface UseFileDeleteOptions {
+    onDeleteFiles?: (items: DialDeletedItem[], sourceFolder: string) => void;
+    onDeleteSuccess?: () => void;
+}
+export declare const useFileDelete: ({ onDeleteFiles, onDeleteSuccess, }: UseFileDeleteOptions) => {
+    deleteConfirmationOpen: boolean;
+    itemsToDelete: DialFile[];
+    openDeleteConfirmation: (items: DialFile[], parentFolderPath: string) => void;
+    closeDeleteConfirmation: () => void;
+    confirmDelete: () => void;
+};

package/dist/src/components/FileManager/hooks/use-file-download.d.ts

@@ -0,0 +1,9 @@
+import { DialFile } from '../../../models/file';
+export interface UseFileDownloadOptions {
+    onDownloadFiles?: (items: DialFile[]) => void;
+    customDownloadItemsAction?: (items: DialFile[]) => void;
+    onDownloadSuccess?: () => void;
+}
+export declare const useFileDownload: ({ onDownloadFiles, customDownloadItemsAction, onDownloadSuccess, }: UseFileDownloadOptions) => {
+    handleDownloadFiles: (items: DialFile[]) => void;
+};

package/dist/src/components/FileManager/hooks/use-file-manager-columns.d.ts

@@ -0,0 +1,43 @@
+import { ReactNode } from '../../../../node_modules/react';
+import { ColDef } from '../../../../node_modules/ag-grid-community';
+import { DialFile } from '../../../models/file';
+import { FileManagerRenameTriggerView, FileManagerColumnKey } from '../../../types/file-manager';
+import { FileManagerGridRow } from '../FileManagerContext';
+type GridRow = FileManagerGridRow;
+export interface FileManagerGridContext {
+    newFolderTempId?: string;
+    renamedPath?: string;
+    renamedItem?: DialFile;
+    renameTriggerView: FileManagerRenameTriggerView;
+    sharedByMePaths?: Set<string>;
+    selectedPaths?: Set<string>;
+    disabledRowIds?: Set<string>;
+    forbiddenSymbolsRegExp?: RegExp;
+    forbiddenSymbolsTooltip?: ReactNode;
+    cancelFolderCreation: () => void;
+    saveFolderCreation: (name: string) => Promise<void>;
+    validateFolderName: (name: string) => string | null;
+    onRenameValidate: (value: string, item: DialFile) => string | null;
+    onRenameSave: (value: string) => void;
+    onRenameCancel: () => void;
+    getDisplayName: (item: DialFile) => string;
+    hideSearchPathItemName?: boolean;
+    filesLoading?: boolean;
+}
+export interface UseFileManagerColumnsArgs {
+    userColumnDefs?: (ColDef<GridRow> | ((dateLocale: Intl.LocalesArgument, dateOptions: Intl.DateTimeFormatOptions | undefined, isCompactView: boolean) => ColDef<GridRow, unknown>))[];
+    filterable: boolean;
+    dateLocale?: Intl.LocalesArgument;
+    dateOptions?: Intl.DateTimeFormatOptions;
+    effectiveVisibleColumns: FileManagerColumnKey[];
+    isCompactView: boolean;
+    hasActions: boolean;
+    actionsColumnDef: ColDef<GridRow>;
+    rootItemPath?: string;
+    rootItemLabel?: string;
+}
+export interface UseFileManagerColumnsResult {
+    columnDefs: ColDef<GridRow>[];
+}
+export declare function useFileManagerColumns({ userColumnDefs, filterable, dateLocale, dateOptions, effectiveVisibleColumns, isCompactView, hasActions, actionsColumnDef, rootItemLabel, rootItemPath, }: UseFileManagerColumnsArgs): UseFileManagerColumnsResult;
+export {};

package/dist/src/components/FileManager/hooks/use-file-manager-context.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook to read the File Manager context.
+ * Throws if used outside of the provider.
+ */
+export declare const useFileManagerContext: () => import('../FileManagerContext').FileManagerContextValue;

package/dist/src/components/FileManager/hooks/use-file-manager-tabs.d.ts

@@ -0,0 +1,7 @@
+import { TabModel } from '@epam/ai-dial-ui-kit';
+import { DialFileManagerTabs } from '../../../types/file-manager';
+export declare const useDialFileManagerTabs: (tabLabels?: Record<DialFileManagerTabs, string>, initialTab?: DialFileManagerTabs) => {
+    activeTab: DialFileManagerTabs;
+    handleTabChange: (tab: DialFileManagerTabs) => void;
+    tabs: TabModel[] | undefined;
+};

package/dist/src/components/FileManager/hooks/use-file-metadata.d.ts

@@ -0,0 +1,10 @@
+import { DialFile } from '../../../models/file';
+export interface UseFileMetadataProps {
+    onGetInfo?: (file: DialFile) => void | Promise<void>;
+}
+export declare const useFileMetadata: ({ onGetInfo }: UseFileMetadataProps) => {
+    isMetadataPopupOpen: boolean;
+    selectedFileForMetadata: DialFile | undefined;
+    openMetadataPopup: (file: DialFile) => Promise<void>;
+    closeMetadataPopup: () => void;
+};

package/dist/src/components/FileManager/hooks/use-file-search.d.ts

@@ -0,0 +1,23 @@
+import { DialFile } from '../../../models/file';
+export interface UseFileSearchOptions {
+    onSearchFiles?: (folder: string, query: string) => void;
+    clearSearchResults?: () => void;
+    currentPath?: string;
+    searchResults?: DialFile[];
+    searchInProgress?: boolean;
+    navigationPanelValue?: string | number | null;
+    onNavigationPanelSearchChange?: (value: string) => void;
+    allItems?: DialFile[];
+    activeTab?: string;
+}
+export interface UseFileSearchReturn {
+    isSearchMode: boolean;
+    searchValue: string;
+    effectiveSearchValue: string;
+    setSearchValue: (value: string) => void;
+    handleSearchChange: (value?: string) => void;
+    handleSearchActivate: (query: string) => void;
+    handleSearchClear: () => void;
+    searchResultsRows: DialFile[];
+}
+export declare function useFileSearch({ onSearchFiles, clearSearchResults, currentPath, searchResults, searchInProgress, navigationPanelValue, onNavigationPanelSearchChange, allItems, activeTab, }: UseFileSearchOptions): UseFileSearchReturn;

package/dist/src/components/FileManager/hooks/use-file-upload.d.ts

@@ -0,0 +1,62 @@
+import { DragEvent } from '../../../../node_modules/react';
+import { DialFile } from '../../../models/file';
+import { DialFileAcceptType, DialUploadFileItem } from '../../../models/file-manager';
+import { FileConflictDecision } from '../components/ConflictResolutionPopup/ConflictResolutionPopup';
+export interface FileUploadValidationResult {
+    valid: boolean;
+    message?: string;
+}
+export interface FileUploadValidationMessages {
+    /**
+     * Message displayed when duplicate files are selected. Customize for accessibility or copy consistency.
+     */
+    duplicateFiles?: string;
+    /**
+     * Message displayed when files exceed the maximum allowed size. Customize for accessibility or copy consistency.
+     */
+    oversizedFiles?: string;
+    /**
+     * Message displayed when selected files are of unsupported types. Customize for accessibility or copy consistency.
+     */
+    unsupportedFiles?: string;
+    /**
+     * Message displayed when folder uploads are attempted but not supported. Customize for accessibility or copy consistency.
+     */
+    foldersNotSupported?: string;
+    validationFailed?: string;
+    validationError?: string;
+}
+export interface UseFileUploadOptions {
+    uploadEnabled?: boolean;
+    onUploadFiles?: (files: DialUploadFileItem[], destinationFolder: string) => void;
+    onValidateUpload?: (files: DialUploadFileItem[], existingFiles: DialFile[], destinationFolder: string) => FileUploadValidationResult | Promise<FileUploadValidationResult>;
+    maxFileSize?: number;
+    allowedFileTypes?: DialFileAcceptType[];
+    validationMessages?: FileUploadValidationMessages;
+    onUploadArchive?: (file: File, name: string, destinationFolder: string) => void;
+    prepareUploadFileName?: (name: string) => string;
+    currentFolder?: DialFile;
+}
+export declare const useFileUpload: ({ onUploadFiles, onValidateUpload, maxFileSize, allowedFileTypes, validationMessages, onUploadArchive, prepareUploadFileName, uploadEnabled, currentFolder, }?: UseFileUploadOptions) => {
+    isDragging: boolean;
+    isDraggingOverWindow: boolean;
+    uploadError: string | undefined;
+    handleDragEnter: (e: DragEvent) => void;
+    handleDragLeave: (e: DragEvent) => void;
+    handleDragOver: (e: DragEvent) => void;
+    handleDrop: (e: DragEvent, destinationFolder: string, existingFiles: DialFile[]) => Promise<void>;
+    clearError: () => void;
+    handleUpload: (files: DialUploadFileItem[], destinationFolder: string, existingFiles: DialFile[]) => Promise<boolean>;
+    openFileDialog: (destinationFolder: string, existingFiles: DialFile[]) => void;
+    openArchiveDialog: (destinationFolder: string, existingFiles: DialFile[]) => void;
+    fileInputRef: import('../../../../node_modules/react').RefObject<HTMLInputElement | null>;
+    uploadConflictingFiles: DialFile[];
+    uploadConflictResolutionOpen: boolean;
+    hasActiveUploadConflictRef: import('../../../../node_modules/react').RefObject<boolean>;
+    openUploadConflictResolution: (files: DialFile[]) => void;
+    closeUploadConflictResolution: () => void;
+    handleUploadConflictReplace: () => void;
+    handleUploadConflictDuplicate: () => void;
+    handleUploadConflictCancel: () => void;
+    handleUploadConflictDecideForEach: (decisions: FileConflictDecision[]) => void;
+};

package/dist/src/components/FileManager/hooks/use-folder-creation.d.ts

@@ -0,0 +1,30 @@
+import { DialFile } from '../../../models/file';
+import { DialUploadFileItem } from '../../../models/file-manager';
+export interface FolderCreationValidationMessages {
+    emptyName?: string;
+    duplicateName?: string;
+    hiddenItemWarning?: string;
+    consecutiveDotsError?: string;
+}
+export interface UseFolderCreationProps {
+    currentFolder?: DialFile;
+    onCreateFolder?: (file: DialUploadFileItem, folderPath: string, fileId: string) => void | Promise<void>;
+    onValidateFolderName?: (name: string, parentFolder: DialFile) => string | null;
+    validationMessages?: FolderCreationValidationMessages;
+    items?: DialFile[];
+}
+export interface UseFolderCreationResult {
+    isCreatingFolder: boolean;
+    newFolderTempId: string | null;
+    newFolderDefaultName: string;
+    createdFolderPath: string | null;
+    startFolderCreation: () => void;
+    startGridSiblingFolderCreation: (targetFile: DialFile) => void;
+    startTreeSiblingFolderCreation: (targetFile: DialFile) => void;
+    startGridChildFolderCreation: (targetFile: DialFile) => void;
+    startTreeChildFolderCreation: (targetFile: DialFile) => void;
+    cancelFolderCreation: () => void;
+    saveFolderCreation: (name: string) => Promise<void>;
+    validateFolderName: (name: string) => string | null;
+}
+export declare const useFolderCreation: ({ currentFolder, onCreateFolder, onValidateFolderName, validationMessages, items, }: UseFolderCreationProps) => UseFolderCreationResult;

package/dist/src/components/FileManager/hooks/use-grid-actions-column.d.ts

@@ -0,0 +1,15 @@
+import { ColDef } from '../../../../node_modules/ag-grid-community';
+import { FileManagerGridRow } from '../FileManagerContext';
+import { DropdownItem } from '@epam/ai-dial-ui-kit';
+import { DialFileAcceptType } from '../../../models/file-manager';
+interface UseGridActionsColumnProps {
+    getContextMenuItems: (row: FileManagerGridRow) => DropdownItem[];
+    isRowDisabled: (row: FileManagerGridRow, allowedFileTypes?: DialFileAcceptType[], maxSelectableFileSize?: number) => boolean;
+    allowedFileTypes?: DialFileAcceptType[];
+    maxSelectableFileSize?: number;
+    buttonClassName?: string;
+}
+export declare const useGridActionsColumn: ({ getContextMenuItems, isRowDisabled, allowedFileTypes, maxSelectableFileSize, buttonClassName, }: UseGridActionsColumnProps) => {
+    actionsColumnDef: ColDef<FileManagerGridRow, any>;
+};
+export {};

package/dist/src/components/FileManager/hooks/use-grid-context-menu.d.ts

@@ -0,0 +1,43 @@
+import { DialFile } from '../../../models/file';
+import { DialFileManagerActions } from '../../../types/file-manager';
+import { DropdownItem } from '@epam/ai-dial-ui-kit';
+export interface UseGridContextMenuProps {
+    actionLabels?: {
+        [DialFileManagerActions.AddSibling]?: string;
+        [DialFileManagerActions.AddChild]?: string;
+        [DialFileManagerActions.Copy]?: string;
+        [DialFileManagerActions.Duplicate]?: string;
+        [DialFileManagerActions.Copy]?: string;
+        [DialFileManagerActions.Rename]?: string;
+        [DialFileManagerActions.Download]?: string;
+        [DialFileManagerActions.ManagePermissions]?: string;
+        [DialFileManagerActions.Preview]?: string;
+        [DialFileManagerActions.Delete]?: string;
+        [DialFileManagerActions.Move]?: string;
+        [DialFileManagerActions.Info]?: string;
+        [DialFileManagerActions.Unshare]?: string;
+        [DialFileManagerActions.RemoveAccess]?: string;
+        [DialFileManagerActions.OpenInNewTab]?: string;
+    };
+    onDuplicate: (file: DialFile) => void;
+    onCopy: (file: DialFile) => void;
+    onMove: (file: DialFile) => void;
+    onDownload: (file: DialFile) => void;
+    onRename: (filePath: string) => void;
+    onDelete: (file: DialFile, parentFolderPath: string) => void;
+    onInfo: (file: DialFile) => void;
+    onUnshare: (file: DialFile) => void;
+    onRemoveAccess?: (file: DialFile) => void;
+    sharedWithMeIds?: string[];
+    sharedByMePaths?: Set<string>;
+    onManagePermissions?: (path?: string) => void;
+    onPreview?: (path?: string) => void;
+    onOpenInNewTab?: (file: DialFile) => void;
+    previewExtensions?: string[];
+    isRenameFileAvailable?: boolean;
+    isDuplicateFolderAvailable?: boolean;
+    forbiddenSymbolsRegExp?: RegExp;
+    onGridCreateSiblingFolder: (files: DialFile[]) => void;
+    onGridCreateChildFolder: (files: DialFile[]) => void;
+}
+export declare const useGridContextMenu: ({ actionLabels, onDuplicate, onCopy, onMove, onDownload, onRename, onDelete, onInfo, onUnshare, onRemoveAccess, sharedWithMeIds, sharedByMePaths, onManagePermissions, onPreview, onOpenInNewTab, previewExtensions, isRenameFileAvailable, isDuplicateFolderAvailable, forbiddenSymbolsRegExp, onGridCreateSiblingFolder, onGridCreateChildFolder, }: UseGridContextMenuProps) => (file: DialFile) => DropdownItem[];

package/dist/src/components/FileManager/hooks/use-item-renaming.d.ts

@@ -0,0 +1,22 @@
+import { DialFile } from '../../../models/file';
+import { DialCopiedItem } from '../../../models/file-manager';
+export interface RenameValidationMessages {
+    emptyName?: string;
+    duplicateName?: string;
+    hiddenItemWarning?: string;
+    consecutiveDotsError?: string;
+}
+export declare const useItemRenaming: ({ items, onRenameValidate, validationMessages, onMoveToFiles, }: {
+    items?: DialFile[];
+    onRenameValidate?: (value: string, item: DialFile) => string | null;
+    validationMessages?: RenameValidationMessages;
+    onMoveToFiles?: (items: DialCopiedItem[], sourceFolder: string, destinationFolder: string) => void;
+}) => {
+    renamedPath: string | undefined;
+    renamedItem: DialFile | undefined;
+    renameHandler: (path: string) => void;
+    renameSaveHandler: (value: string) => void;
+    renameCancelHandler: () => void;
+    renameValidateHandler: (value: string, item: DialFile) => string | null;
+    getDisplayName: (item: DialFile) => string;
+};

package/dist/src/components/FileManager/hooks/use-new-actions.d.ts

@@ -0,0 +1,23 @@
+import { DropdownItem } from '@epam/ai-dial-ui-kit';
+import { NewAction } from '../FileManager';
+import { DialFile } from '../../../models/file';
+export interface UseNewActionsProps {
+    newActions?: {
+        uploadFiles?: NewAction;
+        newFolder?: NewAction;
+        uploadArchive?: NewAction;
+        newItem?: NewAction;
+    };
+    currentFolder?: DialFile;
+    onUploadFiles?: () => void;
+    onCreateFolder?: () => void;
+    onUploadArchive?: () => void;
+    onCreateNewItem: () => void;
+    isNewButtonDisabled?: boolean;
+}
+export interface UseNewActionsResult {
+    newActions: DropdownItem[];
+    isNewButtonVisible: boolean;
+    isNewButtonDisabled: boolean;
+}
+export declare const useNewActions: ({ newActions, currentFolder, onUploadFiles, onCreateFolder, onUploadArchive, onCreateNewItem, isNewButtonDisabled: isNewButtonDisabledExternal, }: UseNewActionsProps) => UseNewActionsResult;

package/dist/src/components/FileManager/hooks/use-paths-selection.d.ts

@@ -0,0 +1,13 @@
+interface UsePathsSelectionParams {
+    selectedPaths?: Set<string>;
+    defaultSelectedPaths?: Set<string>;
+    onSelectedPathsChange?: (paths: Set<string>) => void;
+}
+interface UsePathsSelectionResult {
+    selectedPaths: Set<string>;
+    setSelectedPaths: (paths: Set<string>) => void;
+    clearSelection: () => void;
+    isControlled: boolean;
+}
+export declare function usePathsSelection({ selectedPaths, defaultSelectedPaths, onSelectedPathsChange, }: UsePathsSelectionParams): UsePathsSelectionResult;
+export {};