@ynput/ayon-frontend-shared 0.2.15 → 0.2.17

package/dist/types/components/ProjectTableSettings/ProjectTableSettings.d.ts

@@ -5,7 +5,7 @@ import { SettingConfig } from '../SettingsPanel';
 interface Props extends ButtonProps {
     defaultSelected?: string | null;
 }
-export declare const CustomizeButton: ({ defaultSelected, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const CustomizeButton: ({ defaultSelected, className, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export type OverviewSettingsChange = (setting: 'columns' | 'group-by', value: any) => void;
 export type ProjectTableSettingsProps = {
     settings?: SettingConfig[];

package/dist/types/components/ProjectTableSettings/SortableColumnItem.d.ts

@@ -6,6 +6,7 @@ interface SortableColumnItemProps {
     isPinned: boolean;
     isHidden: boolean;
     isHighlighted?: boolean;
+    isDisabled?: boolean;
     onTogglePinning: (columnId: string) => void;
     onToggleVisibility: (columnId: string) => void;
 }

package/dist/types/components/ReviewableProgressCard/ReviewableProgressCard.d.ts

@@ -10,6 +10,6 @@ export interface ReviewableProgress {
 export interface ReviewableProgressCardProps extends ReviewableProgress, Omit<HTMLProps<HTMLDivElement>, 'name' | 'children' | 'as' | 'ref'> {
     onRemove?: () => void;
     tooltip?: string;
-    type: 'upload' | 'processing' | 'unsupported' | 'queued';
+    type: 'upload' | 'processing' | 'unsupported' | 'queued' | 'waiting';
 }
 export declare const ReviewableProgressCard: FC<ReviewableProgressCardProps>;

package/dist/types/components/ReviewablesList/ReviewablesUpload.d.ts

@@ -1,11 +1,27 @@
 import { FC } from 'react';
-export interface ReviewableUploadProps {
+export interface ReviewableUploadProps extends React.HTMLProps<HTMLDivElement> {
     projectName: string | null;
-    versionId: string;
-    productId: string | null;
+    taskId?: string | null;
+    folderId?: string | null;
+    versionId?: string | null;
+    productId?: string | null;
     variant?: 'normal' | 'large';
+    dispatch: any;
+    pendingFiles?: Array<{
+        file: File;
+        preview?: string;
+    }>;
+    setPendingFiles?: React.Dispatch<React.SetStateAction<Array<{
+        file: File;
+        preview?: string;
+    }>>>;
     onUpload?: () => void;
+    onFilesAdded?: (files: File[]) => void;
     children?: any;
+    pt?: {
+        upload?: React.HTMLProps<HTMLDivElement>;
+        dropzone?: React.HTMLProps<HTMLDivElement>;
+    };
 }
 export declare const ReviewableUpload: FC<ReviewableUploadProps>;
 export default ReviewableUpload;

package/dist/types/components/SettingsPanel/SettingsPanelItemTemplate.d.ts

@@ -12,6 +12,7 @@ export type SettingsPanelItem = {
 export interface SettingsPanelItemTemplateProps extends React.HTMLAttributes<HTMLLIElement> {
     item: SettingsPanelItem;
     isHighlighted?: boolean;
+    isDisabled?: boolean;
     startContent?: React.ReactNode;
     endContent?: React.ReactNode;
     actions?: Action[];

package/dist/types/components/index.d.ts

@@ -18,4 +18,5 @@ export * from './SettingsPanel';
 export * from './AttributeEditor';
 export * from './EnumEditor';
 export * from './SearchFilter';
+export * from './Badge';
 export * from './Powerpack';

package/dist/types/containers/ContextMenu/ContextMenuItem.d.ts

@@ -1,4 +1,5 @@
 import { default as React, RefObject } from 'react';
+import { PowerpackFeature } from '../../context';
 export interface CommandEvent {
     originalEvent: React.MouseEvent;
     item: {
@@ -23,6 +24,9 @@ export interface ContextMenuItemProps {
     danger?: boolean;
     developer?: boolean;
     style?: React.CSSProperties;
+    powerFeature?: PowerpackFeature;
+    powerLicense?: boolean;
+    onPowerClick?: (feature: PowerpackFeature) => void;
     [key: string]: any;
 }
 declare const ContextMenuItem: React.FC<ContextMenuItemProps>;

package/dist/types/containers/ContextMenu/useCreateContextMenu.d.ts

@@ -1,5 +1,6 @@
 import { MouseEvent, RefObject } from 'react';
 import { ContextMenuItemProps } from './ContextMenuItem';
+import { PowerpackContextType } from '../../context';
 export interface ContextMenuItemType extends Omit<ContextMenuItemProps, 'contextMenuRef'> {
     items?: ContextMenuItemType[];
     template?: React.ReactNode;
@@ -13,5 +14,5 @@ type UseCreateContextReturn = [
         hide: () => void;
     }>
 ];
-export declare const useCreateContextMenu: (menuList?: ContextMenuItemType[]) => UseCreateContextReturn;
+export declare const useCreateContextMenu: (menuList?: ContextMenuItemType[], powerConfig?: Pick<PowerpackContextType, "powerLicense" | "setPowerpackDialog">) => UseCreateContextReturn;
 export default useCreateContextMenu;

package/dist/types/containers/Feed/components/FileUploadPreview/FileUploadPreview.styled.d.ts

@@ -2,3 +2,4 @@ export declare const DialogWrapper: import('styled-components/dist/types').IStyl
     ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
 }, never>> & string & Omit<import('react').ForwardRefExoticComponent<import('@ynput/ayon-react-components').DialogProps & import('react').RefAttributes<HTMLDivElement>>, keyof import('react').Component<any, {}, any>>;
 export declare const Image: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never>> & string;
+export declare const ScrollableContent: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/types/containers/ProjectTreeTable/ProjectTreeTable.d.ts

@@ -6,7 +6,6 @@ import { BuiltInFieldOptions } from './types';
 import { ToggleExpandAll } from './context/ProjectTableContext';
 import { UpdateTableEntities } from './hooks/useUpdateTableData';
 import { UniqueIdentifier } from '@dnd-kit/core';
-import { GroupByEntityType } from './hooks/useBuildGroupByTableData';
 declare module '@tanstack/react-table' {
     interface TableMeta<TData extends RowData> {
         options?: BuiltInFieldOptions;
@@ -30,15 +29,12 @@ export interface ProjectTreeTableProps extends React.HTMLAttributes<HTMLDivEleme
     sortableRows?: boolean;
     onRowReorder?: (active: UniqueIdentifier, over: UniqueIdentifier | null) => void;
     dndActiveId?: UniqueIdentifier | null;
-    groupByConfig?: {
-        entityType?: GroupByEntityType;
-    };
     pt?: {
         container?: React.HTMLAttributes<HTMLDivElement>;
         head?: Partial<TableHeadProps>;
     };
 }
-export declare const ProjectTreeTable: ({ scope, sliceId, fetchMoreOnBottomReached, onOpenNew, readOnly, excludedColumns, extraColumns, isLoading: isLoadingProp, clientSorting, sortableRows, onRowReorder, dndActiveId, groupByConfig, pt, ...props }: ProjectTreeTableProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ProjectTreeTable: ({ scope, sliceId, fetchMoreOnBottomReached, onOpenNew, readOnly, excludedColumns, extraColumns, isLoading: isLoadingProp, clientSorting, sortableRows, onRowReorder, dndActiveId, pt, ...props }: ProjectTreeTableProps) => import("react/jsx-runtime").JSX.Element;
 interface TableHeadProps extends React.HTMLAttributes<HTMLTableSectionElement> {
     columnVirtualizer: Virtualizer<HTMLDivElement, HTMLTableCellElement>;
     table: Table<TableRow>;

package/dist/types/containers/ProjectTreeTable/components/GroupSettingsFallback.d.ts

@@ -1,11 +1,18 @@
 import { SettingsPanelItem } from '../../../components';
 import { FC } from 'react';
 import { ColumnSettingsContextType } from '../context';
-export interface GroupSettingsFallbackProps {
-    requiredVersion?: string;
+export type GroupByConfig = {
+    showEmpty?: boolean;
+};
+export interface GroupSettingsProps {
     fields: SettingsPanelItem[];
+    config?: GroupByConfig;
     onChange?: ColumnSettingsContextType['updateGroupBy'];
     groupBy?: ColumnSettingsContextType['groupBy'];
     updateGroupBy?: ColumnSettingsContextType['updateGroupBy'];
+    onConfigChange?: (config: GroupByConfig) => void;
+}
+export interface GroupSettingsFallbackProps extends GroupSettingsProps {
+    requiredVersion?: string;
 }
 export declare const GroupSettingsFallback: FC<GroupSettingsFallbackProps>;

package/dist/types/containers/ProjectTreeTable/context/ColumnSettingsContext.d.ts

@@ -1,9 +1,20 @@
-import { default as React, ReactNode } from 'react';
+import { default as React } from 'react';
 import { ColumnOrderState, ColumnPinningState, OnChangeFn, VisibilityState, ColumnSizingState } from '@tanstack/react-table';
+import { GroupByConfig } from '../components/GroupSettingsFallback';
 export interface TableGroupBy {
     desc: boolean;
     id: string;
 }
+export type ColumnsConfig = {
+    columnVisibility: VisibilityState;
+    columnOrder: ColumnOrderState;
+    columnPinning: ColumnPinningState;
+    columnSizing: ColumnSizingState;
+    groupBy?: TableGroupBy;
+    groupByConfig?: {
+        showEmpty?: boolean;
+    };
+};
 export interface ColumnSettingsContextType {
     columnVisibility: VisibilityState;
     setColumnVisibility: (columnVisibility: VisibilityState) => void;
@@ -20,22 +31,11 @@ export interface ColumnSettingsContextType {
     columnSizing: ColumnSizingState;
     setColumnSizing: (columnSizing: ColumnSizingState) => void;
     columnSizingUpdater: OnChangeFn<ColumnSizingState>;
-    updateGroupBy: (groupBy: TableGroupBy | undefined) => void;
     groupBy?: TableGroupBy;
+    updateGroupBy: (groupBy: TableGroupBy | undefined) => void;
+    groupByConfig: GroupByConfig;
+    updateGroupByConfig: (config: GroupByConfig) => void;
     setColumnsConfig: (config: ColumnsConfig) => void;
 }
-export type ColumnsConfig = {
-    columnVisibility: VisibilityState;
-    columnOrder: ColumnOrderState;
-    columnPinning: ColumnPinningState;
-    columnSizing: ColumnSizingState;
-    groupBy?: TableGroupBy;
-};
-interface ColumnSettingsProviderProps {
-    children: ReactNode;
-    config?: Record<string, any>;
-    onChange: (config: ColumnsConfig) => void;
-}
-export declare const ColumnSettingsProvider: React.FC<ColumnSettingsProviderProps>;
+export declare const ColumnSettingsContext: React.Context<ColumnSettingsContextType | undefined>;
 export declare const useColumnSettingsContext: () => ColumnSettingsContextType;
-export {};

package/dist/types/containers/ProjectTreeTable/context/ColumnSettingsProvider.d.ts

@@ -0,0 +1,9 @@
+import { default as React, ReactNode } from 'react';
+import { ColumnsConfig } from './ColumnSettingsContext';
+interface ColumnSettingsProviderProps {
+    children: ReactNode;
+    config?: Record<string, any>;
+    onChange: (config: ColumnsConfig) => void;
+}
+export declare const ColumnSettingsProvider: React.FC<ColumnSettingsProviderProps>;
+export {};

package/dist/types/containers/ProjectTreeTable/context/ProjectTableContext.d.ts

@@ -1,57 +1,10 @@
-import { ReactNode } from 'react';
-import { ExpandedState, OnChangeFn, SortingState } from '@tanstack/react-table';
-import { Filter } from '@ynput/ayon-react-components';
-import { EntitiesMap, EntityMap, FolderNodeMap, TableRow, TaskNodeMap, TasksByFolderMap } from '../types/table';
+import { EntityMap, TableRow } from '../types/table';
 import { FindInheritedValueFromAncestors, GetAncestorsOf, GetInheritedDependents, FindNonInheritedValues } from '../hooks/useFolderRelationships';
 import { RowId } from '../utils/cellUtils';
-import { ProjectModel } from '../types/project';
-import { ProjectTableAttribute, LoadingTasks } from '../types';
-import { QueryFilter } from '../types/folders';
-import { ContextMenuItemConstructors } from '../hooks/useCellContextMenu';
-import { TaskGroup } from '../../../api';
-export type TableUser = {
-    name: string;
-    fullName?: string;
-};
+import { ProjectTableProviderProps } from './ProjectTableProvider';
 export type ToggleExpandAll = (rowIds: RowId[], expand?: boolean) => void;
 export type ToggleExpands = (rowIds: RowId[], expand?: boolean) => void;
-export interface ProjectTableProviderProps {
-    children: ReactNode;
-    isInitialized: boolean;
-    isLoading: boolean;
-    isLoadingMore: boolean;
-    loadingTasks?: LoadingTasks;
-    error?: string;
-    projectInfo?: ProjectModel;
-    projectName: string;
-    users: TableUser[];
-    attribFields: ProjectTableAttribute[];
-    tasksMap: TaskNodeMap;
-    foldersMap: FolderNodeMap;
-    entitiesMap: EntitiesMap;
-    tasksByFolderMap: TasksByFolderMap;
-    tableRows?: TableRow[];
-    taskGroups: TaskGroup[];
-    fetchNextPage: (value?: string) => void;
-    reloadTableData: () => void;
-    filters: Filter[];
-    setFilters: (filters: Filter[]) => void;
-    queryFilters: {
-        filter: QueryFilter | undefined;
-        filterString?: string;
-        search: string | undefined;
-    };
-    showHierarchy: boolean;
-    updateShowHierarchy: (showHierarchy: boolean) => void;
-    expanded: ExpandedState;
-    toggleExpanded: (id: string) => void;
-    updateExpanded: OnChangeFn<ExpandedState>;
-    setExpanded: (expanded: ExpandedState) => void;
-    sorting: SortingState;
-    updateSorting: OnChangeFn<SortingState>;
-    contextMenuItems: ContextMenuItemConstructors;
-}
-export interface ProjectTableContextProps {
+export interface ProjectTableContextType {
     isInitialized: ProjectTableProviderProps['isInitialized'];
     isLoading: ProjectTableProviderProps['isLoading'];
     projectInfo: ProjectTableProviderProps['projectInfo'];
@@ -84,6 +37,8 @@ export interface ProjectTableContextProps {
     findNonInheritedValues: FindNonInheritedValues;
     getAncestorsOf: GetAncestorsOf;
     contextMenuItems: ProjectTableProviderProps['contextMenuItems'];
+    powerpack?: ProjectTableProviderProps['powerpack'];
+    modules: ProjectTableProviderProps['modules'];
 }
-export declare const ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, expanded, projectInfo, showHierarchy, loadingTasks, isLoadingMore, isLoading, error, isInitialized, projectName, users, attribFields, taskGroups, filters, setFilters, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, sorting, updateSorting, fetchNextPage, reloadTableData, setExpanded, contextMenuItems, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;
-export declare const useProjectTableContext: () => ProjectTableContextProps;
+export declare const ProjectTableContext: import('react').Context<ProjectTableContextType | undefined>;
+export declare const useProjectTableContext: () => ProjectTableContextType;

package/dist/types/containers/ProjectTreeTable/context/ProjectTableProvider.d.ts

@@ -0,0 +1,59 @@
+import { ReactNode } from 'react';
+import { ExpandedState, OnChangeFn, SortingState } from '@tanstack/react-table';
+import { Filter } from '@ynput/ayon-react-components';
+import { EntitiesMap, FolderNodeMap, TableRow, TaskNodeMap, TasksByFolderMap } from '../types/table';
+import { ProjectModel } from '../types/project';
+import { ProjectTableAttribute, LoadingTasks } from '../types';
+import { QueryFilter } from '../types/folders';
+import { ContextMenuItemConstructors } from '../hooks/useCellContextMenu';
+import { EntityGroup } from '../../../api';
+import { GroupByEntityType } from '../hooks/useBuildGroupByTableData';
+import { PowerpackContextType } from '../../../context';
+import { ProjectTableModulesType } from '../hooks';
+export declare const parseRowId: (rowId: string) => string;
+export type TableUser = {
+    name: string;
+    fullName?: string;
+};
+export interface ProjectTableProviderProps {
+    children: ReactNode;
+    isInitialized: boolean;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    loadingTasks?: LoadingTasks;
+    error?: string;
+    projectInfo?: ProjectModel;
+    projectName: string;
+    users: TableUser[];
+    attribFields: ProjectTableAttribute[];
+    tasksMap: TaskNodeMap;
+    foldersMap: FolderNodeMap;
+    entitiesMap: EntitiesMap;
+    tasksByFolderMap: TasksByFolderMap;
+    tableRows?: TableRow[];
+    taskGroups: EntityGroup[];
+    fetchNextPage: (value?: string) => void;
+    reloadTableData: () => void;
+    filters: Filter[];
+    setFilters: (filters: Filter[]) => void;
+    queryFilters: {
+        filter: QueryFilter | undefined;
+        filterString?: string;
+        search: string | undefined;
+    };
+    showHierarchy: boolean;
+    updateShowHierarchy: (showHierarchy: boolean) => void;
+    expanded: ExpandedState;
+    toggleExpanded: (id: string) => void;
+    updateExpanded: OnChangeFn<ExpandedState>;
+    setExpanded: (expanded: ExpandedState) => void;
+    sorting: SortingState;
+    updateSorting: OnChangeFn<SortingState>;
+    contextMenuItems: ContextMenuItemConstructors;
+    powerpack?: PowerpackContextType;
+    modules: ProjectTableModulesType;
+    groupByConfig?: {
+        entityType?: GroupByEntityType;
+    };
+}
+export declare const ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, expanded, projectInfo, showHierarchy, loadingTasks, isLoadingMore, isLoading, error, isInitialized, projectName, users, attribFields, taskGroups, filters, setFilters, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, sorting, updateSorting, fetchNextPage, reloadTableData, setExpanded, contextMenuItems, powerpack, modules, groupByConfig, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/containers/ProjectTreeTable/context/SelectedRowsContext.d.ts

@@ -1,5 +1,4 @@
-import { ReactNode } from 'react';
-export interface SelectedRowsContextProps {
+export interface SelectedRowsContextType {
     selectedRows: string[];
     isRowSelected: (rowId: string) => boolean;
     clearRowsSelection: () => void;
@@ -7,9 +6,5 @@ export interface SelectedRowsContextProps {
     areAllRowsSelected: () => boolean;
     areSomeRowsSelected: () => boolean;
 }
-interface SelectedRowsProviderProps {
-    children: ReactNode;
-}
-export declare const SelectedRowsProvider: ({ children }: SelectedRowsProviderProps) => import("react/jsx-runtime").JSX.Element;
-export declare const useSelectedRowsContext: () => SelectedRowsContextProps;
-export {};
+export declare const SelectedRowsContext: import('react').Context<SelectedRowsContextType | undefined>;
+export declare const useSelectedRowsContext: () => SelectedRowsContextType;

package/dist/types/containers/ProjectTreeTable/context/SelectedRowsProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+interface SelectedRowsProviderProps {
+    children: ReactNode;
+}
+export declare const SelectedRowsProvider: ({ children }: SelectedRowsProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/containers/ProjectTreeTable/context/SelectionCellsContext.d.ts

@@ -1,4 +1,4 @@
-import { default as React, ReactNode } from 'react';
+import { default as React } from 'react';
 import { CellId, RowId, ColId, CellPosition } from '../utils/cellUtils';
 export declare const ROW_SELECTION_COLUMN_ID = "__row_selection__";
 export interface GridMap {
@@ -29,7 +29,5 @@ export interface SelectionCellsContextType {
     getCellPositionFromId: (cellId: CellId) => CellPosition | null;
     getCellBorderClasses: (cellId: CellId) => string[];
 }
-export declare const SelectionCellsProvider: React.FC<{
-    children: ReactNode;
-}>;
+export declare const SelectionCellsContext: React.Context<SelectionCellsContextType | undefined>;
 export declare const useSelectionCellsContext: () => SelectionCellsContextType;

package/dist/types/containers/ProjectTreeTable/context/SelectionCellsProvider.d.ts

@@ -0,0 +1,4 @@
+import { default as React, ReactNode } from 'react';
+export declare const SelectionCellsProvider: React.FC<{
+    children: ReactNode;
+}>;

package/dist/types/containers/ProjectTreeTable/context/index.d.ts

@@ -1,11 +1,13 @@
 export * from './clipboard';
 export * from './CellEditingContext';
 export * from './ClipboardContext';
+export * from './ColumnSettingsProvider';
 export * from './ColumnSettingsContext';
 export * from './ProjectTableContext';
+export * from './ProjectTableProvider';
 export * from './ProjectTableQueriesContext';
 export * from './SelectedRowsContext';
+export * from './SelectedRowsProvider';
 export * from './SelectionCellsContext';
-export * from './ProjectTableSelectionContext';
+export * from './SelectionCellsProvider';
 export * from './ProjectDataContext';
-export * from './ProjectTableModulesContext';

package/dist/types/containers/ProjectTreeTable/hooks/index.d.ts

@@ -0,0 +1,14 @@
+export * from './useGetEntityTypeData';
+export * from './useUpdateTableData';
+export * from './useCellContextMenu';
+export * from './useGetGroupedFields';
+export * from './useFetchOverviewData';
+export * from './useGetTaskGroups';
+export * from './useQueryFilters';
+export * from './useEntitiesMap';
+export * from './useSelectedFolders';
+export * from './useScopedAttributeFields';
+export * from './useExpandedState';
+export * from './useColumnSorting';
+export * from './useBuildGroupByTableData';
+export * from './useProjectTableModules';

package/dist/types/containers/ProjectTreeTable/hooks/useBuildGroupByTableData.d.ts

@@ -1,6 +1,6 @@
-import { ProjectModel, TaskGroup } from '../../../api';
+import { ProjectModel, EntityGroup } from '../../../api';
 import { TableGroupBy } from '../context';
-import { EntitiesMap, TableRow } from '../types';
+import { EntitiesMap, ProjectTableAttribute, TableRow } from '../types';
 export type GroupByEntityType = 'task' | 'folder' | 'version' | 'product';
 export type GroupData = {
     value: string;
@@ -11,6 +11,8 @@ export type GroupData = {
     count?: number;
 };
 export declare const NEXT_PAGE_ID = "next-page";
+export declare const UNGROUPED_VALUE = "_ungrouped";
+export declare const ROW_ID_SEPARATOR = "__";
 export declare const GROUP_BY_ID = "_GROUP_";
 export declare const buildGroupId: (value: string) => string;
 export declare const parseGroupId: (groupId: string) => string | null;
@@ -19,7 +21,9 @@ type BuildGroupByTableProps = {
     project?: ProjectModel;
     entities: EntitiesMap;
     entityType?: GroupByEntityType;
-    groups?: TaskGroup[];
+    groups?: EntityGroup[];
+    attribFields: ProjectTableAttribute[];
+    showEmpty?: boolean;
 };
 declare const useBuildGroupByTableData: (props: BuildGroupByTableProps) => (groupBy: TableGroupBy) => TableRow[];
 export default useBuildGroupByTableData;

package/dist/types/containers/ProjectTreeTable/hooks/useCellContextMenu.d.ts

@@ -1,13 +1,22 @@
 import { ContextMenuItemType } from '../../ContextMenu/useCreateContextMenu';
-import { ProjectTableAttribute } from '../types';
+import { ProjectTableAttribute, TableRow } from '../types';
 import { UseHistoryReturn } from './useHistory';
+import { ColumnDef } from '@tanstack/react-table';
 type ContextEvent = React.MouseEvent<HTMLTableSectionElement, MouseEvent>;
+export type HeaderLabel = {
+    id: string;
+    label: string;
+};
 export type TableCellContextData = {
     entityId: string;
     cellId: string;
     columnId: string;
     entityType: 'folder' | 'task' | 'product' | 'version' | undefined;
     attribField: ProjectTableAttribute | undefined;
+    column: {
+        id: string;
+        label: string;
+    };
     isGroup: boolean;
 };
 type DefaultMenuItem = 'copy-paste' | 'show-details' | 'expand-collapse' | 'inherit' | 'delete' | 'export' | 'create-folder' | 'create-task';
@@ -23,9 +32,11 @@ export type ContextMenuItemConstructor = (e: ContextEvent, cell: TableCellContex
 export type ContextMenuItemConstructors = (DefaultMenuItem | ContextMenuItemConstructor)[];
 type CellContextMenuProps = {
     attribs: ProjectTableAttribute[];
+    columns?: ColumnDef<TableRow>[];
+    headerLabels: HeaderLabel[];
     onOpenNew?: (type: 'folder' | 'task') => void;
 };
-declare const useCellContextMenu: ({ attribs, onOpenNew }: CellContextMenuProps) => {
+declare const useCellContextMenu: ({ attribs, headerLabels, onOpenNew }: CellContextMenuProps) => {
     handleTableBodyContextMenu: (e: ContextEvent) => void;
 };
 export default useCellContextMenu;

package/dist/types/containers/ProjectTreeTable/hooks/useColumnSorting.d.ts

@@ -0,0 +1,12 @@
+import { SortingState, OnChangeFn } from '@tanstack/react-table';
+interface UseColumnSortingProps {
+    updatePageConfig: (config: {
+        columnSorting: SortingState;
+    }) => Promise<void>;
+    columnSorting: SortingState;
+}
+export declare const useColumnSorting: ({ updatePageConfig, columnSorting }: UseColumnSortingProps) => {
+    setColumnSorting: (sorting: SortingState) => Promise<void>;
+    updateSorting: OnChangeFn<SortingState>;
+};
+export {};

package/dist/types/containers/ProjectTreeTable/hooks/useEntitiesMap.d.ts

@@ -0,0 +1,7 @@
+import { FolderNodeMap, TaskNodeMap } from '../types';
+interface UseEntitiesMapProps {
+    foldersMap: FolderNodeMap;
+    tasksMap: TaskNodeMap;
+}
+export declare const useEntitiesMap: ({ foldersMap, tasksMap }: UseEntitiesMapProps) => FolderNodeMap & TaskNodeMap;
+export {};

package/dist/types/containers/ProjectTreeTable/hooks/useExpandedState.d.ts

@@ -0,0 +1,11 @@
+import { ExpandedState, OnChangeFn } from '@tanstack/react-table';
+interface UseExpandedStateProps {
+    expanded: ExpandedState;
+    setExpanded: (expanded: ExpandedState) => void;
+}
+export declare const useExpandedState: ({ expanded, setExpanded }: UseExpandedStateProps) => {
+    updateExpanded: OnChangeFn<ExpandedState>;
+    toggleExpanded: (id: string) => void;
+    expandedIds: string[];
+};
+export {};

package/dist/types/containers/ProjectTreeTable/hooks/useFetchOverviewData.d.ts

@@ -0,0 +1,38 @@
+import { EntityGroup, QueryTasksFoldersApiArg } from '../../../api';
+import { FolderNodeMap, TaskNodeMap } from '../types/table';
+import { ExpandedState, SortingState } from '@tanstack/react-table';
+import { LoadingTasks } from '../types';
+import { TasksByFolderMap } from '../utils';
+import { TableGroupBy } from '../context';
+import { Filter } from '@ynput/ayon-react-components';
+import { ProjectTableAttribute } from '../hooks/useAttributesList';
+import { ProjectTableModulesType } from './useProjectTableModules';
+type useFetchOverviewDataData = {
+    foldersMap: FolderNodeMap;
+    tasksMap: TaskNodeMap;
+    tasksByFolderMap: TasksByFolderMap;
+    isLoadingAll: boolean;
+    isLoadingMore: boolean;
+    loadingTasks: LoadingTasks;
+    fetchNextPage: (value?: string) => void;
+    reloadTableData: () => void;
+};
+type Params = {
+    projectName: string;
+    selectedFolders: string[];
+    filters: Filter[];
+    queryFilters: {
+        filter: QueryTasksFoldersApiArg['tasksFoldersQuery']['filter'];
+        filterString?: string;
+        search: QueryTasksFoldersApiArg['tasksFoldersQuery']['search'];
+    };
+    sorting: SortingState;
+    groupBy: TableGroupBy | undefined;
+    taskGroups: EntityGroup[];
+    expanded: ExpandedState;
+    showHierarchy: boolean;
+    attribFields: ProjectTableAttribute[];
+    modules: ProjectTableModulesType;
+};
+export declare const useFetchOverviewData: ({ projectName, selectedFolders, filters, queryFilters, sorting, groupBy, taskGroups, expanded, showHierarchy, attribFields, modules, }: Params) => useFetchOverviewDataData;
+export {};

package/dist/types/containers/ProjectTreeTable/hooks/useGetEntityTypeData.d.ts

@@ -2,5 +2,5 @@ import { ProjectModel } from '../types/project';
 type Props = {
     projectInfo?: ProjectModel;
 };
-declare const useGetEntityTypeData: ({ projectInfo }: Props) => (type: "folder" | "task" | "product" | string | undefined, subType?: string) => any;
-export default useGetEntityTypeData;
+export declare const useGetEntityTypeData: ({ projectInfo }: Props) => (type: "folder" | "task" | "product" | string | undefined, subType?: string) => any;
+export {};

package/dist/types/containers/ProjectTreeTable/hooks/useGetGroupedFields.d.ts

@@ -0,0 +1,9 @@
+import { ProjectTableAttribute } from '../types';
+import { EntityGrouping } from '../../../api';
+export declare const allowedGroupByFields: string[];
+export declare const isAttribGroupable: (attrib: ProjectTableAttribute, entityType: EntityGrouping["entityType"], allowedTypes?: ("string" | "integer" | "float")[], enumOnly?: boolean) => boolean;
+export declare const useGetGroupedFields: (allowedTypes?: ("string" | "integer" | "float")[], enumOnly?: boolean) => {
+    value: string;
+    label: string;
+    icon: string;
+}[];

package/dist/types/containers/ProjectTreeTable/hooks/useGetTaskGroups.d.ts

@@ -0,0 +1,10 @@
+import { TableGroupBy } from '../context';
+type GetTaskGroupsProps = {
+    groupBy?: TableGroupBy;
+    projectName: string;
+};
+export declare const useGetTaskGroups: ({ groupBy, projectName }: GetTaskGroupsProps) => {
+    taskGroups: import('../../../api').EntityGroup[];
+    error: import('@reduxjs/toolkit/query').FetchBaseQueryError | import('@reduxjs/toolkit').SerializedError | undefined;
+};
+export {};

package/dist/types/containers/ProjectTreeTable/hooks/useProjectTableModules.d.ts

@@ -0,0 +1,25 @@
+import { GroupSettingsFallback } from '../components/GroupSettingsFallback';
+import { EntityGroup } from '../../../api';
+import { Filter } from '@ynput/ayon-react-components';
+import { TableGroupBy } from '../context';
+import { ProjectTableAttribute } from './useAttributesList';
+type GetGroupQueriesParams = {
+    taskGroups: EntityGroup[];
+    filters: Filter[];
+    groupBy: TableGroupBy;
+    groupPageCounts: Record<string, number>;
+    dataType: ProjectTableAttribute['data']['type'];
+};
+type GetGroupQueriesReturn = {
+    value: any;
+    count: number;
+    filter: string;
+}[];
+export type ProjectTableModulesType = {
+    GroupSettings: typeof GroupSettingsFallback;
+    getGroupQueries?: (params: GetGroupQueriesParams) => GetGroupQueriesReturn;
+    requiredVersion?: string;
+    isLoading: boolean;
+};
+export declare const useProjectTableModules: () => ProjectTableModulesType;
+export {};