@ynput/ayon-frontend-shared 0.2.35 → 0.2.36

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

@@ -11,6 +11,7 @@ export interface ProjectTableContextType {
     projectName: ProjectTableProviderProps['projectName'];
     users: ProjectTableProviderProps['users'];
     attribFields: ProjectTableProviderProps['attribFields'];
+    attribFieldsScoped: ProjectTableProviderProps['attribFields'];
     error?: string;
     scopes: ProjectTableProviderProps['scopes'];
     tableData: TableRow[];
@@ -20,7 +21,7 @@ export interface ProjectTableContextType {
     fetchNextPage: ProjectTableProviderProps['fetchNextPage'];
     reloadTableData: ProjectTableProviderProps['reloadTableData'];
     getEntityById: (id: string, field?: string) => EntityMap | undefined;
-    taskGroups: ProjectTableProviderProps['taskGroups'];
+    groups: ProjectTableProviderProps['groups'];
     filters: ProjectTableProviderProps['filters'];
     setFilters: ProjectTableProviderProps['setFilters'];
     queryFilters: ProjectTableProviderProps['queryFilters'];
@@ -41,6 +42,7 @@ export interface ProjectTableContextType {
     modules: ProjectTableProviderProps['modules'];
     playerOpen?: ProjectTableProviderProps['playerOpen'];
     onOpenPlayer?: ProjectTableProviderProps['onOpenPlayer'];
+    onResetView?: () => void;
 }
 export declare const ProjectTableContext: import('react').Context<ProjectTableContextType | undefined>;
 export declare const useProjectTableContext: () => ProjectTableContextType;

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

@@ -9,7 +9,7 @@ import { ContextMenuItemConstructors } from '../hooks/useCellContextMenu';
 import { EntityGroup } from '../../../api';
 import { GroupByEntityType } from '../hooks/useBuildGroupByTableData';
 import { PowerpackContextType } from '../../../context';
-import { ProjectTableModulesType } from '../hooks';
+import { ProjectTableModulesType } from '../../../hooks';
 export declare const parseRowId: (rowId: string) => string;
 export type TableUser = {
     name: string;
@@ -32,7 +32,8 @@ export interface ProjectTableProviderProps {
     entitiesMap: EntitiesMap;
     tasksByFolderMap: TasksByFolderMap;
     tableRows?: TableRow[];
-    taskGroups: EntityGroup[];
+    groups: EntityGroup[];
+    groupRowFunc?: (node: any) => TableRow;
     fetchNextPage: (value?: string) => void;
     reloadTableData: () => void;
     filters: Filter[];
@@ -63,5 +64,6 @@ export interface ProjectTableProviderProps {
     }, config?: {
         quickView?: boolean;
     }) => void;
+    onResetView?: () => void;
 }
-export declare const ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, expanded, projectInfo, showHierarchy, loadingTasks, isLoadingMore, isLoading, error, isInitialized, projectName, users, attribFields, scopes, taskGroups, filters, setFilters, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, fetchNextPage, reloadTableData, setExpanded, contextMenuItems, powerpack, modules, groupByConfig, playerOpen, onOpenPlayer, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, expanded, projectInfo, showHierarchy, loadingTasks, isLoadingMore, isLoading, error, isInitialized, projectName, users, attribFields, scopes, groups, groupRowFunc, filters, setFilters, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, fetchNextPage, reloadTableData, setExpanded, contextMenuItems, powerpack, modules, groupByConfig, playerOpen, onOpenPlayer, onResetView, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -3,13 +3,11 @@ 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 './useBuildGroupByTableData';
-export * from './useProjectTableModules';
 export * from './useCheckSelectedCellsVisible';
 export * from './useColumnGroupBy';

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

@@ -20,10 +20,11 @@ export declare const isGroupId: (id: string) => boolean;
 type BuildGroupByTableProps = {
     project?: ProjectModel;
     entities: EntitiesMap;
-    entityType?: GroupByEntityType;
+    entityType: string;
     groups?: EntityGroup[];
     attribFields: ProjectTableAttribute[];
     showEmpty?: boolean;
+    groupRowFunc?: (node: any) => TableRow;
 };
-declare const useBuildGroupByTableData: (props: BuildGroupByTableProps) => (groupBy: TableGroupBy) => TableRow[];
+declare const useBuildGroupByTableData: ({ project, entities, entityType, groups, attribFields, showEmpty, groupRowFunc, }: BuildGroupByTableProps) => (groupBy: TableGroupBy) => TableRow[];
 export default useBuildGroupByTableData;

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

@@ -2,6 +2,7 @@ import { ContextMenuItemType } from '../../ContextMenu/useCreateContextMenu';
 import { ProjectTableAttribute, TableRow } from '../types';
 import { UseHistoryReturn } from './useHistory';
 import { ColumnDef } from '@tanstack/react-table';
+import { EntityMap } from '../utils';
 type ContextEvent = React.MouseEvent<HTMLTableSectionElement, MouseEvent>;
 export type HeaderLabel = {
     id: string;
@@ -11,7 +12,7 @@ export type TableCellContextData = {
     cellId: string;
     columnId: string;
     entityId: string;
-    entityType: 'folder' | 'task' | 'product' | 'version' | undefined;
+    entityType: 'folder' | 'task' | 'product' | 'version' | 'unknown' | undefined;
     parentId?: string;
     attribField: ProjectTableAttribute | undefined;
     column: {
@@ -19,6 +20,7 @@ export type TableCellContextData = {
         label: string;
     };
     isGroup: boolean;
+    data?: EntityMap | undefined;
 };
 type DefaultMenuItem = 'copy-paste' | 'show-details' | 'rename' | 'expand-collapse' | 'inherit' | 'delete' | 'export' | 'create-folder' | 'create-task' | 'open-viewer';
 export type ContextMenuItemConstructor = (e: ContextEvent, cell: TableCellContextData, selectedCells: TableCellContextData[], meta: {
@@ -36,8 +38,9 @@ type CellContextMenuProps = {
     columns?: ColumnDef<TableRow>[];
     headerLabels: HeaderLabel[];
     onOpenNew?: (type: 'folder' | 'task') => void;
+    contextMenuItems?: ContextMenuItemConstructors;
 };
-declare const useCellContextMenu: ({ attribs, headerLabels, onOpenNew }: CellContextMenuProps) => {
+declare const useCellContextMenu: ({ attribs, headerLabels, onOpenNew, contextMenuItems: propsContextMenuItems, }: CellContextMenuProps) => {
     handleTableBodyContextMenu: (e: ContextEvent) => void;
 };
 export default useCellContextMenu;

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

@@ -5,7 +5,7 @@ import { LoadingTasks } from '../types';
 import { TasksByFolderMap } from '../utils';
 import { TableGroupBy } from '../context';
 import { ProjectTableAttribute } from '../hooks/useAttributesList';
-import { ProjectTableModulesType } from './useProjectTableModules';
+import { ProjectTableModulesType } from '../../../hooks';
 type useFetchOverviewDataData = {
     foldersMap: FolderNodeMap;
     tasksMap: TaskNodeMap;

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

@@ -1,9 +1,17 @@
 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) => {
+export declare const isAttribGroupable: (attrib: ProjectTableAttribute, entityType?: string, allowedTypes?: ("string" | "integer" | "float")[], enumOnly?: boolean) => boolean;
+export declare const useGetGroupedFields: ({ allowedTypes, enumOnly, scope, }: {
+    allowedTypes?: ("string" | "integer" | "float")[];
+    enumOnly?: boolean;
+    scope?: string;
+}) => ({
     value: string;
     label: string;
     icon: string;
-}[];
+} | {
+    value: string;
+    label: string;
+    icon: string;
+    scopes: string[];
+})[];

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

@@ -0,0 +1,11 @@
+interface UseGroupBySettingsProps {
+    scope?: string;
+}
+export declare const useGroupBySettings: ({ scope }: UseGroupBySettingsProps) => {
+    id: string;
+    title: string;
+    icon: string;
+    preview: string;
+    component: import("react/jsx-runtime").JSX.Element;
+};
+export {};

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

@@ -0,0 +1,14 @@
+/**
+ * Column Configuration System
+ *
+ * Extensible configuration for controlling column and widget behavior.
+ * Supports per-column configuration for display, behavior, styling, and other settings.
+ */
+export type DisplayConfig = Record<string, boolean>;
+export type ColumnConfig = {
+    display?: DisplayConfig;
+};
+export type ColumnsConfig = Record<string, ColumnConfig>;
+export declare const getDisplayValue: (displayConfig: DisplayConfig | undefined, propertyName: string, layout?: "compact" | "full") => boolean | undefined;
+export declare const getColumnConfig: (columnsConfig: ColumnsConfig | undefined, columnId: string) => ColumnConfig | undefined;
+export declare const getColumnDisplayConfig: (columnsConfig: ColumnsConfig | undefined, columnId: string) => DisplayConfig | undefined;

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

@@ -2,9 +2,10 @@ import { EntityGroup, QueryTasksFoldersApiArg } from '../../../api';
 import { FolderNodeMap, LoadingTasks, TaskNodeMap, TasksByFolderMap } from '.';
 import { ProjectDataContextProps } from '../context';
 import { ExpandedState, OnChangeFn } from '@tanstack/react-table';
-import { ContextMenuItemConstructors, ProjectTableModulesType } from '../hooks';
-import { ReactNode } from 'react';
+import { ContextMenuItemConstructors } from '../hooks';
+import { ProjectTableModulesType } from '../../../hooks';
 import { QueryFilter } from './operations';
+import { ReactNode } from 'react';
 interface EntityMoveData {
     entityId: string;
     entityType: 'folder';

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

@@ -33,24 +33,36 @@ export type TableRow = {
     tags?: string[];
     status?: string;
     updatedAt?: string;
-    createdAt: string;
+    createdAt?: string;
     parentId?: string;
-    folderId: string | null;
+    folderId?: string | null;
     parents?: string[];
-    subRows: TableRow[];
+    folder?: string;
+    product?: string;
+    subRows?: TableRow[];
     icon?: string | null;
     color?: string | null;
     img?: string | null;
     hasReviewables?: boolean;
     hasVersions?: boolean;
+    version?: number | null;
+    versionsCount?: number;
+    versionName?: string;
     startContent?: JSX.Element;
     assignees?: string[];
+    author?: string;
     attrib?: Record<string, any>;
-    links: Record<string, LinkValue>;
+    links?: Record<string, LinkValue>;
     childOnlyMatch?: boolean;
     subType?: string | null;
     isLoading?: boolean;
+    metaType?: 'empty' | 'error';
     group?: GroupData;
+    thumbnail?: {
+        entityId: string;
+        entityType: string;
+        updatedAt: string | undefined;
+    };
 };
 export type MatchingFolder = FolderListItem & {
     childOnlyMatch?: boolean;
@@ -68,6 +80,7 @@ export type EditorTaskNode = Omit<TaskNode, 'links'> & {
         hasNextPage?: string;
     }[];
     links: EntityLink[];
+    hasVersions?: boolean;
 };
 export type EditorVersionNode = {
     id: string;
@@ -93,6 +106,7 @@ export type EditorVersionNode = {
         };
     };
     links: EntityLink[];
+    hasVersions?: boolean;
 };
 type EditorProductNode = {
     id: string;
@@ -112,6 +126,7 @@ type EditorProductNode = {
     allAttrib: string;
     attrib?: Record<string, any>;
     links: EntityLink[];
+    hasVersions?: boolean;
 };
 export type TaskNodeMap = Map<string, EditorTaskNode>;
 export type EntityMap = EditorTaskNode | MatchingFolder | EditorVersionNode | EditorProductNode;

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

@@ -6,6 +6,7 @@ export type FilterForQuery = {
         values?: {
             id: string;
         }[];
+        isCustom?: boolean;
     }[];
     type?: string;
     singleSelect?: boolean;

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

@@ -10,3 +10,5 @@ export * from './localStorageKeys';
 export * from './getTypeDefaultValue';
 export * from './getEntityViewerIds';
 export * from './linksToTableData';
+export * from './restrictedEntity';
+export * from './metaRows';

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

@@ -6,12 +6,7 @@ import { AttributeModel, LoadingTasks } from '../types';
  * @param count - Number of loading rows to generate (default: 50)
  * @returns Array of TableRow objects with loading state
  */
-export declare const generateLoadingRows: (attribs: {
-    name: string;
-}[], count?: number, { type, parentId }?: {
-    type?: string;
-    parentId?: string;
-}) => TableRow[];
+export declare const generateLoadingRows: (count?: number, attrib?: {}) => TableRow[];
 /**
  * Generates an array of dummy attribute models for loading states
  * @param count - Number of dummy attributes to generate (default: 10)

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

@@ -0,0 +1,33 @@
+/**
+ * Utility functions for managing meta rows in tables (empty, loading, error, etc.)
+ */
+export type MetaRowType = 'empty' | 'loading' | 'error' | string;
+/**
+ * Creates an ID for a meta row
+ * @param entityId - The entity ID to create a meta row for
+ * @param type - The type of meta row (empty, loading, error, etc.)
+ * @returns The meta row ID in format `{entityId}__{type}`
+ */
+export declare const createMetaRowId: (entityId: string, type: MetaRowType) => string;
+/**
+ * Parses a meta row ID to extract the entity ID and type
+ * @param metaRowId - The meta row ID to parse
+ * @returns An object with entityId and type, or null if the ID is not a valid meta row ID
+ */
+export declare const parseMetaRowId: (metaRowId: string) => {
+    entityId: string;
+    type: MetaRowType;
+} | null;
+/**
+ * Checks if a row ID is a meta row ID
+ * @param rowId - The row ID to check
+ * @returns true if the row ID is a meta row ID
+ */
+export declare const isMetaRowId: (rowId: string) => boolean;
+/**
+ * Checks if a row ID is a specific type of meta row
+ * @param rowId - The row ID to check
+ * @param type - The meta row type to check for
+ * @returns true if the row ID is a meta row of the specified type
+ */
+export declare const isMetaRowType: (rowId: string, type: MetaRowType) => boolean;

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

@@ -0,0 +1,13 @@
+/**
+ * Constants and utilities for handling restricted entities (entities the user doesn't have access to)
+ */
+export declare const RESTRICTED_ENTITY_TYPE: "unknown";
+export declare const RESTRICTED_ENTITY_NAME = "restricted";
+export declare const RESTRICTED_ENTITY_LABEL = "Access Restricted - Insufficient Permissions";
+export declare const RESTRICTED_ENTITY_ICON = "lock";
+/**
+ * Check if an entity type indicates restricted access
+ * @param type - The entity type to check
+ * @returns true if the entity is restricted (no access), false otherwise
+ */
+export declare const isEntityRestricted: (type: string | undefined) => boolean;

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

@@ -24,6 +24,7 @@ interface EditorCellProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'on
     isReadOnly?: boolean;
     enableCustomValues?: boolean;
     folderId?: string | null;
+    tooltip?: string;
     onChange?: (value: CellValue | CellValue[], key?: 'Enter' | 'Click' | 'Escape') => void;
     pt?: {
         enum?: Partial<EnumWidgetProps>;

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

@@ -3,5 +3,6 @@ export interface DateWidgetProps extends Omit<React.HTMLAttributes<HTMLSpanEleme
     value?: string;
     isReadOnly?: boolean;
     isInherited?: boolean;
+    showTime?: boolean;
 }
 export declare const DateWidget: import('react').ForwardRefExoticComponent<DateWidgetProps & import('react').RefAttributes<HTMLSpanElement>>;

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

@@ -0,0 +1,9 @@
+type EmptyWidgetProps = {
+    label: string;
+};
+/**
+ * Widget for displaying empty rows (e.g., products with no versions)
+ * Shows a simple label indicating the empty state
+ */
+export declare const EmptyWidget: ({ label }: EmptyWidgetProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,15 +1,17 @@
+import { DisplayConfig } from '../types/columnConfig';
 type EntityNameWidgetProps = {
     id: string;
     label: string;
     name: string;
     path?: string | null;
-    showHierarchy?: boolean;
+    isExpandable?: boolean;
     icon?: string | null;
     type: string;
     isExpanded: boolean;
     toggleExpandAll: (id: string) => void;
     toggleExpanded: () => void;
     rowHeight?: number;
+    columnDisplayConfig?: DisplayConfig;
 };
-export declare const EntityNameWidget: ({ id, label, name, path, showHierarchy, icon, type, isExpanded, toggleExpandAll, toggleExpanded, rowHeight, }: EntityNameWidgetProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EntityNameWidget: ({ id, label, name, path, isExpandable, icon, type, isExpanded, toggleExpandAll, toggleExpanded, rowHeight, columnDisplayConfig, }: EntityNameWidgetProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -9,7 +9,6 @@ export interface EnumTemplateProps extends React.HTMLAttributes<HTMLSpanElement>
     isItem?: boolean;
     isSelected?: boolean;
     isReadOnly?: boolean;
-    rowHeight?: number;
     pt?: {
         icon?: Partial<IconProps>;
         img?: Partial<React.ImgHTMLAttributes<HTMLImageElement>>;
@@ -18,4 +17,4 @@ export interface EnumTemplateProps extends React.HTMLAttributes<HTMLSpanElement>
         close?: Partial<IconProps>;
     };
 }
-export declare const EnumCellValue: ({ selectedOptions, placeholder, hasMultipleValues, isMultiSelect, isOpen, isItem, isSelected, isReadOnly, rowHeight, className, pt, ...props }: EnumTemplateProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EnumCellValue: ({ selectedOptions, placeholder, hasMultipleValues, isMultiSelect, isOpen, isItem, isSelected, isReadOnly, className, pt, ...props }: EnumTemplateProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+type ErrorWidgetProps = {
+    label: string;
+};
+/**
+ * Widget for displaying Error rows
+ * Shows a simple label indicating the Error state
+ */
+export declare const ErrorWidget: ({ label }: ErrorWidgetProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,7 +1,7 @@
 import { FC } from 'react';
 interface LoadMoreWidgetProps {
     id: string | undefined;
-    label: string;
+    label?: string;
     onLoadMore: (id?: string) => void;
 }
 declare const LoadMoreWidget: FC<LoadMoreWidgetProps>;

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

@@ -0,0 +1,10 @@
+type MetaWidgetProps = {
+    metaType?: 'empty' | 'error';
+    label: string;
+};
+/**
+ * Meta widget container that switches between different meta widgets based on metaType
+ * Displays appropriate widget for empty or error states
+ */
+export declare const MetaWidget: ({ metaType, label }: MetaWidgetProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

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

@@ -8,3 +8,6 @@ export { EntityNameWidget } from './EntityNameWidget';
 export { GroupHeaderWidget } from './GroupHeaderWidget';
 export { ThumbnailWidget } from './ThumbnailWidget';
 export { LinksWidget } from './LinksWidget';
+export { EmptyWidget } from './EmptyWidget';
+export { ErrorWidget } from './ErrorWidget';
+export { MetaWidget } from './MetaWidget';

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

@@ -33,6 +33,7 @@ export type SimpleTableRow = {
     iconColor?: string;
     iconFilled?: boolean;
     img?: string | null;
+    imgShape?: 'square' | 'circle';
     startContent?: JSX.Element;
     endContent?: JSX.Element;
     subRows: SimpleTableRow[];
@@ -53,11 +54,12 @@ export interface SimpleTableProps {
     globalFilter?: string;
     meta?: Record<string, any>;
     rowHeight?: number;
+    imgRatio?: number;
     onScrollBottom?: () => void;
     children?: (props: SimpleTableCellTemplateProps, row: Row<SimpleTableRow>, table: Table<SimpleTableRow>) => JSX.Element;
     pt?: {
-        cell?: SimpleTableCellTemplateProps;
-        row?: React.HTMLAttributes<HTMLTableRowElement>;
+        cell?: Partial<SimpleTableCellTemplateProps>;
+        row?: Partial<React.HTMLAttributes<HTMLTableRowElement>>;
     };
 }
 declare const SimpleTable: FC<SimpleTableProps>;

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

@@ -1,3 +1,4 @@
+import { Icon } from '@ynput/ayon-react-components';
 export type RowExpanderProps = {
     isRowExpandable?: boolean;
     isRowExpanded?: boolean;
@@ -12,6 +13,9 @@ export interface SimpleTableCellTemplateProps extends React.HTMLAttributes<HTMLD
     parents?: string[];
     iconColor?: string;
     iconFilled?: boolean;
+    img?: string | null;
+    imgShape?: 'square' | 'circle';
+    imgRatio?: number;
     isRowExpandable?: boolean;
     isRowExpanded?: boolean;
     isTableExpandable?: boolean;
@@ -23,5 +27,11 @@ export interface SimpleTableCellTemplateProps extends React.HTMLAttributes<HTMLD
     isDisabled?: boolean;
     disabledMessage?: string;
     active?: boolean;
+    pt?: {
+        img?: Partial<React.ImgHTMLAttributes<HTMLImageElement>>;
+        expander?: Partial<React.ComponentProps<typeof RowExpander>>;
+        icon?: Partial<React.ComponentProps<typeof Icon>>;
+        text?: React.HTMLAttributes<HTMLDivElement>;
+    };
 }
 export declare const SimpleTableCellTemplate: import('react').ForwardRefExoticComponent<SimpleTableCellTemplateProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -3,8 +3,9 @@ import { Row } from '@tanstack/react-table';
 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;
 }
-declare function useRowKeydown<T>({ handleRowSelect }: UseRowKeydownProps<T>): {
+declare function useRowKeydown<T>({ handleRowSelect, handleArrowNavigation }: UseRowKeydownProps<T>): {
     handleRowKeyDown: (event: RowKeyboardEvent, row: Row<T>) => void;
 };
 export default useRowKeydown;

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

@@ -5,6 +5,8 @@ export type SliceDataItem = {
     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 {

package/dist/types/containers/Views/ViewItem/ViewItem.d.ts

@@ -8,8 +8,8 @@ export interface ViewItem {
     isEditable?: boolean;
     isSaveable?: boolean;
     highlighted?: 'save' | 'edit';
-    onEdit?: (e: React.MouseEvent<HTMLButtonElement>) => void;
-    onSave?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    onEdit?: (e: React.MouseEvent<HTMLButtonElement>, viewId: string) => void;
+    onSave?: (e: React.MouseEvent<HTMLButtonElement>, viewId: string) => void;
     onResetView?: (e: React.MouseEvent<HTMLButtonElement>) => void;
     onClick?: (e: React.MouseEvent<HTMLLIElement>) => void;
 }

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

@@ -20,5 +20,5 @@ export { WORKING_VIEW_ID, NEW_VIEW_ID } from './ViewsMenuContainer/ViewsMenuCont
 export type ViewFormData = Required<Pick<GetViewApiResponse, 'label' | 'scope' | 'visibility' | 'owner' | 'accessLevel'> & {
     access: Record<string, AccessLevel>;
 }>;
-export declare const viewTypes: readonly ["overview", "taskProgress", "lists", "reviews", "reports"];
+export declare const viewTypes: readonly ["overview", "taskProgress", "versions", "lists", "reviews", "reports"];
 export type ViewType = (typeof viewTypes)[number];

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

@@ -18,6 +18,14 @@ export type DetailsPanelPip = {
     }[];
     scope: string;
 };
+export type Entities = {
+    entityType: DetailsPanelEntityType;
+    entities: {
+        id: string;
+        projectName: string;
+    }[];
+    entitySubTypes?: string[];
+};
 export interface OpenStateByScope {
     [scope: string]: boolean;
 }
@@ -69,6 +77,8 @@ export interface DetailsPanelContextType extends DetailsPanelContextProps {
     pip: DetailsPanelPip | null;
     openPip: (pip: DetailsPanelPip) => void;
     closePip: () => void;
+    entities: Entities | null;
+    setEntities: (entities: Entities | null) => void;
     feedAnnotations: SavedAnnotationMetadata[];
     setFeedAnnotations: (annotations: SavedAnnotationMetadata[]) => void;
     onPowerFeature: (feature: PowerpackFeature) => void;

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

@@ -6,5 +6,7 @@ export * from './useEntityUpdate';
 export * from './useActionTriggers';
 export * from './useUserProjectConfig';
 export * from './useHierarchyTable';
-export * from './useTagStyling';
 export * from './useQueryArgumentChangeLoading';
+export * from './useGetEntityGroups';
+export * from './useGroupedPagination';
+export * from './useGroupByRemoteModules';

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

@@ -0,0 +1,11 @@
+import { TableGroupBy } from '../containers/ProjectTreeTable/context';
+type GetEntityGroupsProps = {
+    groupBy?: TableGroupBy;
+    projectName: string;
+    entityType: string;
+};
+export declare const useGetEntityGroups: ({ groupBy, projectName, entityType }: GetEntityGroupsProps) => {
+    groups: import('../api').EntityGroup[];
+    error: import('@reduxjs/toolkit/query').FetchBaseQueryError | import('@reduxjs/toolkit').SerializedError | undefined;
+};
+export {};

package/dist/types/{containers/ProjectTreeTable/hooks/useProjectTableModules.d.ts → hooks/useGroupByRemoteModules.d.ts}

@@ -1,8 +1,9 @@
-import { GroupSettingsFallback } from '../components/GroupSettingsFallback';
-import { EntityGroup, QueryFilter } from '../../../api';
-import { TableGroupBy } from '../context';
+import { GroupSettingsFallback } from '../containers/ProjectTreeTable/components/GroupSettingsFallback';
+import { EntityGroup, QueryFilter } from '../api';
+import { TableGroupBy } from '../containers/ProjectTreeTable/context';
 type GetGroupQueriesParams = {
-    taskGroups: EntityGroup[];
+    groups: EntityGroup[];
+    taskGroups?: EntityGroup[];
     filters: QueryFilter | undefined;
     groupBy: TableGroupBy;
     groupPageCounts: Record<string, number>;
@@ -18,5 +19,5 @@ export type ProjectTableModulesType = {
     requiredVersion?: string;
     isLoading: boolean;
 };
-export declare const useProjectTableModules: () => ProjectTableModulesType;
+export declare const useGroupByRemoteModules: () => ProjectTableModulesType;
 export {};

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

@@ -0,0 +1,25 @@
+import { EntityGroup } from '../api';
+type UseGroupedPaginationProps = {
+    groups: EntityGroup[];
+};
+type UseGroupedPaginationReturn = {
+    pageCounts: Record<string, number>;
+    setPageCounts: (counts: Record<string, number>) => void;
+    incrementPageCount: (groupValue: string) => void;
+};
+/**
+ * Generic hook for managing pagination state across grouped entities.
+ * Initializes page counts for each group and provides methods to update them.
+ *
+ * Works with any entity type (tasks, assets, shots, etc.) that uses EntityGroup.
+ *
+ * @param groups - Array of entity groups
+ * @returns Object containing pageCounts, setPageCounts, and incrementPageCount
+ *
+ * @example
+ * const { pageCounts, incrementPageCount } = useGroupedPagination({ groups: entityGroups })
+ * // Later, fetch next page for a specific group
+ * incrementPageCount('groupValue')
+ */
+export declare const useGroupedPagination: ({ groups, }: UseGroupedPaginationProps) => UseGroupedPaginationReturn;
+export {};