@ynput/ayon-frontend-shared 0.7.3 → 0.7.5

package/dist/types/ProjectTreeTable.d.ts

@@ -6,6 +6,7 @@ import { ColumnDef } from '@tanstack/react-table';
 import { ColumnOrderState } from '@tanstack/react-table';
 import { ColumnPinningState } from '@tanstack/react-table';
 import { ColumnSizingState } from '@tanstack/react-table';
+import type { ComponentType } from 'react';
 import { Context } from 'react';
 import { CSSProperties } from 'react';
 import { default as default_2 } from 'react';
@@ -54,6 +55,9 @@ import { useSearchParams } from 'react-router-dom';
 import { Virtualizer } from '@tanstack/react-virtual';
 import { VisibilityState } from '@tanstack/react-table';
 
+/** Who sees a page: everyone when not set. Admins see manager pages too. */
+declare type Access = 'manager' | 'admin'
+
 export declare type ActiveFilters = {
     filter?: {
         conditions?: unknown[];
@@ -101,6 +105,24 @@ export declare type ActivityOperationsResponseModel = {
     success: boolean;
 };
 
+export declare const ADDON_COLUMN_PREFIX = "addon__";
+
+/**
+ * Gets the values of every shown addon column for the rows on screen (fetchValues), into the
+ * store the cells read. Wraps the table body.
+ */
+export declare const AddonColumnDataScope: ({ columns, entities, children, }: {
+    columns: Column<TableRow>[];
+    entities: TableRow["primary"][];
+    children: ReactNode;
+}) => JSX_2.Element;
+
+/** What the table needs to know about an addon column (ColumnDef meta). */
+export declare interface AddonColumnMeta {
+    contribution: Contribution<'tableColumn'>;
+    page: ProjectTablePage;
+}
+
 declare interface AddonConfig {
     /** Display name of the addon */
     label: string;
@@ -120,6 +142,35 @@ declare type AddonDialogSelection = {
 
 declare type AddonFeatureKey = string;
 
+/** The addon a contribution came from. */
+declare interface AddonInfo {
+    /** addon name, as on the server */
+    name: string
+    version: string
+    /** federation remote the manifest was loaded from */
+    remote: string
+}
+
+/** An entry of a button's `menu`. */
+declare type AddonMenuItem =
+| { divider: true }
+| {
+    id: string
+    label: string
+    icon?: string
+    /** goes to an AYON URL when clicked */
+    to?: string
+    /** opens an external URL in a new tab when clicked */
+    href?: string
+    /** called when clicked; an error is shown as a toast */
+    onClick?: () => void | Promise<void>
+    /** a submenu */
+    items?: AddonMenuItem[]
+    disabled?: boolean
+    selected?: boolean
+    danger?: boolean
+}
+
 export declare const allowedGroupByFields: string[];
 
 export declare const ALWAYS_VISIBLE_COLUMNS: string[];
@@ -168,6 +219,10 @@ declare type Anatomy_2 = {
     product_base_types?: ProductBaseTypes_2;
 };
 
+export declare const appliesToPage: (contribution: {
+    pages?: ProjectTablePage[];
+}, page: ProjectTablePage) => boolean;
+
 declare type AttributeData = {
     /** Type of attribute value */
     type?: 'string' | 'integer' | 'float' | 'boolean' | 'datetime' | 'list_of_strings' | 'list_of_integers' | 'list_of_any' | 'list_of_submodels' | 'dict';
@@ -346,6 +401,40 @@ export declare type BuiltInFieldOptions = {
     [key in BuiltInFieldOptionKey]: EnumOption[];
 };
 
+/** Description fields of a button the host draws (header and toolbar items). */
+declare interface ButtonMeta {
+    /** a Material Symbols icon name; required unless the item is a `component` */
+    icon?: string
+    /** shown on hover; the label when not set */
+    tooltip?: string
+    /** navigates there on click, e.g. `/dashboard/comments` (exactly one action: see the slot) */
+    to?: string
+    /** the `dialog`'s title; the label when not set */
+    dialogTitle?: string
+    /** the `dialog`'s size, `md` by default */
+    dialogSize?: 'sm' | 'md' | 'lg' | 'full'
+}
+
+/**
+ * The pieces of a button: what a click does. Set exactly one of them, or `to` in the description.
+ */
+declare interface ButtonPieces<S extends SlotName> {
+    /** called on click with the context (it has `navigate`) */
+    run?: Loader<RunPiece<S>>
+    /** the content of a dialog the host opens and closes: AYON's dialog with title and close button */
+    dialog?: Loader<ComponentType<SlotProps<S> & DialogScope>>
+    /** the items of a menu the host opens under the button, like the header's help menu */
+    menu?: Loader<MenuPiece<S>>
+    /** the addon's own component instead of the host's button: a dropdown, a toggle, anything */
+    component?: Loader<ComponentType<SlotProps<S>>>
+}
+
+/** Context of a button's code (`run`, `dialog`, `menu`, `component`) besides the slot's own. */
+declare interface ButtonScope {
+    /** goes to an AYON URL, e.g. `navigate('/dashboard/comments')` */
+    navigate: (to: string) => void
+}
+
 export declare const CELL_PADDING_Y = 4;
 
 export declare const CellEditingContext: Context<CellEditingContextType | undefined>;
@@ -636,6 +725,18 @@ declare interface ContextMenuItemType extends Omit<ContextMenuItemProps, 'contex
     [key: string]: any;
 }
 
+/** A contribution as the host keeps it: what the addon wrote, plus where it came from. */
+declare type Contribution<S extends SlotName = SlotName> = ContributionInput<S> & {
+    /** `<addonName>.<id>`, unique across addons */
+    key: string
+    addon: AddonInfo
+}
+
+/** What an addon writes for a contribution to slot `S`: the slot, its description and pieces. */
+declare type ContributionInput<S extends SlotName = SlotName> = S extends SlotName
+? { slot: S } & SlotMap[S]['meta'] & SlotMap[S]['pieces']
+: never
+
 /**
  * Converts a datetime Filter to a nested QueryFilter with gte/lte conditions.
  * Returns null if no date conditions could be created.
@@ -740,6 +841,42 @@ export declare interface DetailsPanelEntityProviderProps {
     children: ReactNode;
 }
 
+/** Context of a details panel menu item. */
+declare interface DetailsPanelMenuItemContext extends ProjectNameScope {
+    entityType: string
+    /** the entities the panel shows */
+    selectedEntities: EntityRef[]
+}
+
+/** Description of a `detailsPanel.menuItem` contribution. */
+declare interface DetailsPanelMenuItemMeta extends MenuItemMeta {
+    /** entity types the item shows for; all when not set */
+    entityTypes?: string[]
+    /**
+     * shown as an icon button in the panel's header, next to the "more" button, instead of in its
+     * menu (the label is the tooltip); `position` and `order` then order the header buttons
+     */
+    pinned?: boolean
+}
+
+/** Context of a details panel tab. */
+declare interface DetailsPanelTabContext extends ProjectNameScope, EntityScope_2 {
+    /** where the panel is open (`overview`, `dashboard`, `inbox`, ...); the panel opens in many places */
+    scope: string
+}
+
+/** Description of a `detailsPanel.tab` contribution. */
+declare interface DetailsPanelTabMeta {
+    /** the tab id is `<addon>.<id>` */
+    id: string
+    /** the tab button's tooltip */
+    label: string
+    /** a Material Symbols icon name, the tab button */
+    icon: string
+    /** entity types the tab shows for; all when not set */
+    entityTypes?: string[]
+}
+
 /**
  * Determines which folders are currently loading tasks
  * @param params - Object containing parameters for determining loading folders
@@ -758,6 +895,12 @@ export declare type DetermineLoadingTaskFoldersParams = {
     foldersMap: FolderNodeMap;
 };
 
+/** What a `dialog` piece gets besides the slot context. */
+declare interface DialogScope {
+    /** closes the dialog */
+    close: () => void
+}
+
 declare type DisplayConfig = Record<string, boolean>;
 
 export declare const DRAG_HANDLE_COLUMN_ID = "drag-handle";
@@ -939,6 +1082,23 @@ declare type EntityLinkQuery = FolderLink | TaskLink | ProductLink | VersionLink
 
 export declare type EntityMap = EditorTaskNode | MatchingFolder | EditorVersionNode | EditorProductNode;
 
+/** Context of an entity menu item. */
+declare interface EntityMenuItemContext extends ProjectNameScope {
+    page: ProjectTablePage
+    /** the selected entities (not table rows: list items resolve to their entity) */
+    entities: EntityRef[]
+}
+
+/** Description of an `entityMenuItem` contribution. */
+declare interface EntityMenuItemMeta extends MenuItemMeta {
+    /** entity types it acts on: shown only when every selected entity is one of them. All when not set */
+    entityTypes?: string[]
+    /** which tables offer it; all (Overview, Products, Lists) when not set */
+    pages?: ProjectTablePage[]
+    /** `single`: only for one selected entity; `multi` (default): for one or more */
+    selection?: 'single' | 'multi'
+}
+
 declare interface EntityMoveData {
     entityId: string;
     entityType: EntityMoveType;
@@ -976,8 +1136,24 @@ declare type EntityNaming_2 = {
     separator?: '' | '_' | '-' | '.';
 };
 
+/** An entity a slot is about: its id and type, and its name when the host has it. */
+declare interface EntityRef {
+    id: string
+    /** `folder`, `task`, `product`, `version`, `representation` */
+    entityType: string
+    projectName: string
+    name?: string
+    label?: string
+}
+
 export declare type EntityScope = 'primary' | EntityType;
 
+/** Slots about one or more entities of one type. */
+declare interface EntityScope_2 {
+    entityType: string
+    entities: EntityRef[]
+}
+
 export declare type EntityType = 'folder' | 'task' | 'product' | 'version';
 
 declare type EntityType_2 = OperationModel_2['entityType'];
@@ -1207,6 +1383,25 @@ export declare interface FolderEntityData extends BaseEntityData {
     hasVersions?: boolean;
 }
 
+/** A folder of the project, as slots pass it. AYON passes its folder list item, so more may be there. */
+declare interface FolderInfo {
+    id: string
+    name: string
+    label?: string
+    folderType: string
+    /** `/` separated names from the project root, e.g. `assets/characters/hero` */
+    path: string
+    /** unset for folders at the project root */
+    parentId?: string
+    /** names of the parents, from the project root */
+    parents: string[]
+    status: string
+    tags?: string[]
+    hasTasks?: boolean
+    hasChildren?: boolean
+    attrib?: Record<string, unknown>
+}
+
 declare type FolderLink = GetFoldersLinksQuery['project']['folders']['edges'][0]['node']['links']['edges'][0];
 
 export declare type FolderListItem = {
@@ -1322,6 +1517,8 @@ export declare const generateDummyAttributes: (count?: number) => AttributeModel
  */
 export declare const generateLoadingRows: (count?: number, attrib?: {}, key?: string) => TableRow[];
 
+export declare const getAddonColumnId: (column: Contribution<"tableColumn">) => string;
+
 declare type GetAncestorsOf = (id: string) => string[];
 
 /**
@@ -1885,6 +2082,24 @@ export declare const HeaderActionButton: FC<HeaderActionButtonProps>;
 declare interface HeaderActionButtonProps extends ButtonProps {
 }
 
+/** Context of a header item. */
+declare interface HeaderItemContext extends ButtonScope {
+    /** the project whose page is open, else `null` */
+    projectName: string | null
+}
+
+/** Description of a `header.item` contribution. */
+declare interface HeaderItemMeta extends ButtonMeta {
+    /** unique among the addon's header items */
+    id: string
+    /** shown next to the icon on the left, as the tooltip on the right */
+    label: string
+    /** `left`: after the Home button; `right`: before chat and the inbox */
+    placement: 'left' | 'right'
+    /** order among addon items on the same side, lowest first */
+    order?: number
+}
+
 export declare type HeaderLabel = {
     id: string;
     label: string;
@@ -1964,6 +2179,8 @@ export declare type InheritFromParentEntity = {
     meta?: Record<string, any>;
 };
 
+export declare const isAddonColumnId: (columnId: string) => boolean;
+
 export declare const isAttribGroupable: (attrib: ProjectTableAttribute, entityType?: string, allowedTypes?: ("string" | "integer" | "float")[], enumOnly?: boolean) => boolean;
 
 export declare const isColumnSortable: (columnId: string) => boolean;
@@ -2128,6 +2345,12 @@ declare type ListMembershipFragmentFragment = {
     itemIds: Array<string>;
 };
 
+/** Description of a `projectList.menuItem` or `slicer.menuItem` contribution. */
+declare interface ListMenuItemMeta extends MenuItemMeta {
+    /** which menus show it: both when not set */
+    in?: MenuKind[]
+}
+
 export declare const LISTS_COLUMN_ID = "lists";
 
 declare type ListsMembershipEntityType = 'folder' | 'task' | 'version';
@@ -2146,6 +2369,12 @@ declare interface ListsWidgetProps extends WidgetBaseProps {
     cellId: string;
 }
 
+/**
+ * A piece of a contribution: a dynamic import of a file in the addon, `() => import('./NotesTab')`.
+ * The build puts each piece in its own chunk, and the slot decides when it loads.
+ */
+declare type Loader<T> = () => Promise<{ default: T }>
+
 export declare type LoadingTasks = Record<string, number>;
 
 export declare type MainBreakdownFields = {
@@ -2179,6 +2408,34 @@ declare type Maybe<T> = T | null;
 
 declare type Maybe_2<T> = T | null;
 
+/** Description of a menu item contribution. */
+declare interface MenuItemMeta {
+    /** unique among the addon's items of the slot */
+    id: string
+    /** the menu entry */
+    label: string
+    /** a Material Symbols icon name */
+    icon: string
+    /**
+     * `top`: first in the menu; `bottom` (default): after the menu's own items, above the
+     * destructive ones (Delete, Archive)
+     */
+    position?: MenuItemPosition
+    /** order among addon items with the same position, lowest first */
+    order?: number
+}
+
+/** Where an addon's item goes in a menu. */
+declare type MenuItemPosition = 'top' | 'bottom'
+
+/** Which menu a list's menu item is in: the right-click menu or the "more" dropdown. */
+declare type MenuKind = 'context' | 'dropdown'
+
+/** What a `menu` piece exports as default: the menu's items, built each time the menu opens. */
+declare type MenuPiece<S extends SlotName> = (
+context: SlotContext<S>,
+) => AddonMenuItem[] | Promise<AddonMenuItem[]>
+
 /**
  * Utility functions for managing meta rows in tables (empty, loading, error, etc.)
  */
@@ -2290,6 +2547,43 @@ declare interface Option_2 {
     singleSelect?: boolean;
 }
 
+/** Description of a page contribution (`project.page`, `studio.page`). */
+declare interface PageMeta {
+    /**
+     * The page's URL segment and tab id: `/projects/<project>/<id>`, `/dashboard/<id>`.
+     * A built-in page with the same id wins.
+     */
+    id: string
+    /** the tab label */
+    title: string
+    /** `manager` or `admin`: the tab is hidden from everyone else, and its URL redirects them */
+    access?: Access
+    /**
+     * Gives the page views: the host shows the views menu and the page gets `views` in its context.
+     * The type its views are saved under, e.g. `budget`: letters, digits, `_`, `-` and `.`. It must
+     * be the page's own: one AYON or another page already uses is not shown.
+     */
+    viewType?: string
+}
+
+/**
+ * The views of a page with a `viewType`. The host shows the views menu (saved views, the user's
+ * working view, sharing); the page reads the selected view's settings and saves changes here.
+ */
+declare interface PageViews {
+    /** the page's `viewType` */
+    viewType: string
+    /** settings of the selected view: the page decides their shape. `undefined` while loading */
+    settings: Record<string, unknown> | undefined
+    /** true until the selected view's settings have loaded: don't save before that */
+    isLoading: boolean
+    /**
+     * Saves settings the user changed: they are merged into the selected view's settings and stored
+     * in the user's working view, which becomes the selected view (as on the built-in pages).
+     */
+    updateSettings: (settings: Record<string, unknown>) => Promise<void>
+}
+
 declare type Params = {
     users: {
         name: string;
@@ -2579,6 +2873,21 @@ declare interface ProjectDataProviderProps {
     projectName: string;
 }
 
+/** The project's folders. The host loads them once per project, for every page of it. */
+declare interface ProjectFolders {
+    /** every folder of the project; empty while they load */
+    folders: FolderInfo[]
+    /** true on the first load and when the project changes */
+    isLoading: boolean
+    getFolderById: (id: string) => FolderInfo | undefined
+    /** ids of the folder's parents, nearest first */
+    getParentFolderIds: (folderId: string) => string[]
+    /** ids of every folder inside the given ones, and the given ones too with `includeSelf` */
+    getChildFolderIds: (folderIds: string[], includeSelf?: boolean) => string[]
+    /** the given folders, without those inside another one of them */
+    getFolderIdsWithoutChildren: (folderIds: string[]) => string[]
+}
+
 declare interface ProjectFoldersContextValue {
     folders: FolderListItem_2[];
     getFolderById: (id: string) => FolderListItem_2 | undefined;
@@ -2594,6 +2903,12 @@ declare interface ProjectFoldersContextValue {
     refetch: () => Promise<FolderListModel>;
 }
 
+/** Slots on a project page, which always has the project's folders. */
+declare interface ProjectFoldersScope {
+    /** every folder of the project, with lookups for parents and children */
+    projectFolders: ProjectFolders
+}
+
 declare type ProjectInfo = {
     folderTypes: FolderType_5[];
     taskTypes: TaskType_5[];
@@ -2603,6 +2918,30 @@ declare type ProjectInfo = {
     productTypes: ProductType_2[];
 };
 
+/**
+ * A project, as slots pass it. The fields addons can rely on; AYON passes the full project
+ * model, so more may be there.
+ */
+declare interface ProjectInfo_2 {
+    name: string
+    code: string
+    label?: string
+    active?: boolean
+    library?: boolean
+    attrib?: Record<string, unknown>
+    statuses?: { name: string; color?: string; icon?: string; state?: string; scope?: string[] }[]
+    folderTypes?: { name: string; icon?: string; color?: string }[]
+    taskTypes?: { name: string; icon?: string; color?: string; shortName?: string }[]
+    tags?: { name: string; color?: string }[]
+}
+
+/** Context of a project list menu item. */
+declare interface ProjectListMenuItemContext {
+    /** the selected projects (project folders left out) */
+    projectNames: string[]
+    menu: MenuKind
+}
+
 declare type ProjectModel = {
     /** Name is an unique id of the {entity_name} */
     name: string;
@@ -2631,6 +2970,11 @@ declare type ProjectModelWithProducts = ProjectModel & {
     productTypes: ProductTypeListItem[];
 };
 
+/** Slots that are about one project. */
+declare interface ProjectNameScope {
+    projectName: string
+}
+
 export declare interface ProjectOverviewContextType {
     isInitialized: boolean;
     projectInfo?: ProjectInfo;
@@ -2697,6 +3041,12 @@ export declare interface ProjectOverviewProviderProps {
     modules: ProjectTableModulesType;
 }
 
+/** Slots that are about one project, with the project itself. */
+declare interface ProjectScope extends ProjectNameScope {
+    /** the project; `undefined` while it loads */
+    project: ProjectInfo_2 | undefined
+}
+
 export declare interface ProjectTableAttribute extends Omit<AttributeModel, 'position'> {
     readOnly?: boolean;
     enumIsLoading?: boolean;
@@ -2763,12 +3113,32 @@ export declare interface ProjectTableContextType {
     dispatch?: ThunkDispatch<any, any, UnknownAction>;
 }
 
+/** Context of a Customize section. */
+declare interface ProjectTableCustomizeSectionContext extends ProjectNameScope {
+    page: ProjectTablePage
+}
+
+/** Description of a `projectTable.customizeSection` contribution. */
+declare interface ProjectTableCustomizeSectionMeta {
+    /** unique among the addon's sections */
+    id: string
+    /** the section's entry in Customize and its title when open */
+    title: string
+    /** a Material Symbols icon name */
+    icon: string
+    /** which tables' Customize panels show it; all (Overview, Products, Lists) when not set */
+    pages?: ProjectTablePage[]
+}
+
 declare type ProjectTableModulesType = {
     GroupSettings: typeof GroupSettingsFallback;
     requiredVersion?: string;
     isLoading: boolean;
 };
 
+/** The project pages with a project table (ProjectTreeTable). */
+declare type ProjectTablePage = 'overview' | 'products' | 'lists'
+
 export declare const ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, selectedFolders, expanded, showHierarchy, loadingTasks, isLoadingMore, isLoading, error, softError, softErrorAction, isInitialized, users, attribFields, scopes, groups, groupRowFunc, overrideGroupBy, groupCounts, groupCountsComplete, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, fetchNextPage, onSyncData, setExpanded, contextMenuItems, powerpack, modules, loadingLinksEntityIds, groupByConfig, hierarchyOptions, hierarchyActive, isFlatFolderView, SubtasksManager, playerOpen, onOpenPlayer, onResetView, hiddenListIds, useParams, useNavigate, useLocation, useSearchParams, dispatch, }: ProjectTableProviderProps) => JSX_2.Element;
 
 export declare interface ProjectTableProviderProps {
@@ -2862,7 +3232,24 @@ export declare interface ProjectTableQueriesProviderProps {
     }, force?: boolean) => Promise<any>;
 }
 
-export declare const ProjectTreeTable: ({ scope, sliceId, onScroll, onScrollBottom, onOpenNew, readOnly, excludedColumns, excludedSorting, extraColumns, includeLinks, includeParents, parentColumns, isLoading: isLoadingProp, isExpandable, enableSorting, clientSorting, sortableRows, onRowReorder, dndActiveId, columnsConfig, showColumnSummaries, fieldStats, groupFieldStats, fieldStatsLoading, fieldStatsError, mainCountLabels, mainBreakdownFields, onScrollBottomGroupBy, contextMenuItems: propsContextMenuItems, onColumnVisibleChange, onColumnVisibleChangeSubscribed, onVisibleRowsChange, scrollToRowId, onScrolledToRow, pt, ...props }: ProjectTreeTableProps) => JSX_2.Element;
+/** Context of a project table toolbar item. */
+declare interface ProjectTableToolbarItemContext extends ProjectNameScope, ButtonScope {
+    page: ProjectTablePage
+    /** on Lists: the open list */
+    list?: { id: string; label: string; entityType: string }
+}
+
+/** Description of a `projectTable.toolbarItem` contribution. */
+declare interface ProjectTableToolbarItemMeta extends ButtonMeta {
+    /** unique among the addon's toolbar items */
+    id: string
+    /** shown next to the icon; an icon-only button when not set */
+    label?: string
+    /** which tables' toolbars show it; all (Overview, Products, Lists) when not set */
+    pages?: ProjectTablePage[]
+}
+
+export declare const ProjectTreeTable: ({ scope, sliceId, onScroll, onScrollBottom, onOpenNew, readOnly, excludedColumns, excludedSorting, extraColumns, includeLinks, includeParents, parentColumns, isLoading: isLoadingProp, isExpandable, enableSorting, clientSorting, sortableRows, onRowReorder, dndActiveId, columnsConfig, showColumnSummaries, fieldStats, groupFieldStats, fieldStatsLoading, fieldStatsError, mainCountLabels, mainBreakdownFields, onScrollBottomGroupBy, contextMenuItems: propsContextMenuItems, onColumnVisibleChange, onColumnVisibleChangeSubscribed, onVisibleRowsChange, scrollToRowId, onScrolledToRow, addonPage, pt, ...props }: ProjectTreeTableProps) => JSX_2.Element;
 
 export declare interface ProjectTreeTableProps extends React.HTMLAttributes<HTMLDivElement> {
     scope: string;
@@ -2898,6 +3285,7 @@ export declare interface ProjectTreeTableProps extends React.HTMLAttributes<HTML
     onVisibleRowsChange?: (entityIds: string[]) => void;
     scrollToRowId?: string | null;
     onScrolledToRow?: (rowId: string) => void;
+    addonPage?: ProjectTablePage;
     pt?: {
         container?: React.HTMLAttributes<HTMLDivElement>;
         head?: Partial<TableHeadProps>;
@@ -3063,6 +3451,9 @@ declare type RTEntityUpdate = {
     message?: any;
 };
 
+/** What a menu item's `run` piece exports as default: called on click with the slot context. */
+declare type RunPiece<S extends SlotName> = (context: SlotContext<S>) => void | Promise<void>
+
 export declare const sanitizeQueryFilter: (filter: QueryFilter) => QueryFilter;
 
 export declare const sanitizeSubtaskName: (name: string) => string;
@@ -3208,11 +3599,205 @@ declare type SettingsPanelItem = {
     path?: string;
 };
 
+/**
+ * A table with addon shortcuts: the project tables (`overview`, `products`, `lists`) and the
+ * panels' tables: the slicer, the project list, the Lists page's lists and the Products page's
+ * versions.
+ */
+declare type ShortcutTable = ProjectTablePage | 'slicer' | 'projects' | 'listsPanel' | 'versionsPanel'
+
+/** Context of a slicer menu item. */
+declare interface SlicerMenuItemContext extends ProjectNameScope {
+    sliceType: string
+    /** the rows it acts on: the selected ones, or the right-clicked one */
+    selected: SlicerRowRef[]
+    menu: MenuKind
+}
+
+/** Description of a `slicer.menuItem` contribution. */
+declare interface SlicerMenuItemMeta extends ListMenuItemMeta {
+    /** slice types it shows for (`hierarchy`, `assignees`, `status`, ...); all when not set */
+    sliceTypes?: string[]
+}
+
 export declare interface SliceRowSelection {
     sliceType: string;
     rowSelection: RowSelectionState;
 }
 
+/** A row of the slicer: a folder in `hierarchy`, a value (user, status, type) in the others. */
+declare interface SlicerRowRef {
+    id: string
+    label?: string
+    /** for `hierarchy` rows: `folder` (or `task`) */
+    entityType?: string
+}
+
+/** Slots on a project page, which always has the host's slicer state (selection, per page). */
+declare interface SlicerScope {
+    /** empty until the user selects something in a `<Slicer>` the page places */
+    slicer: SlicerSelection
+}
+
+/** What is selected in the project page's slicer. */
+declare interface SlicerSelection {
+    /** `hierarchy`, `assignees`, `status`, `taskType`, ... */
+    sliceType: string
+    /** ids of the selected rows: folder ids for `hierarchy`, the values for the others */
+    selection: string[]
+}
+
+/** What the code of a contribution to slot `S` gets: `{ slot: S, ...context }`. */
+declare type SlotContext<S extends SlotName> = S extends SlotName
+? { slot: S } & SlotMap[S]['context']
+: never
+
+/**
+ * Every slot this version of AYON has. Keys are slot names (`'project.page'`); each value has
+ * the slot's `version`, its description fields (`meta`), the context its code gets (`context`)
+ * and its pieces (`pieces`).
+ */
+declare interface SlotMap {
+    /**
+     * A tab on the project page, at `/projects/<project>/<id>`. The tab shows from the
+     * description; `component` loads when the page is first opened.
+     */
+    'project.page': {
+        version: 1
+        meta: PageMeta
+        context: ProjectScope & SlicerScope & ProjectFoldersScope & ViewsScope
+        pieces: { component: Loader<ComponentType<SlotProps<'project.page'>>> }
+    }
+    /**
+     * A tab on the dashboard (studio level), at `/dashboard/<id>`. The tab shows from the
+     * description; `component` loads when the page is first opened.
+     */
+    'studio.page': {
+        version: 1
+        meta: PageMeta
+        context: StudioPageContext
+        pieces: { component: Loader<ComponentType<SlotProps<'studio.page'>>> }
+    }
+    /**
+     * A button in the main header, drawn by the host like its own buttons. What a click does is the
+     * addon's: navigate (`to`), run code (`run`), open a dialog (`dialog`) or a menu (`menu`); or the
+     * addon draws the item itself (`component`, loaded with the header). Set exactly one.
+     */
+    'header.item': {
+        version: 1
+        meta: HeaderItemMeta
+        context: HeaderItemContext
+        pieces: ButtonPieces<'header.item'>
+    }
+    /**
+     * A tab in the details panel. The tab button shows from the description, for `entityTypes`;
+     * `component` loads when the tab is first opened.
+     */
+    'detailsPanel.tab': {
+        version: 1
+        meta: DetailsPanelTabMeta
+        context: DetailsPanelTabContext
+        pieces: { component: Loader<ComponentType<SlotProps<'detailsPanel.tab'>>> }
+    }
+    /**
+     * An item in the details panel's "more" menu. It shows from the description; `run` loads when
+     * the menu opens and is called on click.
+     */
+    'detailsPanel.menuItem': {
+        version: 1
+        meta: DetailsPanelMenuItemMeta
+        context: DetailsPanelMenuItemContext
+        pieces: { run: Loader<RunPiece<'detailsPanel.menuItem'>> }
+    }
+    /**
+     * An item in the project list's menus (dashboard, project menu, studio pages' ProjectList): the
+     * right-click menu, the "more" dropdown, or both (`in`). It acts on the selected projects.
+     */
+    'projectList.menuItem': {
+        version: 1
+        meta: ListMenuItemMeta
+        context: ProjectListMenuItemContext
+        pieces: { run: Loader<RunPiece<'projectList.menuItem'>> }
+    }
+    /**
+     * An item in the project page slicer's menus: the right-click menu, the panel's dropdown, or both
+     * (`in`), for the slice types it lists.
+     */
+    'slicer.menuItem': {
+        version: 1
+        meta: SlicerMenuItemMeta
+        context: SlicerMenuItemContext
+        pieces: { run: Loader<RunPiece<'slicer.menuItem'>> }
+    }
+    /**
+     * An item in the right-click menu of the project tables' cells, for the selected entities. It
+     * shows from the description; `run` loads when the menu opens and is called on click.
+     */
+    entityMenuItem: {
+        version: 1
+        meta: EntityMenuItemMeta
+        context: EntityMenuItemContext
+        pieces: { run: Loader<RunPiece<'entityMenuItem'>> }
+    }
+    /**
+     * A button in the project tables' toolbar, before Customize (Overview, Products, Lists), drawn
+     * by the host like the toolbar's own. What a click does is the addon's: navigate (`to`), run code
+     * (`run`), open a dialog (`dialog`) or a menu (`menu`); or the addon draws the item itself
+     * (`component`, loaded with the toolbar). Set exactly one.
+     */
+    'projectTable.toolbarItem': {
+        version: 1
+        meta: ProjectTableToolbarItemMeta
+        context: ProjectTableToolbarItemContext
+        pieces: ButtonPieces<'projectTable.toolbarItem'>
+    }
+    /**
+     * A section in the project tables' Customize panel (Overview, Products, Lists). The entry shows
+     * from the description; `component` loads when the section is opened.
+     */
+    'projectTable.customizeSection': {
+        version: 1
+        meta: ProjectTableCustomizeSectionMeta
+        context: ProjectTableCustomizeSectionContext
+        pieces: { component: Loader<ComponentType<SlotProps<'projectTable.customizeSection'>>> }
+    }
+    /**
+     * A read-only column in the project tables (Overview, Products, Lists). It is in the column
+     * settings from the description; `cell` and `fetchValues` load with the table. The host draws
+     * the cell box (padding, selection, focus), so `cell` renders only its content; selecting, the
+     * right-click menu and Copy (the cell's `value` as text) work as in other columns. Not sortable,
+     * and pasting into it changes nothing.
+     */
+    tableColumn: {
+        version: 1
+        meta: TableColumnMeta
+        context: TableCellContext_2
+        pieces: {
+            cell: Loader<ComponentType<SlotProps<'tableColumn'>>>
+            fetchValues?: Loader<TableColumnFetch>
+        }
+    }
+    /**
+     * A keyboard shortcut on the cells of AYON's tables: the project tables (Overview, Products,
+     * Lists) and the panels' tables (slicer, project list, lists, versions). Pressed in a cell, it
+     * runs code (`run`) or opens a dialog (`dialog`) with the selected rows; set exactly one. AYON's
+     * own keys (arrows, Enter, Escape, Tab, Space, `r`, Delete, copy, paste, undo) can't be taken,
+     * and the key does nothing while a cell is being edited.
+     */
+    'table.shortcut': {
+        version: 1
+        meta: TableShortcutMeta
+        context: TableShortcutContext
+        pieces: TableShortcutPieces
+    }
+}
+
+/** The name of a slot, e.g. `'project.page'`. */
+declare type SlotName = keyof SlotMap & string
+
+/** Props of the component a contribution to slot `S` renders. Same as `SlotContext<S>`. */
+declare type SlotProps<S extends SlotName> = SlotContext<S>
+
 export declare type SoftErrorAction = {
     label: string;
     icon: string;
@@ -3298,6 +3883,12 @@ declare type Status_5 = {
     scope?: string[];
 };
 
+/** Context of a studio page. */
+declare interface StudioPageContext extends ViewsScope {
+    /** projects selected in the page's `<ProjectList>`; saved per page */
+    selectedProjects: string[]
+}
+
 export declare const StyledBaseTextWidget: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick< DetailedHTMLProps<HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;
 
 declare type SubTaskNode = {
@@ -3390,6 +3981,14 @@ export declare const TABLE_CONTAINER_ATTR = "data-column-dnd-container";
 
 export declare const TableCellContext: Context<TableCellContextValue>;
 
+/** Context of one cell of a `tableColumn`. */
+declare interface TableCellContext_2 extends ProjectNameScope {
+    page: ProjectTablePage
+    entity: EntityRef
+    /** what the column's `fetchValues` returned for this entity; `undefined` without `fetchValues` */
+    value: unknown
+}
+
 export declare type TableCellContextData = {
     cellId: string;
     columnId: string;
@@ -3410,6 +4009,47 @@ export declare type TableCellContextValue = {
     isRowReadOnly?: boolean;
 };
 
+/**
+ * Gets a column's values, by entity id; each cell gets its own as `value`. AYON calls it with
+ * the rows that come on screen and that it has no value for yet, in batches once scrolling
+ * pauses, and keeps what it returns: scrolling back costs nothing. A row whose entity changes
+ * (here or by someone else) is asked for again; `refreshTableColumn(id)` asks again for all.
+ * When it throws, those cells show the error and are tried again when they next come on
+ * screen. Fetch through AYON's store (`dispatch(api.endpoints.x.initiate(...))`) to share its
+ * cache.
+ */
+declare type TableColumnFetch = (args: TableColumnFetchArgs) => Promise<Record<string, unknown>>
+
+/** What a column's `fetchValues` gets. */
+declare interface TableColumnFetchArgs extends ProjectNameScope {
+    page: ProjectTablePage
+    /** the rows to get values for (entities, not list items): at most 100 */
+    entities: EntityRef[]
+    /** aborted when the table no longer needs them (another project or table) */
+    signal: AbortSignal
+}
+
+/** Description of a `tableColumn` contribution. */
+declare interface TableColumnMeta {
+    /** part of the column id, so only letters, digits and `_` */
+    id: string
+    /** the column header and its name in the column settings */
+    label: string
+    icon?: string
+    /** entity types with a cell; other rows show an empty read-only cell. All when not set */
+    entityTypes?: string[]
+    /** which tables offer it; all (Overview, Products, Lists) when not set */
+    pages?: ProjectTablePage[]
+    /** width in pixels. Addon columns start hidden: users show them in Customize */
+    width?: number
+    /**
+     * where the column sits in the "Add column" menu: a submenu named after the addon when not
+     * set, a submenu with this name (columns giving the same name share it, across addons too), or
+     * `false` for the menu's top level
+     */
+    menu?: string | false
+}
+
 export declare interface TableGroupBy {
     desc: boolean;
     id: string;
@@ -3440,6 +4080,66 @@ export declare interface TableRow {
     cellMarks?: Record<string, CellMark>;
 }
 
+/** A table row a shortcut acts on. */
+declare interface TableRowRef {
+    /** project tables: the entity's id (list items resolve to their entity); else the row's id */
+    id: string
+    /** project tables: `folder`, `task`, `product`, `version`, ... */
+    entityType?: string
+    name?: string
+    label?: string
+    /**
+     * the row as the table has it: an entity's fields and `attrib` in the project tables, the
+     * project, list, version or slicer value in the panels
+     */
+    data: Record<string, unknown>
+}
+
+/** Context of a table shortcut. */
+declare interface TableShortcutContext {
+    /** the table the key was pressed in */
+    table: ShortcutTable
+    /** the open project; `null` in the project list */
+    projectName: string | null
+    /** the rows it acts on: the selected ones when the key was pressed in one of them, else its row */
+    rows: TableRowRef[]
+    /** where the key was pressed: the row's id, and the column's in the project tables */
+    focused: { rowId: string; columnId?: string }
+    /** project tables: the selected cells, by row (entity) and column id; empty elsewhere */
+    cells: { rowId: string; columnId: string }[]
+}
+
+/** Description of a `table.shortcut` contribution. */
+declare interface TableShortcutMeta {
+    /** unique among the addon's shortcuts */
+    id: string
+    /** what it does, e.g. `Copy row as JSON`; the dialog's title when `dialogTitle` is not set */
+    label: string
+    /**
+     * the key and its modifiers joined by `+`, lower case: `g`, `shift+mod+c`, `alt+1`, `f2`. `mod` is
+     * ⌘ on macOS and Ctrl elsewhere; `ctrl`, `meta`, `alt` and `shift` are the keys themselves.
+     * Letters and digits match the key's place on the keyboard, so `alt+g` works on macOS too
+     */
+    keys: string
+    /**
+     * which tables it works in; all when not set. `overview`, `products`, `lists` (the project
+     * tables), `slicer`, `projects`, `listsPanel`, `versionsPanel`
+     */
+    tables?: ShortcutTable[]
+    /** the `dialog`'s title; the label when not set */
+    dialogTitle?: string
+    /** the `dialog`'s size, `md` by default */
+    dialogSize?: 'sm' | 'md' | 'lg' | 'full'
+}
+
+/** The pieces of a table shortcut: what the key does. Set exactly one. */
+declare interface TableShortcutPieces {
+    /** called with the context when the key is pressed */
+    run?: Loader<RunPiece<'table.shortcut'>>
+    /** the content of a dialog the host opens: AYON's dialog with title and close button */
+    dialog?: Loader<ComponentType<SlotProps<'table.shortcut'> & DialogScope>>
+}
+
 export declare type TableUser = {
     name: string;
     fullName?: string | null;
@@ -3691,6 +4391,31 @@ export declare type UpdateTableEntity = (cellId: CellId, value: string, { includ
     includeSelection: boolean;
 }) => Promise<void>;
 
+/**
+ * Items addons contribute to the cells' right-click menu (entityMenuItem slot, @ynput/ayon-addon),
+ * as one constructor a page adds to its contextMenuItems: the `top` ones first in the list, the
+ * `bottom` ones (default) right before 'delete'. The items draw from their descriptions; `run`
+ * starts loading when the menu opens.
+ */
+export declare const useAddonEntityMenuItems: (page: ProjectTablePage, position?: MenuItemPosition) => ContextMenuItemConstructor;
+
+/**
+ * The columns addons contribute to this page's table (tableColumn slot): `columns` for the
+ * table's `extraColumns`, `settingsColumns` for the column settings and the add-column menu.
+ * Both come from the descriptions; the cells' code starts loading with the table. In the
+ * add-column menu each addon's columns get a submenu titled after it unless they name one
+ * (`menu`) or ask for the top level (`menu: false`).
+ */
+export declare const useAddonTableColumns: (page: ProjectTablePage) => {
+    columns: TreeTableExtraColumn[];
+    settingsColumns: {
+        value: string;
+        label: string;
+        icon: string | undefined;
+        menu: string | undefined;
+    }[];
+};
+
 export declare const useCellEditing: () => CellEditingContextType;
 
 export declare const useCheckSelectedCellsVisible: ({ selectedCells, setSelectedCells, focusedCellId, setFocusedCellId, }: CheckSelectedCellsVisibleProps) => void;
@@ -4111,6 +4836,12 @@ export declare type VersionStatsArgs = {
     latestPerFolder?: boolean;
 };
 
+/** Pages, which have views when their description sets `viewType`. */
+declare interface ViewsScope {
+    /** `undefined` when the page's description has no `viewType` */
+    views: PageViews | undefined
+}
+
 declare type VisibleEntity = {
     id: string;
     entityType: string;
@@ -4151,6 +4882,9 @@ export { }
 
 
 declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        addonColumn?: AddonColumnMeta;
+    }
     interface TableMeta<TData extends RowData> {
         options?: BuiltInFieldOptions;
         readOnly?: ProjectTreeTableProps['readOnly'];