@ynput/ayon-frontend-shared 0.7.3 → 0.7.5

package/dist/types/components.d.ts

@@ -9,6 +9,7 @@ import { ColumnOrderState } from '@tanstack/react-table';
 import { ColumnPinningState } from '@tanstack/react-table';
 import { ColumnSizingState } from '@tanstack/react-table';
 import { Component } from 'react';
+import type { ComponentType } from 'react';
 import { Context } from 'react';
 import { coreModuleName } from '@reduxjs/toolkit/query';
 import { CSSProperties } from 'react';
@@ -96,6 +97,9 @@ export declare const $isYouTubeNode: (node: LexicalNode | null | undefined) => n
 
 export declare const $setMarkdown: (markdown: string) => void;
 
+/** Who sees a page: everyone when not set. Admins see manager pages too. */
+declare type Access = 'manager' | 'admin'
+
 export declare const ACCESS_LEVEL_LABELS: {
     0: string;
     10: string;
@@ -153,11 +157,7 @@ export declare const ACTIVITY_LINK_LABEL = "Comment";
 export declare const AddColumnButton: FC<AddColumnButtonProps>;
 
 declare interface AddColumnButtonProps {
-    extraColumns?: {
-        value: string;
-        label: string;
-        icon?: string;
-    }[];
+    extraColumns?: Pick<AddColumnItem, 'value' | 'label' | 'icon' | 'menu'>[];
     hiddenColumns?: string[];
     includeLinks?: boolean;
     extraMenuItems?: MenuItemType[];
@@ -172,6 +172,7 @@ declare type AddColumnItem = SettingsPanelItem & {
     field?: string;
     isLink?: boolean;
     parentScope?: EntityType;
+    menu?: string;
 };
 
 declare type AddLinks = (links: {
@@ -189,8 +190,71 @@ declare interface AddNewLinksProps {
     onAdd?: (targetEntityId: string, linkType?: string) => void;
 }
 
+export declare const AddonButton: <S extends ButtonSlot>({ contribution, context, renderButton, autoOpen, onContext, }: AddonButtonProps<S>) => JSX_2.Element;
+
+export declare interface AddonButtonProps<S extends ButtonSlot> {
+    contribution: Contribution<S>;
+    /** the slot's context, without `navigate` (the button adds it) */
+    context: Omit<SlotMap[S]['context'], 'navigate'>;
+    /** the host's button; not called for a `component` item, which draws itself */
+    renderButton: (props: AddonButtonRenderProps) => ReactNode;
+    /** dev shell: open the dialog right away */
+    autoOpen?: boolean;
+    /** dev shell: the context the item's code gets */
+    onContext?: (context: object) => void;
+}
+
+export declare interface AddonButtonRenderProps {
+    ref: (element: HTMLElement | null) => void;
+    /** its dialog or menu is open */
+    active: boolean;
+    onClick: () => void;
+    onMouseEnter: () => void;
+}
+
+declare type AddonDetailsPanelTab = `${string}.${string}`;
+
+export declare const AddonDialog: <S extends SlotName>({ contribution, context }: AddonDialogProps<S>) => JSX_2.Element;
+
+export declare interface AddonDialogProps<S extends SlotName> {
+    contribution: Contribution<S>;
+    /** the slot's context with `close`; memoize it */
+    context: SlotMap[S]['context'] & {
+        close: () => void;
+    };
+}
+
+/** 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
+}
+
 export declare const AddonLoadingScreen: FC<ReportsLoadingScreenProps>;
 
+/** 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
+}
+
 declare type AlignType = 'left' | 'right';
 
 declare type Anatomy = {
@@ -215,6 +279,15 @@ declare type Anatomy = {
     product_base_types?: ProductBaseTypes;
 };
 
+/** Any contribution, whatever its slot: what the host's generic code (loading, errors) uses. */
+declare interface AnyContribution {
+    slot: string
+    id: string
+    key: string
+    addon: AddonInfo
+    [field: string]: unknown
+}
+
 export declare type AttributeData = {
     id: string;
     isExpanded: boolean;
@@ -363,6 +436,46 @@ declare const Button: IStyledComponentBase<"web", FastOmit<Omit< ButtonProps & R
     ref?: ((instance: HTMLButtonElement | null) => void | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | RefObject<HTMLButtonElement> | null | undefined;
 }, never>>> & string & Omit< ForwardRefExoticComponent< ButtonProps & RefAttributes<HTMLButtonElement>>, keyof Component<any, {}, any>>;
 
+/** What a button contribution does on click: exactly one is set (checked when the manifest loads). */
+export declare type ButtonAction = 'to' | 'run' | 'dialog' | 'menu' | 'component';
+
+/** 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
+}
+
+/** The slots whose contributions are buttons: header.item, projectTable.toolbarItem. */
+export declare type ButtonSlot = 'header.item' | 'projectTable.toolbarItem';
+
 export declare const CellEditingDialog: FC<LinksManagerDialogProps>;
 
 export declare const Chips: FC<ChipsProps>;
@@ -547,6 +660,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
+
 /**
  * Mention source backed by the activity feed's mention suggestions (`useGetEntityMentionsQuery`),
  * using the same option builders and sorting as the legacy comment input.
@@ -898,6 +1023,24 @@ declare type DetailsPanelFolderFragmentFragment = {
     folderType: string;
 };
 
+/** 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
+}
+
 declare type DetailsPanelPip = {
     entityType: DetailsPanelEntityType;
     entities: {
@@ -928,7 +1071,25 @@ declare type DetailsPanelRepresentationFragmentFragment = {
     }>;
 };
 
-declare type DetailsPanelTab = 'feed' | 'subtasks' | 'details' | 'files';
+declare type DetailsPanelTab = 'feed' | 'subtasks' | 'details' | 'files' | AddonDetailsPanelTab;
+
+/** Context of a details panel tab. */
+declare interface DetailsPanelTabContext extends ProjectNameScope, EntityScope {
+    /** 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[]
+}
 
 declare type DetailsPanelTask = NonNullable<GetDetailsPanelTaskQuery['project']['task']>;
 
@@ -969,6 +1130,12 @@ export declare const detectRelativeDatePattern: (startISO: string | undefined, e
     id: DateOptionType;
 } | null;
 
+/** What a `dialog` piece gets besides the slot context. */
+declare interface DialogScope {
+    /** closes the dialog */
+    close: () => void
+}
+
 declare type DivPt = Partial<React.HTMLAttributes<HTMLDivElement>>;
 
 declare type DivPt_2 = Partial<default_2.HTMLAttributes<HTMLDivElement>>;
@@ -1122,6 +1289,23 @@ declare type EntityListModel = {
     accessLevel?: ListAccessLevel;
 };
 
+/** 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 type EntityNaming_2 = {
     /** How to capitalize the entity names */
     capitalization?: 'lower' | 'upper' | 'keep' | 'pascal' | 'camel';
@@ -1156,6 +1340,22 @@ export declare interface EntityPathProps {
     scope: string;
 }
 
+/** 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
+}
+
+/** Slots about one or more entities of one type. */
+declare interface EntityScope {
+    entityType: string
+    entities: EntityRef[]
+}
+
 export declare const EntityTooltip: React.FC<EntityTooltipProps>;
 
 export declare interface EntityTooltipProjectInfo {
@@ -1439,6 +1639,25 @@ declare type FolderDeleteInfo = {
     totalVersionCount: number;
 };
 
+/** 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 interface FolderProduct {
     id: string;
     name: string;
@@ -1587,6 +1806,8 @@ declare type GetBaseViewApiResponse =
 /** status 200 Successful Response */
 OverviewViewModel | TaskProgressViewModel | ListsViewModel | ReviewsViewModel | VersionsViewModel | GenericViewModel;
 
+export declare const getButtonAction: (contribution: AnyContribution) => ButtonAction | undefined;
+
 declare type GetDefaultViewApiArg = {
     viewType: string;
     projectName?: string;
@@ -1761,6 +1982,24 @@ declare interface HastNode_2 {
     children?: HastNode_2[];
 }
 
+/** 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 interface HeightSliderProps {
     value: number;
     onChange: (value: number) => void;
@@ -1944,6 +2183,12 @@ declare interface ListAttributeFormProps {
     attributes?: AttributeField[];
 }
 
+/** 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 ListMetaData: FC<ListMetaDataProps>;
 
 declare interface ListMetaDataProps {
@@ -2002,6 +2247,29 @@ declare type ListViewsApiArg = {
     projectName?: 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 const LoginPage: ({ onLogin, loading, isFirstTime }: LoginPageProps) => JSX_2.Element | null;
+
+export declare interface LoginPageProps {
+    /** stores the session: ayon-frontend dispatches its `login`, the addon dev shell stores the token */
+    onLogin: (result: LoginResult) => void;
+    /** shown while the site info or an SSO callback loads */
+    loading?: ReactNode;
+    isFirstTime?: boolean;
+}
+
+/** What a successful login gives the host, which stores the session (see storeAccessToken). */
+export declare interface LoginResult {
+    user: any;
+    accessToken?: string;
+    redirectUrl?: string | null;
+}
+
 declare type MainCalc = 'count' | 'breakdown';
 
 export declare const MARKDOWN_TRANSFORMERS: Transformer_2[];
@@ -2226,6 +2494,26 @@ declare interface MenuItemEndAction {
     onClick: (e: default_2.MouseEvent) => void;
 }
 
+/** 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'
+
 export declare interface MenuItemType {
     id: string;
     label?: string | string[];
@@ -2250,6 +2538,9 @@ export declare interface MenuItemType {
     [key: string]: any;
 }
 
+/** Which menu a list's menu item is in: the right-click menu or the "more" dropdown. */
+declare type MenuKind = 'context' | 'dropdown'
+
 export declare const MenuList: default_2.FC<MenuListProps>;
 
 declare interface MenuListProps {
@@ -2277,6 +2568,11 @@ declare interface MenuListProps {
     [key: string]: any;
 }
 
+/** 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[]>
+
 declare interface MenuProps {
     menu?: MenuItemType[];
     onClose?: () => void;
@@ -2310,6 +2606,13 @@ declare type Omit_2<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
 declare type OnSyncDataCallback = (updates: RTEntityUpdate[] | undefined) => void | Promise<void>;
 
+export declare interface OpenAddonShortcutDialog {
+    contribution: Contribution<'table.shortcut'>;
+    context: TableShortcutContext & {
+        close: () => void;
+    };
+}
+
 declare interface OpenStateByScope {
     [scope: string]: boolean;
 }
@@ -2378,6 +2681,43 @@ declare type OverviewViewPostModel = {
     viewType?: 'overview';
 };
 
+/** 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 ParentColumnDataType = 'string' | 'datetime' | 'list_of_strings';
 
 declare type ParentColumnDefinition = {
@@ -2581,6 +2921,51 @@ declare interface ProjectContextValue extends ProjectModelWithProducts {
     }[];
 }
 
+/** 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[]
+}
+
+/** 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
+}
+
+/**
+ * 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 {
+    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;
@@ -2609,6 +2994,19 @@ declare type ProjectModelWithProducts = ProjectModel & {
     productTypes: ProductTypeListItem[];
 };
 
+/** Slots that are about one project. */
+declare interface ProjectNameScope {
+    projectName: string
+}
+
+export declare const ProjectPageLayoutHost: ({ sidebar, children }: ProjectPageLayoutProps) => JSX_2.Element;
+
+declare interface ProjectPageLayoutProps {
+    /** the left panel, usually `<Slicer fields={[...]} />` */
+    sidebar?: ReactNode
+    children: ReactNode
+}
+
 export declare const ProjectPageRemote: FC<ProjectPageRemoteProps>;
 
 export declare interface ProjectPageRemoteProps extends RemotePageWrapperProps {
@@ -2618,15 +3016,37 @@ export declare interface ProjectPageRemoteProps extends RemotePageWrapperProps {
     addonProps?: any;
 }
 
+/** Slots that are about one project, with the project itself. */
+declare interface ProjectScope extends ProjectNameScope {
+    /** the project; `undefined` while it loads */
+    project: ProjectInfo | undefined
+}
+
+/** 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[]
+}
+
+/** The project pages with a project table (ProjectTreeTable). */
+declare type ProjectTablePage = 'overview' | 'products' | 'lists'
+
 export declare const ProjectTableSettings: FC<ProjectTableSettingsProps>;
 
 export declare type ProjectTableSettingsProps = {
     settings?: SettingConfig[];
-    extraColumns?: {
-        value: string;
-        label: string;
-        icon?: string;
-    }[];
+    extraColumns?: Pick<AddColumnItem, 'value' | 'label' | 'icon' | 'menu'>[];
     hiddenColumns?: string[];
     hiddenSettings?: ('columns' | 'row-height' | 'group-by' | 'sort-by')[];
     highlighted?: SettingHighlightedId;
@@ -2639,6 +3059,23 @@ export declare type ProjectTableSettingsProps = {
     columnIdAliases?: ColumnIdAliases;
 };
 
+/** 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[]
+}
+
 declare type Props = {
     projectName: string;
     entityId: string;
@@ -3001,6 +3438,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>
+
 declare type SavedAnnotationMetadata = {
     id: string;
     composite: string;
@@ -3154,6 +3594,18 @@ export declare interface ShareOptionIconProps {
     withTooltip?: boolean;
 }
 
+declare type ShortcutKeyEvent = Pick<KeyboardEvent, 'key' | 'code' | 'ctrlKey' | 'metaKey' | 'altKey' | 'shiftKey' | 'repeat'> & {
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+
+/**
+ * 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'
+
 declare interface SidebarConfig {
     width?: string;
     minWidth?: string;
@@ -3237,12 +3689,206 @@ declare interface SliceFilter extends Filter {
     values: FilterValue[];
 }
 
+export declare const SlicerHost: ({ fields }: SlicerProps) => JSX_2.Element;
+
+/** 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[]
+}
+
+declare interface SlicerProps {
+    /** which slice types the slicer offers: `hierarchy`, `assignees`, `status`, `taskType`, ... */
+    fields: string[]
+}
+
+/** 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[]
+}
+
 declare type SlideOut = {
     entityId: string;
     entityType: DetailsPanelEntityType;
     projectName: 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
+        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>
+
 declare interface SortMenuItemArgs<T extends string> {
     options: SortMenuOption<T>[];
     sort: SortMenuValue<T>;
@@ -3346,6 +3992,12 @@ declare type Status_3 = {
     scope?: string[];
 };
 
+/** Context of a studio page. */
+declare interface StudioPageContext extends ViewsScope {
+    /** projects selected in the page's `<ProjectList>`; saved per page */
+    selectedProjects: string[]
+}
+
 declare namespace Styled {
     export {
         EnumListWrapper,
@@ -3436,6 +4088,55 @@ declare interface SyncButtonProps extends Omit<ButtonProps, 'onClick'> {
     hideWhenNoUpdates?: boolean;
 }
 
+/** Context of one cell of a `tableColumn`. */
+declare interface TableCellContext extends ProjectNameScope {
+    page: ProjectTablePage
+    entity: EntityRef
+    /** what the column's `fetchValues` returned for this entity; `undefined` without `fetchValues` */
+    value: unknown
+}
+
+/**
+ * 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 const TableGridSwitch: ForwardRefExoticComponent<TableGridSwitchProps & RefAttributes<HTMLDivElement>>;
 
 declare interface TableGridSwitchProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
@@ -3448,6 +4149,21 @@ declare interface TableGroupBy {
     id: string;
 }
 
+/** 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>
+}
+
 export declare const TableSearch: FC<TableSearchProps>;
 
 export declare interface TableSearchProps {
@@ -3466,6 +4182,51 @@ export declare interface TableSettingsFallbackProps {
     children?: React.ReactNode;
 }
 
+/** 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>>
+}
+
 declare interface TabStateByScope {
     [scope: string]: DetailsPanelTab;
 }
@@ -3632,6 +4393,12 @@ export declare interface ThumbnailSimpleProps extends default_2.HTMLAttributes<H
  */
 export declare const toggleBlockFormat: (editor: LexicalEditor, format: BlockFormat, mode?: "toggle" | "set") => void;
 
+/**
+ * An addon's menu entries as the shared Menu's items: `to` and `href` become links (the Menu
+ * follows them), and a failing `onClick` is reported as a toast naming the addon.
+ */
+export declare const toMenuItems: (items: AddonMenuItem[], contribution: AnyContribution) => MenuItemType[];
+
 export declare type ToolbarItem = 'h1' | 'h2' | 'h3' | 'bold' | 'italic' | 'strikethrough' | 'code' | 'link' | 'codeBlock' | 'quote' | 'numberList' | 'bulletList' | 'checkList';
 
 export declare type ToolbarLayout = (ToolbarItem | '|')[];
@@ -3695,6 +4462,21 @@ export declare const UploadVersionDialog: FC<UploadVersionDialogProps>;
 declare interface UploadVersionDialogProps {
 }
 
+/**
+ * The sections addons contribute to this page's Customize panel (projectTable.customizeSection
+ * slot, @ynput/ayon-addon), for ProjectTableSettings' `settings`. The entries show from the
+ * descriptions; a section's code loads when it is opened (the panel only renders the open one).
+ */
+export declare const useAddonCustomizeSections: (page: ProjectTablePage) => SettingConfig[];
+
+/** `table`: which table this is; no shortcuts when not set. */
+export declare const useAddonTableShortcuts: (table: ShortcutTable | undefined) => {
+    hasShortcuts: boolean;
+    handleShortcut: (event: ShortcutKeyEvent, getContext: () => Omit<TableShortcutContext, "table"> | undefined) => boolean;
+    runShortcut: (contribution: Contribution<"table.shortcut">, context: TableShortcutContext) => void;
+    dialog: OpenAddonShortcutDialog | null;
+};
+
 export declare const useBuildFilterOptions: ({ filterTypes: globalFilterTypes, projectNames, scope, scopes: customScopes, data, config, power, }: BuildFilterOptions) => {
     options: Option_2[];
     groupOptions: SearchFilterGroupOption[];
@@ -3737,6 +4519,9 @@ export declare const useFeedbackSafe: () => FeedbackContextType | undefined;
 
 export declare const useOptionalVersionUploadContext: () => VersionUploadContextType | null;
 
+/** The context of a project.page contribution. */
+export declare const useProjectPageSlotContext: (projectName: string) => SlotMap["project.page"]["context"];
+
 export declare const USER_KEY_PREFIX = "user:";
 
 declare type UserAttribModel = {
@@ -3794,6 +4579,9 @@ declare type UserSuggestionItem = {
     fullName?: string;
 };
 
+/** The context of a studio.page contribution. */
+export declare const useStudioPageSlotContext: (selectedProjects: string[]) => SlotMap["studio.page"]["context"];
+
 export declare const useUpdateLinks: ({ projectName, direction, entityId, entityType, targetEntityType, linkType, }: Props) => {
     remove: RemoveLinks;
     add: AddLinks;
@@ -4299,6 +5087,12 @@ declare const viewsQueries: Api<BaseQueryFn<string | {
     } | FetchArgs, unknown, FetchBaseQueryError, {} | Partial<Pick< ClientError, "response" | "request">>>, string, ViewListModel, "restApi", unknown>, ViewListItemModel[]>;
 }>, string, never>, "restApi", string, typeof coreModuleName | typeof reactHooksModuleName>;
 
+/** 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 interface ViewsWithReportsSettings extends ViewsContextValue {
     viewSettings: GenericViewModel['settings'] | undefined;
     settings: GenericViewModel['settings'] | undefined;
@@ -4365,6 +5159,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'];