@ynput/ayon-frontend-shared 0.3.29 → 0.3.31

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

@@ -1,6 +1,7 @@
 import { default as React } from 'react';
 import { Tag, DetailsPanelEntityType, DetailsPanelEntityData } from '../../api';
 import { ProjectModelWithProducts } from '../../context';
+import { DetailsPanelEntityListsContext } from './components/DetailsPanelMoreMenu';
 export declare const entitiesWithoutFeed: string[];
 type User = {
     avatarUrl: string;
@@ -35,12 +36,19 @@ export type DetailsPanelProps = {
     onOpenViewer?: (entity: any) => void;
     onEntityFocus?: (id: string, entityType: DetailsPanelEntityType) => void;
     onOpen?: () => void;
-    onUriOpen?: (entity: DetailsPanelEntityData) => void;
+    onUriOpen?: (entity: DetailsPanelEntityData, source: 'uri' | 'url') => void;
     annotations?: any;
     removeAnnotation?: (id: string) => void;
     exportAnnotationComposite?: (id: string) => Promise<Blob | null>;
     entityListId?: string;
     guestCategories?: Record<string, string>;
+    /** Optional EntityListsContext for the "Add to list" sub-menu in the more-menu.
+     *  Hosts that already mount EntityListsProvider can pass the resolved context here;
+     *  otherwise wrap the panel with EntityListsContextBoundary. The shape mirrors
+     *  `EntityListsContextType` from `src/pages/ProjectListsPage/context` — it lives as a
+     *  structural type in shared/ so the layering rule (shared cannot import src/pages)
+     *  is preserved. */
+    entityListsContext?: DetailsPanelEntityListsContext;
 };
 export declare const DetailsPanel: ({ isOpen, entityType, ...props }: Omit<DetailsPanelProps, "entityType"> & {
     entityType?: DetailsPanelEntityType;

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

@@ -5,13 +5,13 @@ export declare const Toolbar: import('styled-components/dist/types').IStyledComp
 }, never>>> & string & Omit<import('react').ForwardRefExoticComponent<import('react').HTMLAttributes<HTMLElement> & import('react').RefAttributes<HTMLElement>>, keyof import('react').Component<any, {}, any>>;
 export declare const RightTools: 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 Panel: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<Omit<import('react').HTMLAttributes<HTMLDivElement> & {
-    direction?: "row" | "column";
+    direction?: "column" | "row" | undefined;
 } & import('react').RefAttributes<HTMLDivElement>, "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('react').HTMLAttributes<HTMLDivElement> & {
-    direction?: "row" | "column";
+    direction?: "column" | "row" | undefined;
 } & import('react').RefAttributes<HTMLDivElement>, "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 & Omit<import('react').ForwardRefExoticComponent<import('react').HTMLAttributes<HTMLDivElement> & {
-    direction?: "row" | "column";
+    direction?: "column" | "row" | undefined;
 } & import('react').RefAttributes<HTMLDivElement>>, keyof import('react').Component<any, {}, any>>;

package/dist/types/containers/DetailsPanel/components/DetailsPanelHeader/DetailsPanelHeader.d.ts

@@ -1,3 +1,4 @@
+import { RefObject } from 'react';
 import { DetailsPanelProps } from '../../..';
 import { DetailsPanelEntityData } from '../../../../api';
 import { DetailsPanelTab } from '../../../../context';
@@ -21,6 +22,8 @@ type DetailsPanelHeaderProps = {
     onOpenViewer: (args: any) => void;
     onEntityFocus: DetailsPanelProps['onEntityFocus'];
     entityTypeIcons: EntityTypeIcons;
+    thumbnailInputRef: RefObject<HTMLInputElement>;
+    versionsInputRef: RefObject<HTMLInputElement>;
 };
-declare const DetailsPanelHeader: ({ entityType, entitySubTypes, entities, disabledAssignees, users, disabledStatuses, tagsOptions, isFetching, isCompact, currentTab, onTabChange, entityTypeIcons, onOpenViewer, onEntityFocus, }: DetailsPanelHeaderProps) => import("react/jsx-runtime").JSX.Element;
+declare const DetailsPanelHeader: ({ entityType, entitySubTypes, entities, disabledAssignees, users, disabledStatuses, tagsOptions, isFetching, isCompact, currentTab, onTabChange, entityTypeIcons, onOpenViewer, onEntityFocus, thumbnailInputRef, versionsInputRef, }: DetailsPanelHeaderProps) => import("react/jsx-runtime").JSX.Element;
 export default DetailsPanelHeader;

package/dist/types/containers/DetailsPanel/components/DetailsPanelMoreMenu/DetailsPanelMoreMenu.d.ts

@@ -0,0 +1,17 @@
+import { DetailsPanelEntityListsContext, SelectedEntityRef } from './types';
+export interface DetailsPanelMoreMenuProps {
+    entityType: string;
+    entityId?: string;
+    entityIds?: string[];
+    entityLabel?: string;
+    projectName?: string;
+    selectedEntities?: SelectedEntityRef[];
+    entityListsContext?: DetailsPanelEntityListsContext;
+    onOpenPip?: () => void;
+    onOpenViewer?: (args: any) => void;
+    productId?: string;
+    taskId?: string;
+    folderId?: string;
+}
+export declare const DetailsPanelMoreMenu: ({ entityType, entityId, entityIds, entityLabel, projectName, selectedEntities, entityListsContext, onOpenPip, onOpenViewer, productId, taskId, folderId, }: DetailsPanelMoreMenuProps) => import("react/jsx-runtime").JSX.Element;
+export default DetailsPanelMoreMenu;

package/dist/types/containers/DetailsPanel/components/DetailsPanelMoreMenu/components/ShareDialog.d.ts

@@ -0,0 +1,8 @@
+export interface ShareDialogProps {
+    link: string;
+    entityLabel: string;
+    visible: boolean;
+    onHide: () => void;
+}
+export declare const ShareDialog: ({ link, entityLabel, visible, onHide }: ShareDialogProps) => import("react/jsx-runtime").JSX.Element | null;
+export default ShareDialog;

package/dist/types/containers/DetailsPanel/components/DetailsPanelMoreMenu/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useContextAccess } from './useContextAccess';
+export { useMenuOptions } from './useMenuOptions';

package/dist/types/containers/DetailsPanel/components/DetailsPanelMoreMenu/hooks/useContextAccess.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Reads VersionUploadContext without throwing when the provider is absent.
+ * Replaces a try/catch around `useVersionUploadContext()` (which violated the
+ * Rules of Hooks if the throwing hook was ever to call additional hooks).
+ */
+export declare const useContextAccess: () => {
+    onOpenVersionUpload: ((params: {
+        productId?: string;
+        folderId?: string;
+        taskId?: string;
+        linkedTask?: import('../../../../../components').LinkedTask;
+        latestVersionNumber?: number;
+        latestVersionId?: string;
+    }) => void) | null;
+};

package/dist/types/containers/DetailsPanel/components/DetailsPanelMoreMenu/hooks/useMenuOptions.d.ts

@@ -0,0 +1,25 @@
+import { MenuItemType } from '../../../../../components';
+import { DetailsPanelEntityListsContext, SelectedEntityRef } from '../types';
+interface UseMenuOptionsParams {
+    entityType: string;
+    entityId?: string;
+    projectName?: string;
+    selectedEntities: SelectedEntityRef[];
+    canUploadThumbnail: boolean;
+    canUploadVersion: boolean;
+    canOpenPip: boolean;
+    canOpenViewer: boolean;
+    entityListsContext: DetailsPanelEntityListsContext | undefined;
+    onPip: () => void;
+    onOpenViewer: () => void;
+    onUploadThumbnail: () => void;
+    onUploadVersion: () => void;
+    onShare: (link: string) => void;
+    onViewData: () => void;
+}
+export interface MenuOptionsResult {
+    items: MenuItemType[];
+    shareLink: string | null;
+}
+export declare const useMenuOptions: ({ entityType, entityId, projectName, selectedEntities, canUploadThumbnail, canUploadVersion, canOpenPip, canOpenViewer, entityListsContext, onPip, onOpenViewer, onUploadThumbnail, onUploadVersion, onShare, onViewData, }: UseMenuOptionsParams) => MenuOptionsResult;
+export {};

package/dist/types/containers/DetailsPanel/components/DetailsPanelMoreMenu/index.d.ts

@@ -0,0 +1,3 @@
+export { DetailsPanelMoreMenu } from './DetailsPanelMoreMenu';
+export type { DetailsPanelMoreMenuProps } from './DetailsPanelMoreMenu';
+export type { DetailsPanelEntityListsContext, EntityList, SelectedEntityRef, } from './types';

package/dist/types/containers/DetailsPanel/components/DetailsPanelMoreMenu/types.d.ts

@@ -0,0 +1,44 @@
+import { MenuItemType } from '../../../../components';
+/**
+ * Selected entity reference passed to the more-menu's "Add to list" sub-menu.
+ */
+export interface SelectedEntityRef {
+    entityId: string;
+    entityType?: string;
+    hasReviewables?: boolean;
+}
+/**
+ * Generic list shape produced by the project-lists context. Kept minimal — only the
+ * fields the more-menu cares about. The full type lives in
+ * `src/pages/ProjectListsPage/context/EntityListsContext.tsx`; we don't import it
+ * directly because `shared/` cannot depend on `src/pages/`.
+ */
+export interface EntityList {
+    id: string;
+    label?: string;
+    entityType?: string;
+    [key: string]: unknown;
+}
+/**
+ * Structural interface for the EntityLists context as consumed by the details-panel
+ * more-menu. Shadows the public API surface of `EntityListsContextType` from
+ * `src/pages/ProjectListsPage/context` without importing it (layering: shared → src
+ * is forbidden). When the source type changes, update this interface to match.
+ */
+export interface DetailsPanelEntityListsContext {
+    folders: EntityList[];
+    tasks: EntityList[];
+    products: EntityList[];
+    versions: EntityList[];
+    reviews: EntityList[];
+    buildHierarchicalMenuItems?: (lists: EntityList[], selected: SelectedEntityRef[], showIcon?: (list: EntityList) => boolean) => MenuItemType[];
+    buildAddToListMenu?: (items: MenuItemType[], menu?: {
+        label?: string;
+    }) => {
+        id: string;
+        label: string;
+        icon: string;
+        items: MenuItemType[];
+    };
+    newListMenuItem?: (entityType: 'folder' | 'task' | 'version', selected: SelectedEntityRef[]) => MenuItemType | undefined;
+}

package/dist/types/containers/DetailsPanel/components/TabHeaderAndFilters/TabHeaderAndFilters.d.ts

@@ -1,11 +1,10 @@
-import { QueryCondition } from '../../../../api';
-import { AttributeEnumItem } from '../../../../containers/ProjectTreeTable/types';
+import { QueryCondition, EnumItem } from '../../../../api';
 export interface FilterItem<T = string> {
     id: T;
     tooltip: string;
     icon: string;
     type?: 'boolean' | 'enum' | 'search';
-    options?: AttributeEnumItem[];
+    options?: EnumItem[];
     placeholder?: string;
     operator?: QueryCondition['operator'];
 }

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

@@ -11,6 +11,8 @@ interface ActivityReferenceProps extends Omit<React.HTMLAttributes<HTMLElement>,
     }) => void;
     categoryPrimary?: string;
     categorySecondary?: string;
+    'data-mention-value'?: string;
+    'data-mention-label'?: string;
 }
 declare const ActivityReference: React.FC<ActivityReferenceProps>;
 export default ActivityReference;

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

@@ -0,0 +1,22 @@
+import { default as QuillType } from 'quill';
+type TypeOption = {
+    id: string;
+    isCircle?: boolean;
+};
+type TypeOptions = Record<string, TypeOption>;
+interface MentionClipboardOptions {
+    typeOptions?: TypeOptions;
+    refTypes?: readonly string[];
+}
+declare class MentionClipboard {
+    private quill;
+    private root;
+    private typeOptions;
+    private refTypes;
+    private mentionMdRe;
+    constructor(quill: QuillType, options?: MentionClipboardOptions);
+    private matchAnchor;
+    private handleCopy;
+    private handlePaste;
+}
+export default MentionClipboard;

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

@@ -1,6 +1,7 @@
 export declare const quillFormats: string[];
-export declare const getModules: ({ imageUploader, disableImageUpload }: {
+export declare const getModules: ({ imageUploader, mentionTypeOptions, disableImageUpload }: {
     imageUploader: any;
+    mentionTypeOptions: any;
     disableImageUpload?: boolean | undefined;
 }) => {
     toolbar: ((string | {
@@ -10,4 +11,7 @@ export declare const getModules: ({ imageUploader, disableImageUpload }: {
     }[])[];
     imageUploader: any;
     magicUrl: boolean;
+    mentionClipboard: {
+        typeOptions: any;
+    };
 };

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

@@ -0,0 +1,4 @@
+import { RowData } from '@tanstack/react-table';
+import { ListTableProps } from './ListTable.types';
+export type { ListTableGroupDisplay, ListTableGroupingPathItem, ListTableProps, ListTableRowDoubleClickContext, ListTableRowDoubleClickHandler, ListTableRowContextMenuBuilder, ListTableRowContextMenuContext, } from './ListTable.types';
+export declare function ListTable<TData extends RowData>({ data, columns, getRowId, fetchNextPage, hasNextPage, isFetchingNextPage, onUpdateRow, onOpenViewer, editable, onReorderRows, rowContextMenuBuilders, onRowDoubleClick, selectedRows, onSelectedRowsChange, multiSelection, cellWrapper, columnAttributeData, dataTypeWidgets, enableColumnReordering, columnOrder: columnOrderProp, onColumnOrderChange, enableColumnVisibility, columnVisibility: columnVisibilityProp, defaultColumnVisibility, onColumnVisibilityChange, enableColumnResizing, columnSizing: columnSizingProp, onColumnSizingChange, enableSorting, sorting: sortingProp, onSortingChange, getIsRowInactive, }: ListTableProps<TData>): import("react/jsx-runtime").JSX.Element;

package/dist/types/containers/ListTable/ListTable.styled.d.ts

@@ -0,0 +1,37 @@
+export declare const TR: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never>>> & string;
+export declare const TD: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, never>>> & string;
+export declare const TDInner: 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 PlaceholderRowContent: 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 ListTableCellWrapper: 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 EditableCellValue: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$isEditing"> & {
+    $isEditing?: boolean;
+}, never> & Partial<Pick<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$isEditing"> & {
+    $isEditing?: boolean;
+}, 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 Table: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, never>>> & string;
+export declare const THead: 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 HeaderTR: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never>>> & string;
+export declare const TH: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never>>> & string;
+export declare const TBody: 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 LoaderTR: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never>>> & string;
+export declare const OverlayTR: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, never>>> & string;
+export declare const SortableTHStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never>>> & string;
+export declare const GroupRowContent: 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 Expander: 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 GroupTD: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, never>>> & string;
+export declare const GroupCount: 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 GroupColorDot: 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 DraggedColumnHeader: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, never>>> & string;
+export declare const THContent: 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 THActions: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref" | "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "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;
+}, "className"> & Partial<Pick<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref" | "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & Omit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "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;
+}, "className">>> & string;
+export declare const ResizeHandle: 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/ListTable/ListTable.types.d.ts

@@ -0,0 +1,75 @@
+import { ColumnDef, ColumnOrderState, Row, ColumnSizingState, RowData, SortingState, VisibilityState } from '@tanstack/react-table';
+import { ContextMenuItemType } from '../ContextMenu';
+import { CellWrapperRenderer } from './ListTableCell';
+import { ListTableColumnAttributeData, ListTableDataTypeWidgets } from './ListTableWidgets';
+export type ListTableGroupDisplay = {
+    value?: unknown;
+    label?: string;
+    icon?: string;
+    color?: string;
+    sortValue?: string | number;
+    sortIndex?: number;
+};
+export type ListTableGroupingPathItem = unknown | ListTableGroupDisplay;
+export type ListTableRowContextMenuContext<TData extends RowData> = {
+    rowId: string;
+    rowIndex: number;
+    row: Row<TData>;
+    selectedRows: string[];
+    isSelected: boolean;
+    isGroupRow: boolean;
+    groupColumnId?: string;
+    groupValue?: unknown;
+};
+export type ListTableRowDoubleClickContext<TData extends RowData> = {
+    rowId: string;
+    rowIndex: number;
+    row: Row<TData>;
+    isSelected: boolean;
+};
+export type ListTableRowContextMenuBuilder<TData extends RowData> = (e: React.MouseEvent<HTMLTableRowElement>, context: ListTableRowContextMenuContext<TData>) => ContextMenuItemType | ContextMenuItemType[] | undefined;
+export type ListTableRowDoubleClickHandler<TData extends RowData> = (e: React.MouseEvent<HTMLTableRowElement>, context: ListTableRowDoubleClickContext<TData>) => void;
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        listTableCustomCell?: boolean;
+        editable?: boolean;
+    }
+    interface TableMeta<TData extends RowData> {
+        updateData: (columnId: string, value: unknown, rowId: string) => void;
+        openViewerDialog?: (row: TData) => void;
+    }
+}
+export interface ListTableProps<TData> {
+    data: TData[];
+    columns: ColumnDef<TData, any>[];
+    getRowId?: (originalRow: TData, index: number) => string;
+    fetchNextPage?: () => void;
+    hasNextPage?: boolean;
+    isFetchingNextPage?: boolean;
+    onUpdateRow: (columnId: string, value: unknown, rowId: string) => void;
+    onOpenViewer?: (row: TData) => void;
+    editable?: boolean;
+    onReorderRows?: (startIndex: number, endIndex: number) => void;
+    rowContextMenuBuilders?: ListTableRowContextMenuBuilder<TData>[];
+    onRowDoubleClick?: ListTableRowDoubleClickHandler<TData>;
+    selectedRows?: string[];
+    onSelectedRowsChange?: (ids: string[]) => void;
+    multiSelection?: boolean;
+    cellWrapper?: CellWrapperRenderer<TData>;
+    columnAttributeData?: ListTableColumnAttributeData;
+    dataTypeWidgets?: ListTableDataTypeWidgets<TData>;
+    enableColumnReordering?: boolean;
+    columnOrder?: ColumnOrderState;
+    onColumnOrderChange?: (order: ColumnOrderState) => void;
+    enableColumnVisibility?: boolean;
+    columnVisibility?: VisibilityState;
+    defaultColumnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: (visibility: VisibilityState) => void;
+    enableColumnResizing?: boolean;
+    columnSizing?: ColumnSizingState;
+    onColumnSizingChange?: (sizing: ColumnSizingState) => void;
+    enableSorting?: boolean;
+    sorting?: SortingState;
+    onSortingChange?: (sorting: SortingState) => void;
+    getIsRowInactive?: (row: TData) => boolean;
+}

package/dist/types/containers/ListTable/ListTableCell.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+import { Row, RowData } from '@tanstack/react-table';
+import { ListTableColumnAttributeData, ListTableDataTypeWidgets } from './ListTableWidgets';
+export type CellWrapperRenderer<TData extends RowData> = ((row: Row<TData>, content: React.ReactNode) => React.ReactElement | null) | null;
+export interface ListTableCellEditingState {
+    editingCellId: string | null;
+    startEditingCell: (cellId: string) => void;
+    stopEditingCell: () => void;
+    getDraftValue: () => string | null;
+    setDraftValue: (value: string | null) => void;
+}
+export interface ListTableCellCallbacks<TData extends RowData> {
+    onUpdateRow: (columnId: string, value: unknown, rowId: string) => void;
+    onOpenViewer?: (row: TData) => void;
+}
+interface RowCellsProps<TData extends RowData> {
+    row: Row<TData>;
+    cellWrapper?: CellWrapperRenderer<TData>;
+    columnAttributeData?: ListTableColumnAttributeData;
+    dataTypeWidgets?: ListTableDataTypeWidgets<TData>;
+    editingState: ListTableCellEditingState;
+    callbacks: ListTableCellCallbacks<TData>;
+    editable?: boolean;
+}
+export declare const RowCells: <TData extends RowData>({ row, cellWrapper, columnAttributeData, dataTypeWidgets, editingState, callbacks, editable, }: RowCellsProps<TData>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/containers/ListTable/ListTableGroupRow.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+import { ListTableGroupDisplay } from './ListTable.types';
+export declare const INTERNAL_GROUPING_COLUMN_PREFIX = "__group_path__";
+export declare const parseInternalGroupingColumnId: (columnId: string) => {
+    baseColumnId: string;
+    level: number;
+} | null;
+export declare const isGroupDisplayValue: (value: unknown) => value is ListTableGroupDisplay;
+export declare const isCustomGroupRowValue: (value: unknown) => value is {
+    __listTableGroup: true;
+    __groupColumnId: string;
+    __groupValue: unknown;
+};
+/** Format a raw group column value into a human-readable label. */
+export declare function defaultGroupLabel(columnId: string, value: unknown): string;
+interface GroupRowProps {
+    groupColumnId: string;
+    groupValue: unknown;
+    count: number;
+    countLabel?: string;
+    depth: number;
+    isExpanded: boolean;
+    onToggle: () => void;
+    virtualStart: number;
+    onContextMenu?: React.MouseEventHandler<HTMLTableRowElement>;
+}
+export declare function GroupRow({ groupColumnId, groupValue, count, countLabel, depth, isExpanded, onToggle, virtualStart, onContextMenu, }: GroupRowProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/containers/ListTable/ListTableHeader.d.ts

@@ -0,0 +1,11 @@
+import { Header, RowData } from '@tanstack/react-table';
+interface SortableTHProps<TData> {
+    header: Header<TData, any>;
+    enabled: boolean;
+    enableSorting?: boolean;
+    enableColumnVisibility?: boolean;
+    enableColumnResizing?: boolean;
+    isLast?: boolean;
+}
+export declare function SortableTHComponent<TData extends RowData>({ header, enabled, enableSorting, enableColumnVisibility, enableColumnResizing, isLast, }: SortableTHProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/containers/ListTable/ListTableRow.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { Row, RowData } from '@tanstack/react-table';
+import { CellWrapperRenderer, ListTableCellCallbacks, ListTableCellEditingState } from './ListTableCell';
+import { ListTableColumnAttributeData, ListTableDataTypeWidgets } from './ListTableWidgets';
+interface DraggableRowProps<TData extends RowData> {
+    row: Row<TData>;
+    virtualRow: any;
+    isSelected: boolean;
+    rowIndex: number;
+    onRowClick: (rowId: string, rowIndex: number, e: React.MouseEvent) => void;
+    onRowDoubleClick?: (rowId: string, rowIndex: number, e: React.MouseEvent<HTMLTableRowElement>) => void;
+    onRowContextMenu?: (rowId: string, rowIndex: number, e: React.MouseEvent<HTMLTableRowElement>) => void;
+    cellWrapper?: CellWrapperRenderer<TData>;
+    columnAttributeData?: ListTableColumnAttributeData;
+    dataTypeWidgets?: ListTableDataTypeWidgets<TData>;
+    editingState: ListTableCellEditingState;
+    callbacks: ListTableCellCallbacks<TData>;
+    editable?: boolean;
+    isInactive?: boolean;
+}
+declare function DraggableRowInner<TData extends RowData>({ row, virtualRow, isSelected, rowIndex, onRowClick, onRowDoubleClick, onRowContextMenu, cellWrapper, columnAttributeData, dataTypeWidgets, editingState, callbacks, editable, isInactive, }: DraggableRowProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare const DraggableRow: typeof DraggableRowInner;
+export {};

package/dist/types/containers/ListTable/ListTableWidgets.d.ts

@@ -0,0 +1,27 @@
+import { AttributeData } from '../../api';
+import { Cell, Row, RowData } from '@tanstack/react-table';
+export type ListTableAttributeType = NonNullable<AttributeData['type']>;
+export type ListTableColumnAttributeData = Partial<Record<string, AttributeData>>;
+export interface ListTableWidgetRenderContext<TData extends RowData> {
+    row: Row<TData>;
+    cell: Cell<TData, unknown>;
+    value: unknown;
+    rowIndex: number;
+    columnId: string;
+    cellId: string;
+    attributeData: AttributeData;
+    isEditing: boolean;
+    isReadOnly: boolean;
+    startEditing: () => void;
+    stopEditing: () => void;
+    updateValue: (value: unknown) => void;
+    openViewer: () => void;
+    getDraftValue: () => string | null;
+    setDraftValue: (value: string | null) => void;
+}
+export type ListTableWidgetRenderer<TData extends RowData> = (context: ListTableWidgetRenderContext<TData>) => React.ReactNode;
+export type ListTableDataTypeWidgets<TData extends RowData> = Partial<Record<ListTableAttributeType, ListTableWidgetRenderer<TData>>>;
+export declare const defaultListTableDataTypeWidgets: ListTableDataTypeWidgets<any>;
+export declare const getDefaultListTableDataTypeWidgets: <TData extends RowData>() => ListTableDataTypeWidgets<TData>;
+export declare const getListTableCellId: (rowId: string, columnId: string) => string;
+export declare const renderListTableFallbackValue: (value: unknown) => string;

package/dist/types/containers/ListTable/hooks/useColumnWidthVars.d.ts

@@ -0,0 +1,11 @@
+import { RowData, Table } from '@tanstack/react-table';
+/**
+ * Computes CSS variable key/value pairs for each column's current size.
+ * Apply these as inline style on the <table> element so that column-width
+ * changes during resize only mutate a single DOM node's style attribute —
+ * no React re-renders of rows are triggered.
+ *
+ * Header cells should use: `calc(var(--header-{id}-size) * 1px)`
+ * Body cells should use:   `calc(var(--col-{id}-size) * 1px)`
+ */
+export declare function useColumnWidthVars<TData extends RowData>(table: Table<TData>): Record<string, number>;

package/dist/types/containers/ListTable/hooks/useTableColumnOrder.d.ts

@@ -0,0 +1,5 @@
+import { ColumnDef, ColumnOrderState, RowData } from '@tanstack/react-table';
+export declare function useTableColumnOrder<TData extends RowData>(columns: ColumnDef<TData, any>[], columnOrderProp?: ColumnOrderState): {
+    columnOrder: ColumnOrderState;
+    setColumnOrder: import('react').Dispatch<import('react').SetStateAction<ColumnOrderState>>;
+};

package/dist/types/containers/ListTable/hooks/useTableDnd.d.ts

@@ -0,0 +1,21 @@
+import { DragEndEvent, DragStartEvent } from '@dnd-kit/core';
+import { ColumnOrderState, Row, RowData } from '@tanstack/react-table';
+interface UseTableDndOptions<TData extends RowData> {
+    rows: Row<TData>[];
+    columnOrder: ColumnOrderState;
+    onReorderRows?: (startIndex: number, endIndex: number) => void;
+    setColumnOrder: (updater: (prev: ColumnOrderState) => ColumnOrderState) => void;
+    onColumnOrderChange?: (order: ColumnOrderState) => void;
+}
+export declare function useTableDnd<TData extends RowData>({ rows, columnOrder, onReorderRows, setColumnOrder, onColumnOrderChange, }: UseTableDndOptions<TData>): {
+    sensors: import('@dnd-kit/core').SensorDescriptor<import('@dnd-kit/core').SensorOptions>[];
+    activeRowId: string | null;
+    activeColumnId: string | null;
+    handleColumnDragStart: (event: DragStartEvent) => void;
+    handleColumnDragEnd: (event: DragEndEvent) => void;
+    handleColumnDragCancel: () => void;
+    handleRowDragStart: (event: DragStartEvent) => void;
+    handleRowDragEnd: (event: DragEndEvent) => void;
+    handleRowDragCancel: () => void;
+};
+export {};

package/dist/types/containers/ListTable/hooks/useTableEditing.d.ts

@@ -0,0 +1,4 @@
+import { ListTableCellEditingState } from '../ListTableCell';
+export declare function useTableEditing(): {
+    editingState: ListTableCellEditingState;
+};

package/dist/types/containers/ListTable/hooks/useTableSelection.d.ts

@@ -0,0 +1,16 @@
+import { Row, RowData } from '@tanstack/react-table';
+import { Virtualizer } from '@tanstack/react-virtual';
+interface UseTableSelectionOptions<TData extends RowData> {
+    rows: Row<TData>[];
+    selectedRows: string[];
+    onSelectedRowsChange?: (ids: string[]) => void;
+    multiSelection: boolean;
+    rowVirtualizer: Virtualizer<HTMLDivElement, Element>;
+    tableContainerRef: React.RefObject<HTMLDivElement>;
+}
+export declare function useTableSelection<TData extends RowData>({ rows, selectedRows, onSelectedRowsChange, multiSelection, rowVirtualizer, tableContainerRef, }: UseTableSelectionOptions<TData>): {
+    activeRowIndex: number;
+    handleRowClick: (rowId: string, rowIndex: number, e: React.MouseEvent) => void;
+    handleKeyDown: (e: React.KeyboardEvent<HTMLDivElement>) => void;
+};
+export {};

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

@@ -0,0 +1,3 @@
+export * from './ListTable';
+export * from './ListTableWidgets';
+export * from './utils/buildGroupedData';

package/dist/types/containers/ListTable/utils/buildGroupedData.d.ts

@@ -0,0 +1,32 @@
+import { RowData } from '@tanstack/react-table';
+import { ListTableGroupDisplay, ListTableGroupingPathItem } from '../ListTable.types';
+/**
+ * A group row that can be mixed into the data array passed to ListTable.
+ * TData must extend this type (optional fields) so the row shape is compatible.
+ */
+export type ListTableGroupRow<TData> = {
+    id: string;
+    __listTableGroup: true;
+    __groupColumnId: string;
+    __groupValue: ListTableGroupingPathItem;
+    __groupKey: string;
+    subRows: (ListTableGroupRow<TData> | TData)[];
+};
+export declare const isListTableGroupDisplayObject: (value: unknown) => value is ListTableGroupDisplay;
+export declare const isListTableGroupRow: <TData>(row: TData | ListTableGroupRow<TData>) => row is ListTableGroupRow<TData>;
+export declare const getGroupItemValue: (value: ListTableGroupingPathItem | undefined) => unknown;
+export declare const compareGroupingPathItems: (left: ListTableGroupingPathItem | undefined, right: ListTableGroupingPathItem | undefined) => number;
+export type GetGroupingPath<TData> = (columnId: string, row: TData) => ListTableGroupingPathItem[] | undefined;
+export type CreateGroupRow<TData> = (columnId: string, groupKey: string, groupValue: ListTableGroupingPathItem) => ListTableGroupRow<TData>;
+export type GetRowColumnValue<TData> = (row: TData, columnId: string) => unknown;
+/**
+ * Builds a nested tree of group rows from a flat array.
+ *
+ * @param data        - Flat leaf rows
+ * @param grouping    - Ordered list of column IDs to group by
+ * @param groupSortByDesc - Sort group rows descending
+ * @param getGroupingPath - Per-row path segments for a given column (allows multi-level folder paths)
+ * @param createGroupRow  - Factory that constructs a typed group row
+ * @param getRowColumnValue - Fallback to read a plain column value when getGroupingPath returns undefined
+ */
+export declare const buildGroupedData: <TData extends RowData>(data: TData[], grouping: string[], groupSortByDesc: boolean, getGroupingPath: GetGroupingPath<TData>, createGroupRow: CreateGroupRow<TData>, getRowColumnValue: GetRowColumnValue<TData>) => (ListTableGroupRow<TData> | TData)[];