@ynput/ayon-frontend-shared 0.3.31 → 0.3.33

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

@@ -1,12 +1,4 @@
 import { RefObject } from 'react';
-type Operation = {
-    id: string;
-    projectName: string;
-    currentAssignees: any[];
-    data: {
-        updatedAt: string;
-    };
-};
 export type EntityPanelUploaderProps = {
     entityType: string;
     entities: any[];
@@ -16,9 +8,7 @@ export type EntityPanelUploaderProps = {
     thumbnailInputRef: RefObject<HTMLInputElement>;
     versionsInputRef: RefObject<HTMLInputElement>;
     children?: JSX.Element | JSX.Element[];
-    onUploaded?: (operations: Operation[]) => void;
     resetFileUploadState?: () => void;
     onVersionCreated?: (versionId: string) => void;
 };
-export declare const EntityPanelUploader: ({ children, entityType, entities, projectName, thumbnailInputRef, versionsInputRef, onUploaded, onVersionCreated, }: EntityPanelUploaderProps) => import("react/jsx-runtime").JSX.Element;
-export {};
+export declare const EntityPanelUploader: ({ children, entityType, entities, projectName, thumbnailInputRef, versionsInputRef, onVersionCreated, }: EntityPanelUploaderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/SearchFilter/filterScopeRegistry.d.ts

@@ -0,0 +1,5 @@
+import { FilterFieldType, ScopeWithFilterTypes } from '..';
+type ScopeType = ScopeWithFilterTypes['scope'];
+export declare const FILTER_TYPES_BY_SCOPE: Record<ScopeType, FilterFieldType[]>;
+export declare const buildScopes: (scopes: ScopeType[], exclude?: Partial<Record<ScopeType, FilterFieldType[]>>) => ScopeWithFilterTypes[];
+export {};

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

@@ -1,2 +1,3 @@
 export * from './useBuildFilterOptions';
 export * from './filterDates';
+export * from './filterScopeRegistry';

package/dist/types/components/Thumbnail/StackedThumbnails.d.ts

@@ -7,10 +7,10 @@ type Thumbnail = {
     projectName?: string;
     icon?: string;
     color?: string;
-    updatedAt?: string;
+    thumbnailHash?: string;
     src?: string;
 };
-export interface StackedThumbnailsProps extends Omit<ThumbnailProps, 'entityType' | 'entityId' | 'projectName'> {
+export interface StackedThumbnailsProps extends Omit<ThumbnailProps, 'entityType' | 'entityId' | 'projectName' | 'thumbnailHash'> {
     thumbnails?: Thumbnail[];
     isLoading?: boolean;
     className?: string;

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

@@ -5,7 +5,7 @@ export interface ThumbnailProps extends Omit<HTMLAttributes<HTMLDivElement>, 'co
     entityId?: string;
     icon?: string | null;
     color?: string | null;
-    entityUpdatedAt?: string;
+    thumbnailHash?: string;
     isLoading?: boolean;
     shimmer?: boolean;
     className?: string;
@@ -14,4 +14,4 @@ export interface ThumbnailProps extends Omit<HTMLAttributes<HTMLDivElement>, 'co
     hoverIcon?: string;
     showBorder?: boolean;
 }
-export declare const Thumbnail: ({ projectName, entityType, entityId, icon, color, entityUpdatedAt, isLoading, shimmer, className, disabled, src, hoverIcon, showBorder, ...props }: ThumbnailProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Thumbnail: ({ projectName, entityType, entityId, icon, color, thumbnailHash, isLoading, shimmer, className, disabled, src, hoverIcon, showBorder, ...props }: ThumbnailProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -4,7 +4,7 @@ export interface ThumbnailSimpleProps extends React.HTMLAttributes<HTMLDivElemen
     entityType: string;
     entityId: string;
     icon?: string;
-    entityUpdatedAt: string | number;
+    thumbnailHash?: string;
     isLoading?: boolean;
     disabled?: boolean;
     src?: string;

package/dist/types/config/powerpackFeatures.d.ts

@@ -1,5 +1,5 @@
 import { PowerpackDialogType } from '../context';
-export type PowerpackFeature = 'slicer' | 'annotations' | 'releases' | 'advancedFilters' | 'listAttributes' | 'listFolders' | 'listAccess' | 'groupAttributes' | 'sharedViews' | 'commentCategories' | 'projectFolders';
+export type PowerpackFeature = 'slicer' | 'annotations' | 'releases' | 'advancedFilters' | 'listAttributes' | 'listFolders' | 'listAccess' | 'groupAttributes' | 'sharedViews' | 'commentCategories' | 'projectFolders' | 'columnSummaries';
 export declare const powerpackFeatureOrder: PowerpackFeature[];
 export declare const powerpackFeatures: {
     [key in PowerpackFeature]: Omit<PowerpackDialogType, 'priority'>;

package/dist/types/containers/DetailsPanel/containers/FeedWrapper.d.ts

@@ -6,6 +6,7 @@ interface FeedWrapperProps {
     projectInfo: any;
     projectName: string;
     entityType: string;
+    thumbnailHash?: string;
     disabled: boolean;
     readOnly: boolean;
     isSlideOut?: boolean;

package/dist/types/containers/DetailsPanel/helpers/getThumbnails.d.ts

@@ -12,13 +12,13 @@ type Entity = {
     product?: {
         productType: string;
     };
-    updatedAt: string;
+    thumbnailHash: string;
 };
 declare const getThumbnails: (entities: Entity[], entityType: DetailsPanelEntityType, icons: EntityTypeIcons) => {
     icon: string | undefined;
     id: string;
     type: "version" | "folder" | "task";
-    updatedAt: string;
+    thumbnailHash: string;
     projectName: string;
 }[] | {
     icon: string;

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

@@ -6,5 +6,6 @@ export type FeedProps = {
     statuses: Status[];
     entityListId?: string | undefined;
     isSlideOut?: boolean;
+    versionReview?: boolean;
 };
-export declare const Feed: ({ disabled, readOnly, statuses, entityListId, isSlideOut, }: FeedProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Feed: ({ disabled, readOnly, statuses, entityListId, isSlideOut, versionReview, }: FeedProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/containers/Feed/components/ActivityDate.d.ts

@@ -1,3 +1,4 @@
+export declare const REFRESH_INTERVAL_MS = 10000;
 export declare const getFuzzyDate: (date: Date) => string;
 interface ActivityDateProps extends React.HTMLAttributes<HTMLElement> {
     date?: string;

package/dist/types/containers/Feed/components/ActivityVersionReview/ActivityVersionReview.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { VersionReviewFeedback } from '../CommentInput/CommentInput';
+interface ActivityVersionReviewProps {
+    entityType?: string;
+    activity: {
+        authorName?: string;
+        authorFullName?: string;
+        createdAt?: string;
+        activityData: {
+            feedback: VersionReviewFeedback;
+            category: string;
+        };
+        [key: string]: any;
+    };
+}
+export declare const getVerbForFeedback: (feedback: VersionReviewFeedback) => "requested changes" | "approved this";
+export declare const getVerbForFeedbackBody: (feedback: VersionReviewFeedback, entityType: string) => string;
+export declare const getIconForFeedback: (feedback: VersionReviewFeedback) => "refresh" | "task_alt";
+declare const ActivityVersionReview: React.FC<ActivityVersionReviewProps>;
+export default ActivityVersionReview;

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

@@ -0,0 +1,3 @@
+export declare const VersionReview: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, never>>> & string;
+export declare const Body: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+export declare const Text: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;

package/dist/types/containers/Feed/components/ActivityVersions/ActivityVersions.d.ts

@@ -5,6 +5,7 @@ interface Version {
     productId: string;
     productName: string;
     updatedAt: string;
+    thumbnailHash?: string;
     comment?: string;
 }
 interface ActivityVersionsProps {

package/dist/types/containers/Feed/components/CommentInput/CommentInput.d.ts

@@ -1,4 +1,5 @@
 import { FC } from 'react';
+import { FeedActivity } from '../../../../api';
 export declare const mentionTypeOptions: {
     '@@@': {
         id: string;
@@ -11,12 +12,19 @@ export declare const mentionTypeOptions: {
         isCircle: boolean;
     };
 };
+export declare enum VersionReviewFeedback {
+    APPROVE = "approve",
+    REQUEST_CHANGES = "request_changes"
+}
 interface CommentInputProps {
     initValue: string | null;
     initFiles?: any[];
     initCategory?: string | null;
     data?: any;
+    versionReview: boolean;
+    lastOwnVersionReview?: FeedActivity;
     onSubmit: (markdown: string, files: any[], data?: any) => Promise<void>;
+    onReview?: (feedback: VersionReviewFeedback) => void;
     isEditing?: boolean;
     disabled?: boolean;
     isLoading?: boolean;

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

@@ -8,6 +8,25 @@ export declare const categoryColorCss: ($categoryPrimary?: string, $categorySeco
 export declare const Comment: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof CommentProps> & CommentProps, never> & Partial<Pick<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof CommentProps> & CommentProps, never>>> & string;
 export declare const Footer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLElement>, HTMLElement>, never>>> & string;
 export declare const Buttons: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+export declare const SubmitButtons: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & {
+    as?: import('styled-components').WebTarget | undefined;
+    forwardedAs?: import('styled-components').WebTarget | undefined;
+}, "ref"> & {
+    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> & Partial<Pick<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & {
+    as?: import('styled-components').WebTarget | undefined;
+    forwardedAs?: import('styled-components').WebTarget | undefined;
+}, "ref"> & {
+    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;
 export declare const Markdown: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 export declare const Dropzone: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 export declare const Placeholder: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;
+export declare const VersionReviewButtons: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+export declare const VersionReviewButtonsSpacer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+export declare const VersionReviewButton: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<Omit<import('@ynput/ayon-react-components').ButtonProps & import('react').RefAttributes<HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | 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<HTMLButtonElement> | null | undefined;
+}, never> & Partial<Pick<Omit<import('@ynput/ayon-react-components').ButtonProps & import('react').RefAttributes<HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | 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<HTMLButtonElement> | null | undefined;
+}, never>>> & string & Omit<import('react').ForwardRefExoticComponent<import('@ynput/ayon-react-components').ButtonProps & import('react').RefAttributes<HTMLButtonElement>>, keyof import('react').Component<any, {}, any>>;
+export declare const LastOwnVersionReview: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;

package/dist/types/containers/Feed/components/CommentInput/VersionReviewPill.d.ts

@@ -0,0 +1,7 @@
+import { FeedActivity } from '../../../../api';
+type Props = {
+    separate: boolean;
+    lastOwnVersionReview: FeedActivity;
+};
+export declare const VersionReviewPill: ({ separate, lastOwnVersionReview }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/containers/Feed/hooks/useCategoryData.d.ts

@@ -0,0 +1,7 @@
+export declare function useCategoryData(category?: string): {
+    categoryData: import('../../../api').ActivityCategory | {
+        name: string;
+        color: string;
+    } | null;
+    categoryNotFound: boolean;
+};

package/dist/types/containers/Feed/hooks/useCommentMutations.d.ts

@@ -1,3 +1,4 @@
+import { VersionReviewFeedback } from '../components/CommentInput/CommentInput';
 interface Entity {
     id: string;
     subTitle?: string;
@@ -25,6 +26,7 @@ declare const useCommentMutations: ({ projectName, entityType, entities, filter,
     submitComment: (value: string, files?: File[], data?: any) => Promise<void>;
     updateComment: (activity: Activity, value: string, files?: File[], data?: any) => Promise<void>;
     deleteComment: (id: string, entityId: string, refs?: any[]) => Promise<void>;
+    submitReview: (feedback: VersionReviewFeedback) => Promise<void>;
     isSaving: boolean;
 };
 export default useCommentMutations;

package/dist/types/containers/Feed/hooks/useGetFeedActivitiesData.d.ts

@@ -75,6 +75,7 @@ declare const useGetFeedActivitiesData: ({ entities, filter, activityTypes, proj
             last?: import('../../../api').InputMaybe<import('../../../api').Scalars["Int"]["input"]>;
             referenceTypes?: import('../../../api').InputMaybe<Array<import('../../../api').Scalars["String"]["input"]> | import('../../../api').Scalars["String"]["input"]>;
             activityTypes?: import('../../../api').InputMaybe<Array<import('../../../api').Scalars["String"]["input"]> | import('../../../api').Scalars["String"]["input"]>;
+            mine?: import('../../../api').InputMaybe<import('../../../api').Scalars["Boolean"]["input"]>;
         }>, "cursor" | "first" | "last"> & {
             filter?: any;
         };
@@ -113,6 +114,7 @@ declare const useGetFeedActivitiesData: ({ entities, filter, activityTypes, proj
             last?: import('../../../api').InputMaybe<import('../../../api').Scalars["Int"]["input"]>;
             referenceTypes?: import('../../../api').InputMaybe<Array<import('../../../api').Scalars["String"]["input"]> | import('../../../api').Scalars["String"]["input"]>;
             activityTypes?: import('../../../api').InputMaybe<Array<import('../../../api').Scalars["String"]["input"]> | import('../../../api').Scalars["String"]["input"]>;
+            mine?: import('../../../api').InputMaybe<import('../../../api').Scalars["Boolean"]["input"]>;
         }>, "cursor" | "first" | "last"> & {
             filter?: any;
         };
@@ -158,6 +160,7 @@ declare const useGetFeedActivitiesData: ({ entities, filter, activityTypes, proj
             last?: import('../../../api').InputMaybe<import('../../../api').Scalars["Int"]["input"]>;
             referenceTypes?: import('../../../api').InputMaybe<Array<import('../../../api').Scalars["String"]["input"]> | import('../../../api').Scalars["String"]["input"]>;
             activityTypes?: import('../../../api').InputMaybe<Array<import('../../../api').Scalars["String"]["input"]> | import('../../../api').Scalars["String"]["input"]>;
+            mine?: import('../../../api').InputMaybe<import('../../../api').Scalars["Boolean"]["input"]>;
         }>, "cursor" | "first" | "last"> & {
             filter?: any;
         };

package/dist/types/containers/Feed/hooks/useLastVersionReview.d.ts

@@ -0,0 +1,11 @@
+import { FeedActivity } from '../../../api';
+type Args = {
+    projectName: string;
+    enabled: boolean;
+    entityIds: string[];
+    activities: FeedActivity[];
+    loadingActivities: boolean;
+    userName: string;
+};
+export declare function useLastVersionReview({ projectName, enabled, entityIds, activities, loadingActivities, userName }: Args): FeedActivity | undefined;
+export {};

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

@@ -2,8 +2,9 @@ import { Virtualizer } from '@tanstack/react-virtual';
 import { Table, RowData } from '@tanstack/react-table';
 import { TableRow } from './types/table';
 import { DefaultColumns, TreeTableExtraColumn } from './buildTreeTableColumns';
+import { FieldStats } from '../../api';
 import { ContextMenuItemConstructors } from './hooks/useCellContextMenu';
-import { BuiltInFieldOptions } from './types';
+import { BuiltInFieldOptions, MainCountLabels } from './types';
 import { ToggleExpandAll } from './context/ProjectTableContext';
 import { EntityUpdate } from './hooks/useUpdateTableData';
 import { UniqueIdentifier } from '@dnd-kit/core';
@@ -22,7 +23,6 @@ declare module '@tanstack/react-table' {
         columnsConfig?: ColumnsConfig;
     }
 }
-export declare const DRAG_HANDLE_COLUMN_ID = "drag-handle";
 export interface ProjectTreeTableProps extends React.HTMLAttributes<HTMLDivElement> {
     scope: string;
     sliceId: string;
@@ -41,6 +41,11 @@ export interface ProjectTreeTableProps extends React.HTMLAttributes<HTMLDivEleme
     onRowReorder?: (active: UniqueIdentifier, over: UniqueIdentifier | null) => void;
     dndActiveId?: UniqueIdentifier | null;
     columnsConfig?: ColumnsConfig;
+    showColumnSummaries?: boolean;
+    fieldStats?: FieldStats[];
+    groupFieldStats?: FieldStats[];
+    fieldStatsLoading?: boolean;
+    mainCountLabels?: MainCountLabels;
     onScrollBottomGroupBy?: (groupValue: string) => void;
     contextMenuItems?: ContextMenuItemConstructors;
     onColumnVisibleChange?: (changes: Record<string, boolean>) => void;
@@ -50,7 +55,7 @@ export interface ProjectTreeTableProps extends React.HTMLAttributes<HTMLDivEleme
         head?: Partial<TableHeadProps>;
     };
 }
-export declare const ProjectTreeTable: ({ scope, sliceId, onScroll, onScrollBottom, onOpenNew, readOnly, excludedColumns, excludedSorting, extraColumns, includeLinks, isLoading: isLoadingProp, isExpandable, enableSorting, clientSorting, sortableRows, onRowReorder, dndActiveId, columnsConfig, onScrollBottomGroupBy, contextMenuItems: propsContextMenuItems, onColumnVisibleChange, onColumnVisibleChangeSubscribed, pt, ...props }: ProjectTreeTableProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ProjectTreeTable: ({ scope, sliceId, onScroll, onScrollBottom, onOpenNew, readOnly, excludedColumns, excludedSorting, extraColumns, includeLinks, isLoading: isLoadingProp, isExpandable, enableSorting, clientSorting, sortableRows, onRowReorder, dndActiveId, columnsConfig, showColumnSummaries, fieldStats, groupFieldStats, fieldStatsLoading, mainCountLabels, onScrollBottomGroupBy, contextMenuItems: propsContextMenuItems, onColumnVisibleChange, onColumnVisibleChangeSubscribed, 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/ProjectTreeTable.styled.d.ts

@@ -12,9 +12,11 @@ type TableCellProps = {
     $isLastPinned?: boolean;
 };
 export declare const TD: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "$isLastPinned"> & TableCellProps, never> & Partial<Pick<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "$isLastPinned"> & TableCellProps, never>>> & string;
+export declare const ColumnDividers: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 export declare const TableHeader: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, never>>> & string;
 export declare const TableWrapper: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 export declare const TableContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 export declare const LinkColumnHeader: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 export declare const AnimatedEmptyPlaceholder: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+export declare const SummaryPowerFeature: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;
 export {};

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

@@ -1,8 +1,8 @@
 import { ColumnDef, Row } from '@tanstack/react-table';
 import { TableRow } from './types/table';
 import { ProjectTableAttribute, BuiltInFieldOptions } from './types';
-import { ROW_SELECTION_COLUMN_ID } from './context/SelectionCellsContext';
 import { TableGroupBy } from './context';
+import { ROW_SELECTION_COLUMN_ID } from './constants';
 import { LinkTypeModel } from '../../api';
 export declare const isEntityExpandable: (entityType: string) => boolean;
 export declare const COLUMN_MIN_SIZE = 50;

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

@@ -0,0 +1,14 @@
+import { FC, ReactNode } from 'react';
+import { Table } from '@tanstack/react-table';
+import { Virtualizer } from '@tanstack/react-virtual';
+import { TableRow } from '../types/table';
+export interface TableFooterRowProps {
+    columnVirtualizer: Virtualizer<HTMLDivElement, HTMLTableCellElement>;
+    table: Table<TableRow>;
+    virtualPaddingLeft: number | undefined;
+    virtualPaddingRight: number | undefined;
+    renderCellContent?: (columnId: string) => ReactNode;
+    onClick?: () => void;
+    isLoading?: boolean;
+}
+export declare const TableFooterRow: FC<TableFooterRowProps>;

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

@@ -0,0 +1,2 @@
+export declare const ROW_SELECTION_COLUMN_ID = "__row_selection__";
+export declare const DRAG_HANDLE_COLUMN_ID = "drag-handle";

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

@@ -1,6 +1,7 @@
 import { default as React } from 'react';
 import { ColumnOrderState, ColumnPinningState, OnChangeFn, VisibilityState, ColumnSizingState, SortingState } from '@tanstack/react-table';
 import { GroupByConfig } from '../components/GroupSettingsFallback';
+import { SummaryCalc, SummaryFormat, RowScope } from '../types/summaryTypes';
 export interface TableGroupBy {
     desc: boolean;
     id: string;
@@ -10,6 +11,9 @@ export type ColumnsConfig = {
     columnOrder: ColumnOrderState;
     columnPinning: ColumnPinningState;
     columnSizing: ColumnSizingState;
+    columnSummaries?: Record<string, SummaryCalc>;
+    columnSummaryScopes?: Record<string, RowScope>;
+    columnSummaryFormats?: Record<string, SummaryFormat>;
     sorting?: SortingState;
     groupBy?: TableGroupBy;
     groupByConfig?: {
@@ -36,6 +40,12 @@ export interface ColumnSettingsContextType {
     columnSizing: ColumnSizingState;
     setColumnSizing: (columnSizing: ColumnSizingState) => void;
     columnSizingOnChange: OnChangeFn<ColumnSizingState>;
+    columnSummaries: Record<string, SummaryCalc>;
+    updateColumnSummary: (columnId: string, calc: SummaryCalc) => void;
+    columnSummaryScopes: Record<string, RowScope>;
+    updateColumnSummaryScope: (columnId: string, scope: RowScope) => void;
+    columnSummaryFormats: Record<string, SummaryFormat>;
+    updateColumnSummaryFormat: (columnId: string, format: SummaryFormat) => void;
     sorting: SortingState;
     updateSorting: (sorting: SortingState) => void;
     sortingOnChange: OnChangeFn<SortingState>;

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

@@ -32,6 +32,7 @@ export interface ProjectTableProviderProps {
     entitiesMap: EntitiesMap;
     tasksByFolderMap: TasksByFolderMap;
     tableRows?: TableRow[];
+    selectedFolders?: string[];
     groups: EntityGroup[];
     groupRowFunc?: (node: any) => TableRow;
     overrideGroupBy?: TableGroupBy;
@@ -76,4 +77,4 @@ export interface ProjectTableProviderProps {
     useLocation?: typeof useLocation;
     useSearchParams?: typeof useSearchParams;
 }
-export declare const ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, expanded, showHierarchy, loadingTasks, isLoadingMore, isLoading, error, isInitialized, users, attribFields, scopes, groups, groupRowFunc, overrideGroupBy, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, fetchNextPage, reloadTableData, setExpanded, contextMenuItems, powerpack, modules, groupByConfig, hierarchyOptions, hierarchyActive, isFlatFolderView, SubtasksManager, playerOpen, onOpenPlayer, onResetView, useParams, useNavigate, useLocation, useSearchParams, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, selectedFolders, expanded, showHierarchy, loadingTasks, isLoadingMore, isLoading, error, isInitialized, users, attribFields, scopes, groups, groupRowFunc, overrideGroupBy, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, fetchNextPage, reloadTableData, setExpanded, contextMenuItems, powerpack, modules, groupByConfig, hierarchyOptions, hierarchyActive, isFlatFolderView, SubtasksManager, playerOpen, onOpenPlayer, onResetView, useParams, useNavigate, useLocation, useSearchParams, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,6 +1,5 @@
 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 {
     rowIdToIndex: Map<RowId, number>;
     colIdToIndex: Map<ColId, number>;

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

@@ -14,6 +14,7 @@ type Params = {
     loadingTasks?: LoadingTasks;
     isLoadingMore?: boolean;
     groupBy?: TableGroupBy;
+    selectedFolders?: string[];
 };
-export default function useBuildProjectDataTable({ foldersMap, tasksMap, rows, tasksByFolderMap, expanded, showHierarchy, isFlatFolderView, showEmptyFolders, loadingTasks, isLoadingMore, }: Params): TableRow[];
+export default function useBuildProjectDataTable({ foldersMap, tasksMap, rows, tasksByFolderMap, expanded, showHierarchy, isFlatFolderView, showEmptyFolders, loadingTasks, isLoadingMore, selectedFolders, }: Params): TableRow[];
 export {};

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

@@ -24,6 +24,7 @@ type useFetchOverviewDataData = {
 type Params = {
     projectName: string;
     selectedFolders: string[];
+    excludeSelectedFolders?: boolean;
     taskIds?: string[];
     taskFilters: QueryFilterParams;
     folderFilters: QueryFilterParams;
@@ -38,5 +39,5 @@ type Params = {
     modules: ProjectTableModulesType;
     skipLinks?: boolean;
 };
-export declare const useFetchOverviewData: ({ projectName, selectedFolders, taskIds, taskFilters, folderFilters, sorting, groupBy, taskGroups, taskGroupsCount, expanded, showHierarchy, isFlatFolderView, attribFields, modules, skipLinks, }: Params) => useFetchOverviewDataData;
+export declare const useFetchOverviewData: ({ projectName, selectedFolders, excludeSelectedFolders, taskIds, taskFilters, folderFilters, sorting, groupBy, taskGroups, taskGroupsCount, expanded, showHierarchy, isFlatFolderView, attribFields, modules, skipLinks, }: Params) => useFetchOverviewDataData;
 export {};

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

@@ -1,6 +1,6 @@
 import { Filter } from '@ynput/ayon-react-components';
 import { QueryTasksFoldersApiArg } from '../../../api';
-import { QueryFilter } from '../types/operations';
+import { QueryFilter } from '../..';
 interface UseQueryFiltersProps {
     queryFilters: QueryFilter;
     sliceFilter?: Filter | null;

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

@@ -1,4 +1,5 @@
 export * from './ProjectTreeTable';
+export * from './constants';
 export * from './context';
 export * from './utils';
 export * from './types';

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

@@ -1,8 +1,10 @@
-import { AttributeModel, EnumItem } from '../../../api';
+import { FieldStats, AttributeModel, EnumItem } from '../../../api';
+import { MainCountLabels, RowScope, SummaryCalc, SummaryFormat } from './summaryTypes';
 import { OperationModel } from './operations';
 export * from './table';
 export * from './overviewContext';
 export * from './operations';
+export * from './summaryTypes';
 export interface ProjectTableAttribute extends Omit<AttributeModel, 'position'> {
     readOnly?: boolean;
 }
@@ -18,3 +20,17 @@ type BuiltInFieldOptionKey = TreeTableSubType | 'status' | 'assignee' | 'tag';
 export type BuiltInFieldOptions = {
     [key in BuiltInFieldOptionKey]: EnumOption[];
 };
+export interface SummaryCellContentProps {
+    columnId: string;
+    attribs: ProjectTableAttribute[];
+    fieldStats?: FieldStats[];
+    groupFieldStats?: FieldStats[];
+    calc?: SummaryCalc;
+    onCalcChange: (calc: SummaryCalc) => void;
+    format?: SummaryFormat;
+    onFormatChange: (format: SummaryFormat) => void;
+    scope?: RowScope;
+    onScopeChange: (scope: RowScope) => void;
+    mainCountLabels?: MainCountLabels;
+    fieldOptions?: BuiltInFieldOptions;
+}

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

@@ -38,6 +38,8 @@ export interface ProjectOverviewContextType {
     taskGroups: EntityGroup[];
     taskFilters: QueryFilterParams;
     folderFilters: QueryFilterParams;
+    selectedFolders: string[];
+    selectedTaskIds: string[];
     queryFilters: QueryFilterParams;
     setQueryFilters: (queryFilters: QueryFilter) => void;
     combinedFilters: QueryFilter;

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

@@ -0,0 +1,50 @@
+export type SummaryKind = 'main' | 'number' | 'boolean' | 'text' | 'enum' | 'assignee' | 'blank';
+export type NumberCalc = 'sum' | 'avg' | 'min' | 'max' | 'none';
+export type BooleanCalc = 'checked' | 'notChecked';
+export type TextCalc = 'filled' | 'notFilled';
+export type EnumCalc = 'values' | 'fill';
+export type SummaryCalc = NumberCalc | BooleanCalc | TextCalc | EnumCalc;
+export type SummaryFormat = 'count' | 'percent' | 'both' | 'none';
+export declare const DEFAULT_SUMMARY_FORMAT: SummaryFormat;
+export declare const formatHasCount: (f: SummaryFormat) => boolean;
+export declare const formatHasPercent: (f: SummaryFormat) => boolean;
+export declare const buildSummaryFormat: (count: boolean, percent: boolean) => SummaryFormat;
+export type RowScope = 'all' | 'primary' | 'secondary' | 'none';
+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;
+};
+export declare const DEFAULT_MAIN_COUNT_LABELS: MainCountLabels;

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

@@ -18,6 +18,7 @@ export type FolderListItem = {
     ownAttrib?: string[];
     updatedAt: string;
     createdAt: string;
+    thumbnailHash?: string;
     hasReviewables?: boolean;
     hasVersions?: boolean;
     links: EntityLink[];
@@ -33,6 +34,7 @@ export type TableRow = {
     tags?: string[];
     status?: string;
     updatedAt?: string;
+    thumbnailHash?: string;
     createdAt?: string;
     parentId?: string;
     folderId?: string | null;
@@ -43,6 +45,7 @@ export type TableRow = {
     productBaseType?: string;
     taskType?: string;
     taskLabel?: string;
+    folderType?: string;
     subRows?: TableRow[];
     icon?: string | null;
     color?: string | null;
@@ -67,6 +70,7 @@ export type TableRow = {
         entityId: string;
         entityType: string;
         updatedAt: string | undefined;
+        thumbnailHash?: string;
     };
 };
 export type MatchingFolder = FolderListItem & {

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

@@ -1,2 +1,4 @@
 import { VisibilityState } from '@tanstack/react-table';
+export declare const ALWAYS_VISIBLE_COLUMNS: string[];
 export declare const checkColumnVisibility: (columns: VisibilityState, fieldName: string, defaultVisibility?: VisibilityState) => boolean;
+export declare const ensureAtLeastOneVisibleColumn: (resolvedVisibility: VisibilityState, columnIds: string[]) => VisibilityState;