@ynput/ayon-frontend-shared 0.3.42 → 0.3.44

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

@@ -1,4 +1,4 @@
-import { EntityGroup } from '../../../api';
+import { GroupCountsMap, EntityGroup } from '../../../api';
 import { TableGroupBy } from '../context';
 import { EntitiesMap, ProjectTableAttribute, TableRow } from '../types';
 export type GroupByEntityType = 'task' | 'folder' | 'version' | 'product';
@@ -9,6 +9,7 @@ export type GroupData = {
     icon?: string;
     img?: string;
     count?: number;
+    percentage?: number;
 };
 export declare const NEXT_PAGE_ID = "next-page";
 export declare const UNGROUPED_VALUE = "_ungrouped";
@@ -24,6 +25,8 @@ type BuildGroupByTableProps = {
     attribFields: ProjectTableAttribute[];
     showEmpty?: boolean;
     groupRowFunc?: (node: any) => TableRow;
+    groupCounts?: GroupCountsMap;
+    groupCountsComplete?: boolean;
 };
-declare const useBuildGroupByTableData: ({ entities, entityType, groups, attribFields, showEmpty, groupRowFunc, }: BuildGroupByTableProps) => (groupBy: TableGroupBy) => TableRow[];
+declare const useBuildGroupByTableData: ({ entities, entityType, groups, attribFields, showEmpty, groupRowFunc, groupCounts, groupCountsComplete, }: BuildGroupByTableProps) => (groupBy: TableGroupBy) => TableRow[];
 export default useBuildGroupByTableData;

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

@@ -1,7 +1,7 @@
 import { EntityGroup, QueryFilter } from '../../../api';
 import { FolderNodeMap, TaskNodeMap } from '../types/table';
 import { ExpandedState, SortingState } from '@tanstack/react-table';
-import { LoadingTasks } from '../types';
+import { LoadingTasks, SoftErrorAction } from '../types';
 import { TasksByFolderMap } from '../utils';
 import { TableGroupBy } from '../context';
 import { ProjectTableAttribute } from '../hooks/useAttributesList';
@@ -15,6 +15,9 @@ type useFetchOverviewDataData = {
     foldersMap: FolderNodeMap;
     tasksMap: TaskNodeMap;
     tasksByFolderMap: TasksByFolderMap;
+    error?: unknown;
+    softError?: string;
+    softErrorAction?: SoftErrorAction;
     isLoadingAll: boolean;
     isLoadingMore: boolean;
     loadingTasks: LoadingTasks;
@@ -40,6 +43,8 @@ type Params = {
     modules: ProjectTableModulesType;
     skipLinks?: boolean;
     showComments?: boolean;
+    onCollapseAll?: () => void;
+    visibleEntityIds?: string[];
 };
-export declare const useFetchOverviewData: ({ projectName, selectedFolders, excludeSelectedFolders, taskIds, taskFilters, folderFilters, sorting, groupBy, taskGroups, taskGroupsCount, expanded, showHierarchy, isFlatFolderView, attribFields, modules, skipLinks, showComments, }: Params) => useFetchOverviewDataData;
+export declare const useFetchOverviewData: ({ projectName, selectedFolders, excludeSelectedFolders, taskIds, taskFilters, folderFilters, sorting, groupBy, taskGroups, taskGroupsCount, expanded, showHierarchy, isFlatFolderView, attribFields, modules, skipLinks, showComments, onCollapseAll, visibleEntityIds, }: Params) => useFetchOverviewDataData;
 export {};

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

@@ -0,0 +1,39 @@
+import { GroupCountsMap } from '../../../api';
+import { TableGroupBy } from '../context';
+type TaskStatsArgs = {
+    projectName: string;
+    filter?: string;
+    folderFilter?: string;
+    search?: string;
+    folderIds?: string[];
+    taskIds?: string[];
+};
+type VersionStatsArgs = {
+    projectName: string;
+    versionFilter?: string;
+    productFilter?: string;
+    taskFilter?: string;
+    folderIds?: string[];
+    versionIds?: string[];
+    productIds?: string[];
+};
+export type UseGroupCountsParams = {
+    entity: 'task';
+    groupBy?: TableGroupBy;
+    args: TaskStatsArgs;
+    skip?: boolean;
+} | {
+    entity: 'version';
+    groupBy?: TableGroupBy;
+    args: VersionStatsArgs;
+    skip?: boolean;
+};
+export type GroupCountsResult = {
+    counts: GroupCountsMap | undefined;
+    complete: boolean;
+    total: number;
+    isLoading: boolean;
+    isSupported: boolean;
+};
+export declare const useGroupCounts: (params: UseGroupCountsParams) => GroupCountsResult;
+export {};

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

@@ -2,10 +2,8 @@ import { RowSelectionState } from '@tanstack/react-table';
 interface UseSelectedFoldersProps {
     rowSelection: RowSelectionState;
     sliceType: string;
-    rowSelectionData: Record<string, {
-        id: string;
-    }> | null;
+    pinnedRowSelection?: RowSelectionState | null;
     entityListFolderIds?: string[];
 }
-export declare const useSelectedFolders: ({ rowSelection, sliceType, rowSelectionData, entityListFolderIds, }: UseSelectedFoldersProps) => string[];
+export declare const useSelectedFolders: ({ rowSelection, sliceType, pinnedRowSelection, entityListFolderIds, }: UseSelectedFoldersProps) => string[];
 export {};

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

@@ -9,6 +9,11 @@ export interface ProjectTableAttribute extends Omit<AttributeModel, 'position'>
     readOnly?: boolean;
 }
 export type LoadingTasks = Record<string, number>;
+export type SoftErrorAction = {
+    label: string;
+    icon: string;
+    callback: () => void;
+};
 export type PatchOperation = Pick<OperationModel, 'entityId' | 'entityType' | 'data'> & {
     type?: OperationModel['type'];
 };
@@ -34,4 +39,5 @@ export interface SummaryCellContentProps {
     mainCountLabels?: MainCountLabels;
     fieldOptions?: BuiltInFieldOptions;
     parentScopeApplicable?: boolean;
+    selectedCount?: number;
 }

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

@@ -1,11 +1,12 @@
 import { EntityGroup } from '../../../api';
-import { FolderNodeMap, LoadingTasks, TaskNodeMap, TasksByFolderMap } from '.';
+import { FolderNodeMap, LoadingTasks, TaskNodeMap, TasksByFolderMap, SoftErrorAction } from '.';
 import { ProjectDataContextProps } from '../context';
 import { ExpandedState, OnChangeFn } from '@tanstack/react-table';
 import { ContextMenuItemConstructors } from '../hooks';
 import { ProjectTableModulesType } from '../../../hooks';
 import { QueryFilter } from './operations';
 import { ReactNode } from 'react';
+import { ProjectInfo } from '../../DetailsPanel/helpers/mergeProjectInfo';
 interface EntityMoveData {
     entityId: string;
     entityType: 'folder';
@@ -21,7 +22,7 @@ type QueryFilterParams = {
 };
 export interface ProjectOverviewContextType {
     isInitialized: boolean;
-    projectInfo?: ProjectDataContextProps['projectInfo'];
+    projectInfo?: ProjectInfo;
     projectName: string;
     users: ProjectDataContextProps['users'];
     attribFields: ProjectDataContextProps['attribFields'];
@@ -29,6 +30,8 @@ export interface ProjectOverviewContextType {
     isLoadingMore: boolean;
     loadingTasks: LoadingTasks;
     error?: string;
+    softError?: string;
+    softErrorAction?: SoftErrorAction;
     tasksMap: TaskNodeMap;
     foldersMap: FolderNodeMap;
     entitiesMap: FolderNodeMap & TaskNodeMap;
@@ -58,6 +61,8 @@ export interface ProjectOverviewContextType {
     contextMenuItems: ContextMenuItemConstructors;
     loadingLinksEntityIds: Set<string>;
     setLinksVisible: (visible: boolean) => void;
+    visibleEntityIds: string[];
+    setVisibleEntityIds: (entityIds: string[]) => void;
     openMoveDialog?: (entityData: EntityMoveData) => void;
 }
 export {};

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

@@ -14,35 +14,6 @@ export declare const DEFAULT_ROW_SCOPE: RowScope;
 export declare const scopeHasGroups: (s: RowScope) => boolean;
 export declare const scopeHasRows: (s: RowScope) => boolean;
 export declare const buildRowScope: (groups: boolean, rows: boolean) => RowScope;
-export type SummaryDistributionItem = {
-    value: string;
-    label?: string;
-    color?: string;
-    icon?: string;
-    avatarUrl?: string;
-    fullName?: string;
-    count: number;
-};
-export type ColumnSummary = {
-    columnId: string;
-    filledCount?: number;
-    notFilledCount?: number;
-    percentageFilled?: number;
-    percentageNotFilled?: number;
-    checkedCount?: number;
-    notCheckedCount?: number;
-    percentageChecked?: number;
-    percentageNotChecked?: number;
-    sum?: number;
-    avg?: number;
-    min?: number;
-    max?: number;
-    distribution?: SummaryDistributionItem[];
-    total?: number;
-    primaryCount?: number;
-    secondaryCount?: number;
-};
-export type ColumnSummaryMap = Record<string, ColumnSummary>;
 export type MainCountLabels = {
     primary: string;
     secondary?: string;

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

@@ -0,0 +1,11 @@
+export type ActiveFilters = {
+    filter?: {
+        conditions?: unknown[];
+    } | null;
+    search?: string | null;
+};
+export declare const extractQueryErrorMessage: (error: unknown) => string;
+export declare const hasActiveFilters: (filters?: ActiveFilters) => boolean;
+export declare const isFilterError: (error: unknown, filters?: ActiveFilters) => boolean;
+export declare const getFilterErrorMessage: (entities?: string) => string;
+export declare const getEntitiesLabelFromScopes: (scopes?: string[]) => string;

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

@@ -0,0 +1,3 @@
+import { ProjectFoldersContextValue } from '../../../context';
+import { ExpandedState } from '@tanstack/react-table';
+export declare const getFolderIdsToQueryFromExpanded: (expanded: ExpandedState, expandedParentIds: string[], selectedFolders: string[], excludeSelectedFolders: boolean, getFolderById: ProjectFoldersContextValue["getFolderById"]) => string[];

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

@@ -0,0 +1,17 @@
+import { EntityGroup } from '../../../api';
+import { QueryFilter } from '../types/operations';
+import { TableGroupBy } from '../context';
+export type GetGroupQueriesParams = {
+    groups: EntityGroup[];
+    filters?: QueryFilter;
+    groupBy: TableGroupBy;
+    groupPageCounts: Record<string, number>;
+    dataType?: string;
+};
+export type GroupQuery = {
+    value: string;
+    count: number;
+    filter: string;
+};
+export declare const getCountPerGroup: (groupCount?: number) => number;
+export declare const getGroupQueries: ({ groups, filters, groupBy, groupPageCounts, dataType, }: GetGroupQueriesParams) => GroupQuery[];

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

@@ -7,6 +7,7 @@ export * from './getTableFieldOptions';
 export * from './getReadOnlyLists';
 export * from './cellUtils';
 export * from './errorExtraction';
+export * from './filterError';
 export * from './localStorageKeys';
 export * from './getTypeDefaultValue';
 export * from './getEntityViewerIds';
@@ -16,3 +17,4 @@ export * from './metaRows';
 export * from './expandRelativeDates';
 export * from './checkColumnVisibility';
 export * from './sanitizeQueryFilter';
+export * from './getFolderIdsToQueryFromExpanded';

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

@@ -1,6 +1,5 @@
 import { CSSProperties } from 'react';
 import { Column } from '@tanstack/react-table';
 import { TableRow } from '../types/table';
-export declare const DRAG_HANDLE_COLUMN_ID = "drag-handle";
 export declare const getCommonPinningStyles: (column: Column<TableRow, unknown>) => CSSProperties;
 export declare const getColumnWidth: (columnId: string) => string;

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

@@ -6,9 +6,10 @@ type GroupHeaderProps = {
     img?: string | null;
     color?: string | null;
     count?: number;
+    percentage?: number;
     isExpanded: boolean;
     isEmpty?: boolean;
     toggleExpanded: () => void;
 };
-export declare const GroupHeaderWidget: ({ id, label, name, icon, img, count, color, isExpanded, isEmpty, toggleExpanded, }: GroupHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const GroupHeaderWidget: ({ id, label, name, icon, img, count, percentage, color, isExpanded, isEmpty, toggleExpanded, }: GroupHeaderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/containers/RepresentationsList/versionsToRepresentations.d.ts

@@ -7,5 +7,6 @@ declare const versionsToRepresentations: (entities?: DetailsPanelEntityData[]) =
     productType: string | undefined;
     fileCount: number;
     projectName: string;
+    files: string[];
 }[];
 export default versionsToRepresentations;

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

@@ -1,67 +1,4 @@
 import { FC } from 'react';
-import { Row, FilterFn, RowData, Table } from '@tanstack/react-table';
-import { RankingInfo } from '@tanstack/match-sorter-utils';
-import { SimpleTableCellTemplateProps } from './SimpleTableRowTemplate';
-declare module '@tanstack/react-table' {
-    interface FilterFns {
-        fuzzy: FilterFn<unknown>;
-    }
-    interface FilterMeta {
-        itemRank: RankingInfo;
-    }
-    interface TableMeta<TData extends RowData> {
-        isExpandable?: boolean;
-        isLoading?: boolean;
-        children?: (props: SimpleTableCellTemplateProps, row: Row<TData>, table: Table<SimpleTableRow>) => JSX.Element;
-        [key: string]: any;
-    }
-}
-export type RowItemData = {
-    id: string;
-    name?: string | null;
-    label?: string | null;
-    subType?: string | null;
-    [key: string]: any;
-};
-export type SimpleTableRow = {
-    id: string;
-    parentId?: string;
-    name: string;
-    label: string;
-    parents?: string[];
-    icon?: string | null;
-    iconColor?: string;
-    iconFilled?: boolean;
-    img?: string | null;
-    imgShape?: 'square' | 'circle';
-    startContent?: JSX.Element;
-    endContent?: JSX.Element;
-    subRows: SimpleTableRow[];
-    data: RowItemData;
-    isDisabled?: boolean;
-    disabledMessage?: string;
-    inactive?: boolean;
-};
-export interface SimpleTableProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
-    data: SimpleTableRow[];
-    isLoading: boolean;
-    error?: string;
-    isExpandable?: boolean;
-    isMultiSelect?: boolean;
-    enableClickToDeselect?: boolean;
-    enableNonFolderIndent?: boolean;
-    forceUpdateTable?: any;
-    globalFilter?: string;
-    meta?: Record<string, any>;
-    rowHeight?: number;
-    imgRatio?: number;
-    onScrollBottom?: () => void;
-    fitContent?: boolean;
-    children?: (props: SimpleTableCellTemplateProps, row: Row<SimpleTableRow>, table: Table<SimpleTableRow>) => JSX.Element;
-    pt?: {
-        cell?: Partial<SimpleTableCellTemplateProps>;
-        row?: Partial<React.HTMLAttributes<HTMLTableRowElement>>;
-    };
-}
+import { SimpleTableProps } from './SimpleTable.types';
 declare const SimpleTable: FC<SimpleTableProps>;
 export default SimpleTable;

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

@@ -0,0 +1,79 @@
+import { Row, RowData, Table } from '@tanstack/react-table';
+import { ContextMenuItemType } from '../ContextMenu';
+import { SimpleTableCellTemplateProps } from './SimpleTableRowTemplate';
+import { RankingInfo } from '@tanstack/match-sorter-utils';
+declare module '@tanstack/react-table' {
+    interface FilterFns {
+        fuzzy: (row: Row<any>, columnId: string, searchValue: string, addMeta: (meta: any) => void) => boolean;
+    }
+    interface FilterMeta {
+        itemRank: RankingInfo;
+    }
+    interface TableMeta<TData extends RowData> {
+        isExpandable?: boolean;
+        isLoading?: boolean;
+        children?: (props: SimpleTableCellTemplateProps, row: Row<TData>, table: Table<SimpleTableRow>) => JSX.Element;
+        [key: string]: any;
+    }
+}
+export type RowItemData = {
+    id: string;
+    name?: string | null;
+    label?: string | null;
+    subType?: string | null;
+    [key: string]: any;
+};
+export type SimpleTableRow = {
+    id: string;
+    parentId?: string;
+    name: string;
+    label: string;
+    parents?: string[];
+    icon?: string | null;
+    iconColor?: string;
+    iconFilled?: boolean;
+    img?: string | null;
+    imgShape?: 'square' | 'circle';
+    startContent?: JSX.Element;
+    endContent?: JSX.Element;
+    subRows: SimpleTableRow[];
+    data: RowItemData;
+    isDisabled?: boolean;
+    disabledMessage?: string;
+    inactive?: boolean;
+};
+export type SimpleTableRowContextMenuContext = {
+    rowId: string;
+    rowIndex: number;
+    row: Row<SimpleTableRow>;
+    selectedRows: string[];
+    isSelected: boolean;
+};
+export type SimpleTableRowContextMenuBuilder = (e: React.MouseEvent<HTMLTableRowElement>, context: SimpleTableRowContextMenuContext) => ContextMenuItemType | ContextMenuItemType[] | undefined;
+export interface SimpleTableProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    data: SimpleTableRow[];
+    isLoading: boolean;
+    error?: string;
+    isExpandable?: boolean;
+    isMultiSelect?: boolean;
+    enableClickToDeselect?: boolean;
+    enableNonFolderIndent?: boolean;
+    forceUpdateTable?: any;
+    globalFilter?: string;
+    meta?: Record<string, any>;
+    rowHeight?: number;
+    imgRatio?: number;
+    onScrollBottom?: () => void;
+    onRename?: (id: string, row: Row<SimpleTableRow>) => void;
+    renamingId?: string | null;
+    onSubmitRename?: (id: string, value: string) => void;
+    onCancelRename?: () => void;
+    onRowDoubleClick?: (id: string, row: Row<SimpleTableRow>) => void;
+    fitContent?: boolean;
+    rowContextMenuBuilders?: SimpleTableRowContextMenuBuilder[];
+    children?: (props: SimpleTableCellTemplateProps, row: Row<SimpleTableRow>, table: Table<SimpleTableRow>) => JSX.Element;
+    pt?: {
+        cell?: Partial<SimpleTableCellTemplateProps>;
+        row?: Partial<React.HTMLAttributes<HTMLTableRowElement>>;
+    };
+}

package/dist/types/containers/SimpleTable/SimpleTableRowTemplate.d.ts

@@ -1,4 +1,7 @@
-import { Icon } from '@ynput/ayon-react-components';
+import { Icon, IconProps, InputText } from '@ynput/ayon-react-components';
+export interface TableRowAction extends IconProps {
+    show?: 'always' | 'hover' | 'hidden';
+}
 export type RowExpanderProps = {
     isRowExpandable?: boolean;
     isRowExpanded?: boolean;
@@ -23,15 +26,24 @@ export interface SimpleTableCellTemplateProps extends React.HTMLAttributes<HTMLD
     onExpandClick?: () => void;
     startContent?: React.ReactNode;
     endContent?: React.ReactNode;
+    badge?: string | React.ReactNode;
+    actions?: TableRowAction[];
+    isRenaming?: boolean;
+    renameInitialValue?: string;
+    onSubmitRename?: (value: string) => void;
+    onCancelRename?: () => void;
+    renamePlaceholder?: string;
     depth?: number;
     isDisabled?: boolean;
     disabledMessage?: string;
     active?: boolean;
+    inactive?: boolean;
     pt?: {
         img?: Partial<React.ImgHTMLAttributes<HTMLImageElement>>;
         expander?: Partial<React.ComponentProps<typeof RowExpander>>;
         icon?: Partial<React.ComponentProps<typeof Icon>>;
         text?: React.HTMLAttributes<HTMLDivElement>;
+        input?: Partial<React.ComponentProps<typeof InputText>>;
     };
 }
 export declare const SimpleTableCellTemplate: import('react').ForwardRefExoticComponent<SimpleTableCellTemplateProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/types/containers/SimpleTable/hooks/useRowKeydown.d.ts

@@ -4,8 +4,9 @@ export type RowKeyboardEvent = KeyboardEvent<HTMLDivElement>;
 interface UseRowKeydownProps<T> {
     handleRowSelect: (event: RowKeyboardEvent, row: Row<T>) => void;
     handleArrowNavigation?: (direction: 'up' | 'down', currentRow: Row<T>, event: RowKeyboardEvent) => void;
+    handleRename?: (event: RowKeyboardEvent, row: Row<T>) => void;
 }
-declare function useRowKeydown<T>({ handleRowSelect, handleArrowNavigation }: UseRowKeydownProps<T>): {
+declare function useRowKeydown<T>({ handleRowSelect, handleArrowNavigation, handleRename, }: UseRowKeydownProps<T>): {
     handleRowKeyDown: (event: RowKeyboardEvent, row: Row<T>) => void;
 };
 export default useRowKeydown;

package/dist/types/containers/SimpleTable/index.d.ts

@@ -1,5 +1,6 @@
 import { default as SimpleTable } from './SimpleTable';
 export * from './SimpleTable';
+export * from './SimpleTable.types';
 export * from './context/SimpleTableContext';
 export * from './SimpleTable.styled';
 export * from './SimpleTableRowTemplate';

package/dist/types/containers/Slicer/context/SlicerContext.d.ts

@@ -1,11 +1,11 @@
 import { ReactNode, ForwardRefExoticComponent, RefAttributes } from 'react';
 import { ExpandedState, RowSelectionState } from '@tanstack/react-table';
-import { SelectionData, SliceType } from '..';
+import { SliceType } from '..';
 import { SimpleTableRow } from '../../SimpleTable';
 import { ProjectModel, Assignees, AttributeModel, ProductType } from '../../../api';
 import { SlicerDropdownFallbackProps } from '../components/SlicerDropdownFallback';
 import { DropdownRef } from '@ynput/ayon-react-components';
-import { PinnedSlice, SliceMap, SliceTypeField } from '../types';
+import { PinnedSlice, SliceTypeField } from '../types';
 import { SlicerContext } from './SlicerContextInstance';
 export declare const SLICER_PAGES_CONFIG: SlicerConfig;
 export type OnSliceTypeChange = (sliceType: SliceType, pinCurrent?: boolean) => void;
@@ -24,11 +24,10 @@ type ExtraSlices = {
     formatAuthors: (project?: ProjectModel) => SimpleTableRow[];
 };
 export type UseExtraSlices = () => ExtraSlices;
-type OnRowSelectionChange = (selection: RowSelectionState, rowData?: SliceMap) => void;
+type OnRowSelectionChange = (selection: RowSelectionState) => void;
 export interface SlicerContextValue {
     rowSelection: RowSelectionState;
     onRowSelectionChange: OnRowSelectionChange;
-    rowSelectionData: SelectionData;
     expanded: ExpandedState;
     onExpandedChange: (expanded: ExpandedState) => void;
     sliceType: SliceType;

package/dist/types/containers/Slicer/hooks/useFiltersWithHierarchy.d.ts

@@ -1,8 +1,8 @@
 import { Filter, FilterValue } from '@ynput/ayon-react-components';
-import { SelectionData } from '..';
+import { RowSelectionState } from '@tanstack/react-table';
 interface UseFiltersWithHierarchyProps {
     sliceFilter: FilterValue | null;
-    persistedHierarchySelection: SelectionData | null;
+    persistedHierarchySelection: RowSelectionState | null;
     filters: Filter[];
     merge?: boolean;
 }

package/dist/types/containers/Slicer/hooks/useSlicerRowSelection.d.ts

@@ -1,5 +1,5 @@
 import { ExpandedState, RowSelectionState } from '@tanstack/react-table';
-import { SelectionData, SliceType } from '../types';
+import { SliceType } from '../types';
 type UseSlicerRowSelectionProps = {
     sliceType: SliceType;
     page: string;
@@ -12,8 +12,6 @@ type UseSlicerRowSelectionProps = {
 export declare const useSlicerRowSelection: ({ sliceType, page, projectName, ...props }: UseSlicerRowSelectionProps) => {
     rowSelection: RowSelectionState;
     setRowSelection: (value: React.SetStateAction<RowSelectionState>, targetSliceType?: SliceType) => void;
-    rowSelectionData: SelectionData;
-    setRowSelectionData: (value: React.SetStateAction<SelectionData>, targetSliceType?: SliceType) => void;
     expanded: ExpandedState;
     setExpanded: (value: React.SetStateAction<ExpandedState>, targetSliceType?: SliceType) => void;
 };

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

@@ -3,15 +3,6 @@ import { SimpleTableRow } from '../SimpleTable';
 import { RowSelectionState, ExpandedState } from '@tanstack/react-table';
 import { FilterValue } from '@ynput/ayon-react-components';
 export type SliceType = 'hierarchy' | 'assignees' | 'status' | 'type' | 'taskType' | 'entityList' | string;
-export type SliceDataItem = {
-    id: string;
-    name?: string | null;
-    label?: string | null;
-    subType?: string | null;
-    path?: string | null;
-    parents?: string[] | null;
-};
-export type SelectionData = Record<string, SliceDataItem>;
 export interface SliceFilter extends FilterValue {
     values: {
         id: string;
@@ -57,6 +48,5 @@ export interface TableData {
 export interface PinnedSlice {
     sliceType: SliceType;
     rowSelection: RowSelectionState;
-    rowSelectionData: SelectionData;
     expanded: ExpandedState;
 }

package/dist/types/containers/Slicer/util/createFilterFromSlicer.d.ts

@@ -1,9 +1,10 @@
 import { ProjectTableAttribute } from '../../ProjectTreeTable/hooks/useAttributesList';
-import { SelectionData, SliceFilter, SliceType } from '../types';
+import { SliceFilter, SliceType } from '../types';
+import { RowSelectionState } from '@tanstack/react-table';
 export type CreateFilterFromSlicer = ({ slice, attribFields, }: {
     slice: {
         sliceType: SliceType;
-        rowSelectionData: SelectionData;
+        rowSelection: RowSelectionState;
     } | null;
     attribFields: ProjectTableAttribute[];
 }) => SliceFilter | null;

package/dist/types/containers/Slicer/util/getSelectionDataState.d.ts

@@ -1,3 +1,3 @@
 import { RowSelectionState } from '@tanstack/react-table';
-import { SliceDataItem, SliceMap } from '../types';
+import { SliceMap } from '../types';
 export declare const getSelectionDataState: (selection: RowSelectionState, data: SliceMap) => Record<string, SliceDataItem>;

package/dist/types/containers/Slicer/util/index.d.ts

@@ -1,2 +1 @@
 export * from './createFilterFromSlicer';
-export * from './getSelectionDataState';

package/dist/types/context/ProjectFoldersContextInstance.d.ts

@@ -0,0 +1,2 @@
+import { ProjectFoldersContextValue } from './ProjectFoldersContext';
+export declare const ProjectFoldersContext: import('react').Context<ProjectFoldersContextValue | undefined>;

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

@@ -1,4 +1,5 @@
 export * from './useLocalStorage';
+export * from './useSessionStorage';
 export * from './useLoadModule';
 export * from './useLoadModules';
 export * from './useScopedStatuses';

package/dist/types/hooks/useGroupByRemoteModules.d.ts

@@ -1,24 +1,7 @@
 import { GroupSettingsFallback } from '../containers/ProjectTreeTable/components/GroupSettingsFallback';
-import { EntityGroup, QueryFilter } from '../api';
-import { TableGroupBy } from '../containers/ProjectTreeTable/context';
-import { Filter } from '@ynput/ayon-react-components';
-type GetGroupQueriesParams = {
-    groups: EntityGroup[];
-    taskGroups?: EntityGroup[];
-    filters: QueryFilter | Filter[] | undefined;
-    groupBy: TableGroupBy;
-    groupPageCounts: Record<string, number>;
-};
-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 useGroupByRemoteModules: () => ProjectTableModulesType;
-export {};

package/dist/types/hooks/useSessionStorage.d.ts

@@ -0,0 +1,4 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare const readSessionStorage: <T>(key: string, fallback: T) => T;
+export declare const writeSessionStorage: <T>(key: string, value: T) => void;
+export declare function useSessionStorage<T>(key: string, defaultValue: T): [T, Dispatch<SetStateAction<T>>];

package/dist/types/util/checkName.d.ts

@@ -1,4 +1,4 @@
-import { EntityNaming } from '../api';
+import { EntityNaming } from '../api/generated/anatomy';
 export interface CheckNameResult {
     valid: boolean;
     error?: string;

package/dist/types/util/getAttributeIcon.d.ts

@@ -1,4 +1,4 @@
-import { AttributeData } from '../api';
+import { AttributeData } from '../api/generated/entityLists';
 type GetAttributesIcon = (name: string, type?: AttributeData['type'], hasEnum?: boolean) => string;
 export declare const getAttributeIcon: GetAttributesIcon;
 export {};