@orangelogic/orange-dam-content-browser-sdk 2.4.8 → 2.4.9

package/build/api/asset/asset.d.ts

@@ -36,7 +36,8 @@ export declare function resolveAssetExtraFilters(selectedFacets?: Record<string,
 };
 export declare function apiGetAssetLinks({ assets, extension, extraFields, parameters, permanentLink, proxyPreference, transformations, useSession, }: GetAssetLinksRequest): Promise<GetAssetLinksResponse>;
 export declare function apiGetAssetsByIDs({ extraFields, recordIds, }: GetAssetsByIDsRequest): Promise<GetAssetsByIDsResponse>;
-export declare function apiGetAssets({ folderId, isSeeThrough, limitedToDocTypes, pageSize, searchText, selectedFacets, sortOrder, start, useSession, }: GetAssetsRequest): Promise<GetAssetsResponse>;
+export declare const ASSET_LIST_FIELDS: string[];
+export declare function apiGetAssets({ fields, folderId, isSeeThrough, limitedToDocTypes, pageSize, searchText, selectedFacets, sortOrder, start, useSession, }: GetAssetsRequest): Promise<GetAssetsResponse>;
 export declare function apiGetAvailableProxies({ assetRecordId, siteUrl, }: {
     assetRecordId: string;
     siteUrl?: string;

package/build/api/asset/asset.types.d.ts

@@ -57,12 +57,21 @@ export type GetAssetsRawResponse = {
     contentItems?: ContentItem[];
     facets: Facet[];
     totalCount: number;
+    /** Absent on a Cortex build older than L-42BJ3T. */
+    unreadableFields?: string[];
 };
 export type GetAssetsResponse = {
     facets: Facet[];
     isError: boolean;
     items: Array<Asset & Record<string, string | boolean>>;
     totalCount: number;
+    /**
+     * The requested fields, spelled as sent, that the user cannot read on this page of records. Cortex
+     * still sends each one on every item, with an empty value, except a field that the
+     * `DbBOFieldSecurity_BO.Data.ObjectsInfoRetriever_IgnoredFields` parameter lists, which keeps its
+     * value. Empty when Cortex flags none, or when Cortex is too old to flag any.
+     */
+    unreadableFields: string[];
 };
 export type GetAvailableProxiesRequest = {
     assetRecordId: string;

package/build/components/content-browser/content-browser.d.ts

@@ -6,7 +6,8 @@ import CxContentBrowserFormatDialog from '../../components/content-browser-forma
 import CxContentBrowserGrid from '../../components/content-browser-grid/content-browser-grid';
 import CxContentBrowserHeader from '../../components/content-browser-header/content-browser-header';
 import CxContentBrowserNoResult from '../../components/content-browser-no-result/content-browser-no-result';
-import { type CtaTextTransform, GridView } from '../../types/content-browser';
+import CxContentBrowserTable from '../../components/content-browser-table/content-browser-table';
+import { type AutoSelectFormat, type ContentBrowserView, type CtaTextTransform, type TableColumn, type TableRowActionPosition } from '../../types/content-browser';
 import { GetFolderRequest } from '../../types/folder';
 import CxIcon from '@orangelogic/design-system/components/icon';
 import CxIconButton from '@orangelogic/design-system/components/icon-button';
@@ -18,6 +19,7 @@ export declare const COMPUTED_FIELDS: string[];
  * @summary CxContentBrowser
  */
 export default class CxContentBrowser extends CortexElement {
+    #private;
     static readonly styles: CSSResultGroup;
     static readonly dependencies: {
         'cx-content-browser-browser': typeof CxContentBrowserBrowser;
@@ -26,6 +28,7 @@ export default class CxContentBrowser extends CortexElement {
         'cx-content-browser-grid': typeof CxContentBrowserGrid;
         'cx-content-browser-header': typeof CxContentBrowserHeader;
         'cx-content-browser-no-result': typeof CxContentBrowserNoResult;
+        'cx-content-browser-table': typeof CxContentBrowserTable;
         'cx-icon': typeof CxIcon;
         'cx-icon-button': typeof CxIconButton;
         'cx-resize-observer': typeof CxResizeObserver;
@@ -61,6 +64,10 @@ export default class CxContentBrowser extends CortexElement {
      */
     canPinAsset: boolean;
     canUseProxies: boolean;
+    /**
+     * Host-level import behaviour; forwarded to the format dialog. See `AutoSelectFormat`.
+     */
+    autoSelectFormat: AutoSelectFormat;
     /**
      * Pick-only mode: no available-proxies lookup, no transformation on confirm. The preview popup
      * shows the asset's LargeSizePreview and confirming emits the asset straight to the host.
@@ -73,7 +80,29 @@ export default class CxContentBrowser extends CortexElement {
     ctaText: string;
     ctaTextTransform: CtaTextTransform;
     extraFields: string[];
-    defaultGridView: GridView;
+    defaultGridView: ContentBrowserView;
+    /**
+     * Columns of the table view, defined by the host: a title and the Cortex field the column reads.
+     * The table fits each column to its content, and the user resizes it. The table view is offered only while this is non-empty — an empty table is not a
+     * view mode — and the fields are read once, when the fetch controller is created.
+     */
+    tableColumns: TableColumn[];
+    /**
+     * Where the row action of the table view shows: at the right edge of the host (`host-edge`), or at
+     * the end of the last data column (`row-end`). Any other value gives `host-edge`.
+     */
+    tableRowActionPosition: TableRowActionPosition;
+    /** The widths the user saved for the table columns of this site, in pixels, keyed by field. */
+    private tableColumnWidths;
+    /**
+     * The reads and writes of the saved widths, one after the other: each write reads the stored map
+     * and writes it back, and a read that runs before a write would give the table a stale map.
+     */
+    private tableWidthQueue;
+    /** The number of reads and writes queued on `tableWidthQueue`. Only the last one gives its map to the table. */
+    private tableWidthTasks;
+    /** Set by a drag or a reset that the table shows, until a map from the storage replaces it. */
+    private tableWidthsChangedInTable;
     defaultSortOrderName: string;
     defaultSortDirection: 'ascending' | 'descending';
     defaultSelectedFacets: Record<string, string[]>;
@@ -109,6 +138,35 @@ export default class CxContentBrowser extends CortexElement {
     private initialFolderPending;
     private initialFolderTimeout;
     willUpdate(changedProperties: PropertyValues): void;
+    /**
+     * Never trust the host's value: it also arrives by direct property assignment, past the converter.
+     * Entries are checked one by one, not just the outer array — `field` is dereferenced while the
+     * fetch controller is being built, where a throw leaves the controller unassigned and the picker
+     * blank. `title` is only rendered, and Lit renders a nullish one as nothing, so a column is not
+     * worth dropping over it.
+     */
+    private get tableColumnList();
+    /**
+     * This reads the configured columns, not the shown ones. The shown columns can change with each
+     * response, and a table view that goes away with them flips the view and its page size. When
+     * Cortex flags each column, the rows stay with only the filler and the CTA column.
+     */
+    private get canUseTable();
+    /**
+     * Runs a read or a write of the saved widths after the ones queued before it. The table gets the
+     * map of the last task only: an earlier map does not hold the drags and resets that came after it,
+     * and the table already shows them. A map for a site that is no longer the current one is dropped.
+     */
+    private queueTableWidthTask;
+    /**
+     * A map with the same entries keeps the old one, so that the table does not lay out its columns
+     * again. After a drag or a reset the table can show widths that the old map does not hold, so the
+     * new map always replaces them.
+     */
+    private setTableColumnWidths;
+    private loadTableColumnWidths;
+    handleBaseUrlChangeForTableWidths(): void;
+    private handleTableColumnResize;
     runFirstUpdated(): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -120,8 +178,20 @@ export default class CxContentBrowser extends CortexElement {
      * pin/unpin request (see `cx-content-browser-pin-asset-change`) to reflect the result.
      */
     setIsAssetPinned(isAssetPinned: boolean): void;
+    /**
+     * The asset a click is still working on, or undefined. The two private flags below drive the
+     * guards; this drives the UI, and is a separate field because they are plain fields rather than
+     * reactive state.
+     *
+     * Cleared the moment the format dialog actually opens: from there the dialog's own confirm button
+     * carries the pending state, and two spinners for one operation reads as two operations. It
+     * survives when no dialog opens, which is the auto-confirm path, where the CTA is the only thing
+     * the user can be told anything by.
+     */
+    private busyAssetId;
     private openFormatDialog;
     handleLastRequestChange(): Promise<void>;
+    handleTableColumnsChange(): void;
     handleAuthChange(): void;
     handleSiteSessionChange(): void;
     private handleSortOrderChange;
@@ -144,6 +214,7 @@ export default class CxContentBrowser extends CortexElement {
      */
     private handlePinAssetChange;
     private handleProxyConfirm;
+    private reportProxyConfirmFailure;
     private handleFormatConfirm;
     private handleFormatDialogClose;
     private handleSelectedAsset;

package/build/components/content-browser-asset-card/content-browser-asset-card.d.ts

@@ -1,8 +1,9 @@
 import { CSSResultGroup } from 'lit';
 import CortexElement from '../../base/element';
 import { MediaType } from '../../types/asset';
-import { GridView } from '../../types/content-browser';
+import { type CtaTextTransform, GridView } from '../../types/content-browser';
 import CxArrayLineClamp from '@orangelogic/design-system/components/array-line-clamp';
+import CxButton from '@orangelogic/design-system/components/button';
 import CxCard from '@orangelogic/design-system/components/card';
 import CxCheckbox from '@orangelogic/design-system/components/checkbox';
 import CxLineClamp from '@orangelogic/design-system/components/line-clamp';
@@ -10,10 +11,19 @@ import CxSpace from '@orangelogic/design-system/components/space';
 import CxTag from '@orangelogic/design-system/components/tag';
 import CxTypography from '@orangelogic/design-system/components/typography';
 import CxContentBrowserAssetPreview from '../content-browser-asset-preview/content-browser-asset-preview';
+/**
+ * Grid view is pointer-only by design: the card is not focusable, and its CTA overlay is
+ * `aria-hidden` with a `tabindex="-1"` button because the overlay only restates what clicking the
+ * card already does. This diverges deliberately from `cx-content-browser-table`, whose rows are
+ * focusable and announce their CTA — the grid's keyboard gap predates the table view and closing it
+ * would change focus and screen-reader behaviour for every existing host. Revisit together with the
+ * grid's own keyboard support rather than per-feature.
+ */
 export default class CxContentBrowserAssetCard extends CortexElement {
     static readonly styles: CSSResultGroup;
     static readonly dependencies: {
         'cx-array-line-clamp': typeof CxArrayLineClamp;
+        'cx-button': typeof CxButton;
         'cx-card': typeof CxCard;
         'cx-checkbox': typeof CxCheckbox;
         'cx-content-browser-asset-preview': typeof CxContentBrowserAssetPreview;
@@ -22,6 +32,20 @@ export default class CxContentBrowserAssetCard extends CortexElement {
         'cx-tag': typeof CxTag;
         'cx-typography': typeof CxTypography;
     };
+    private readonly localize;
+    /**
+     * Show the hover overlay that says clicking this card inserts. Set when the host has asked to
+     * skip the format picker: without the dialog a click hands the asset over immediately, and the
+     * card would otherwise carry no sign of that.
+     */
+    showCta: boolean;
+    ctaText: string;
+    ctaTextTransform: CtaTextTransform;
+    /**
+     * This card's insert is still running: hold the overlay open and spin its CTA, so the feedback
+     * does not vanish the moment the pointer leaves.
+     */
+    busy: boolean;
     imageUrl: string;
     originalUrl: string;
     scrubUrl: string;

package/build/components/content-browser-control-bar/content-browser-control-bar.d.ts

@@ -61,6 +61,7 @@ export default class CxContentBrowserControlBar extends CortexElement {
     newlyChangedOption: ChangeOption | undefined;
     searchText: string;
     isMobile: boolean;
+    canUseTable: boolean;
     private handleSearchChange;
     render(): TemplateResult;
 }

package/build/components/content-browser-control-view/content-browser-control-view.d.ts

@@ -10,7 +10,7 @@ import CxSpace from '@orangelogic/design-system/components/space';
 import CxSwitch from '@orangelogic/design-system/components/switch';
 import CxTooltip from '@orangelogic/design-system/components/tooltip';
 import CortexElement from '../../base/element';
-import { ControlOption, GridView } from '../../types/content-browser';
+import { type ContentBrowserView, ControlOption } from '../../types/content-browser';
 import type { CSSResultGroup, TemplateResult } from 'lit';
 /**
  * @summary DAM view control toolbar for selecting asset view modes and toggling options.
@@ -41,14 +41,17 @@ export default class CxContentBrowserControlView extends CortexElement {
         'cx-tooltip': typeof CxTooltip;
     };
     private readonly localize;
-    view: GridView;
+    view: ContentBrowserView;
     views: ControlOption[];
     isSeeThrough: boolean;
     isMobile: boolean;
+    canUseTable: boolean;
     private selectedView;
+    private get isTable();
     runConnectedCallback(): void;
     private handleSeeThroughClick;
     private handleViewSelect;
+    private renderTableOption;
     handleViewChange(): void;
     render(): TemplateResult;
 }

package/build/components/content-browser-format-dialog/content-browser-format-dialog.d.ts

@@ -15,7 +15,7 @@ import CxTypography from '@orangelogic/design-system/components/typography';
 import CxContentBrowserAssetPreview from '../content-browser-asset-preview/content-browser-asset-preview';
 import CxContentBrowserAssetProxySelector from '../content-browser-asset-proxy-selector/content-browser-asset-proxy-selector';
 import CxContentBrowserAssetVersionHistory from '../content-browser-asset-version-history/content-browser-asset-version-history';
-import { type Parameter, type Transformation, type CtaTextTransform, ContentBrowserFormatDialogVariant } from '../../types/content-browser';
+import { type Parameter, type Transformation, type CtaTextTransform, type AutoSelectFormat, ContentBrowserFormatDialogVariant } from '../../types/content-browser';
 export default class CxContentBrowserFormatDialog extends CortexElement {
     static readonly styles: CSSResultGroup;
     static readonly dependencies: {
@@ -47,6 +47,12 @@ export default class CxContentBrowserFormatDialog extends CortexElement {
     canPinAsset: boolean;
     canTrack: boolean;
     canUseProxies: boolean;
+    /**
+     * Skip the format picker and insert directly — see `resolveAutoSelection` for what each value
+     * does. Off by default: this changes what a click does, so a host opts in rather than
+     * inheriting it.
+     */
+    autoSelectFormat: AutoSelectFormat;
     /**
      * Pick-only mode. Suppresses the custom-format editor entirely: cx-asset-link-format issues its
      * own transformasset request as soon as it is in the DOM, so hiding it with CSS is not enough.
@@ -97,7 +103,19 @@ export default class CxContentBrowserFormatDialog extends CortexElement {
      * One rule for the Insert button and handleProxyConfirm, so an enabled Insert always confirms (L-42BIA4).
      */
     private get canConfirm();
+    private filterProxies;
     handleSupportedExtensionsChange(): void;
+    /**
+     * What `autoSelectFormat` resolves to for this asset: the proxy to insert with, or `undefined`
+     * when the dialog should open as usual.
+     *
+     * `{ proxy: undefined }` is deliberate rather than a miss — with the picker switched off there is
+     * no format to name and the original file is the only outcome, which is `handleProxyConfirm`'s
+     * no-proxy branch. With the picker on a proxy must actually resolve: confirming none emits
+     * nothing and would turn the click into a silent no-op, so both an empty proxy list and a format
+     * name that matches nothing fall back to the dialog.
+     */
+    private resolveAutoSelection;
     open({ asset, isFavorite, isAssetPinned, proxies, proxiesFailed, }: {
         asset: Asset & {
             previewUrl: string;
@@ -108,6 +126,14 @@ export default class CxContentBrowserFormatDialog extends CortexElement {
         proxiesFailed?: boolean;
     }): void;
     hide(): void;
+    /**
+     * Show a dialog that `open()` skipped through the auto-confirm shortcut. The asset, proxies and
+     * resolved selection are still in place, so this lands the user on exactly the dialog the
+     * shortcut spared them, with its confirm button live again to retry.
+     */
+    revealAfterAutoConfirm(): void;
+    /** Whether the dialog is actually on screen — false when `open()` took the auto-confirm path. */
+    get isDialogOpen(): boolean;
     setVersionHistory(versions: AssetVersion[]): void;
     setIsFavorite(isFavorite: boolean): void;
     setIsAssetPinned(isAssetPinned: boolean): void;

package/build/components/content-browser-grid/content-browser-grid.d.ts

@@ -1,7 +1,7 @@
 import '@lit-labs/virtualizer';
 import CortexElement from '../../base/element';
 import { Asset } from '../../types/asset';
-import { GridView } from '../../types/content-browser';
+import { GridView, type CtaTextTransform } from '../../types/content-browser';
 import CxButton from '@orangelogic/design-system/components/button';
 import CxIcon from '@orangelogic/design-system/components/icon';
 import CxProgressBar from '@orangelogic/design-system/components/progress-bar';
@@ -34,6 +34,10 @@ export default class CxContentBrowserGrid extends CortexElement {
     showSize: boolean;
     showDimensions: boolean;
     showTags: boolean;
+    showCta: boolean;
+    ctaText: string;
+    ctaTextTransform: CtaTextTransform;
+    busyAssetId: string | undefined;
     selectedAssetId: string | undefined;
     assetMap: Map<string, Asset>;
     columnWidth: number;

package/build/components/content-browser-table/column-layout.d.ts

@@ -0,0 +1,29 @@
+/** The narrowest width a table column can have, in pixels. */
+export declare const MIN_COLUMN_WIDTH = 92;
+/**
+ * One column for the layout rules.
+ * `natural` is the width the column wants, in pixels.
+ * `saved` is the width the user set, in pixels. Leave it out for an auto-fit column.
+ */
+export type ColumnLayoutInput = {
+    natural: number;
+    saved?: number;
+};
+/**
+ * Measure the width of a text with a font, in whole pixels.
+ * @param text The text to measure.
+ * @param font A CSS font value, such as `'14px sans-serif'`.
+ * @returns The width of the text, rounded up. Returns 0 when no canvas context is available.
+ */
+export declare function measureTextWidth(text: string, font: string): number;
+/**
+ * Lay out the column widths inside the available width.
+ * Saved widths keep their size. Auto-fit columns that fit in a fair share keep their natural
+ * width. The other auto-fit columns share the space that is left. Spare space goes to the
+ * auto-fit columns in equal parts. No column is narrower than MIN_COLUMN_WIDTH, so the result can
+ * be wider than `available`.
+ * @param columns The columns, in display order.
+ * @param available The width of the host, in pixels.
+ * @returns One whole-pixel width for each column, in the same order.
+ */
+export declare function layoutColumnWidths(columns: ColumnLayoutInput[], available: number): number[];

package/build/components/content-browser-table/content-browser-table.d.ts

@@ -0,0 +1,302 @@
+import { type PropertyValues } from 'lit';
+import CortexElement from '../../base/element';
+import { Asset } from '../../types/asset';
+import { type CtaTextTransform, TableColumn, type TableRowActionPosition } from '../../types/content-browser';
+import CxButton from '@orangelogic/design-system/components/button';
+import CxIcon from '@orangelogic/design-system/components/icon';
+import CxLineClamp from '@orangelogic/design-system/components/line-clamp';
+import CxProgressBar from '@orangelogic/design-system/components/progress-bar';
+import CxResizeObserver from '@orangelogic/design-system/components/resize-observer';
+import CxContentBrowserNoResult from '../content-browser-no-result/content-browser-no-result';
+import { MIN_COLUMN_WIDTH } from './column-layout';
+import type { CSSResultGroup } from 'lit';
+/** `cx-table`'s own row height, the one every other Cortex table renders at. */
+export declare const ROW_HEIGHT = 48;
+/** Kept here too, so the old import path of the column floor stays valid. */
+export { MIN_COLUMN_WIDTH };
+/** An invisible column keeps Tabulator rows present when every data column is hidden. */
+export declare const FILLER_FIELD = "filler";
+/**
+ * Column values ride on the asset under the Cortex field name as requested (see `apiGetAssets`),
+ * which `Asset` cannot declare because the field set is the host's, not the SDK's. Read as an own
+ * property: a field named after an `Object.prototype` member (`toString`, `constructor`) would
+ * otherwise read back the inherited function.
+ */
+export declare function readCellValue(asset: Asset, field: string): string;
+/**
+ * @summary Table layout for the Content Browser: one row per asset, host-configured metadata columns
+ * instead of a thumbnail, rendered by the design system's `cx-table`.
+ *
+ * @description Renders the same asset list the grid does and emits the same item events, so an asset
+ * with no rendition — a text fragment, `digitized = 0` — is browsable and selectable by its
+ * identifying fields. It fetches nothing of its own: a row exists, and a cell has a value, only
+ * because the search response the grid also consumes carried it.
+ *
+ * @event cx-content-browser-grid-click - Emitted when a row's CTA button is activated, by a click or
+ * from the keyboard: once for a double click on it, and never for a click or a double click on the
+ * row itself.
+ * @event cx-content-browser-grid-resize - Emitted when the number of rows the visible scrollport can
+ * show changes, and again once a restarted list's rows are in, so the host can grow the page size.
+ * A count measured while a page of the shown list loads is emitted once the load ends and any
+ * rows it brings are in. A count measured after the load ends is emitted at once, and it can come
+ * before the rows of a new list are in.
+ * @event cx-content-browser-grid-retry - Emitted when the user clicks Retry after a search error.
+ * @event cx-content-browser-grid-scroll-end - Emitted while `has-more` is set, no page is loading, and
+ * the last row comes into view: by scrolling the table's own scrollport, or by scrolling the page when
+ * a table taller than the viewport holds its rows without overflowing and so never scrolls itself.
+ * @event cx-content-browser-table-column-resize - Emitted when a host-configured column settles on a
+ * new width: a drag of its divider released (`detail.reset` is `false`), or a double click on the
+ * divider that removes the saved width and auto-fits the column (`detail.reset` is `true`). The
+ * filler and the row action have no divider. `detail.width` is the column's width in whole pixels,
+ * and is never `undefined`. The SDK saves the width itself.
+ */
+export default class CxContentBrowserTable extends CortexElement {
+    #private;
+    static readonly styles: CSSResultGroup;
+    static readonly dependencies: {
+        'cx-button': typeof CxButton;
+        'cx-content-browser-no-result': typeof CxContentBrowserNoResult;
+        'cx-icon': typeof CxIcon;
+        'cx-line-clamp': typeof CxLineClamp;
+        'cx-progress-bar': typeof CxProgressBar;
+        'cx-resize-observer': typeof CxResizeObserver;
+        'cx-table': typeof import("node_modules/@orangelogic/design-system/library/packages/hybrid/table-core/src").default;
+    };
+    private readonly localize;
+    private readonly containerEl;
+    private readonly tableEl;
+    assets: Asset[];
+    columns: TableColumn[];
+    ctaText: string;
+    ctaTextTransform: CtaTextTransform;
+    empty: boolean;
+    /** The last search request got an error. With no rows, the error replaces the table. With rows, it shows at the bottom. */
+    error: boolean;
+    hasMore: boolean;
+    loading: boolean;
+    selectedAssetId: string | undefined;
+    /**
+     * The asset whose insert is still running, so its row keeps the CTA on screen and spinning.
+     */
+    busyAssetId: string | undefined;
+    /**
+     * Fields of `columns`, compared exactly, whose columns the table does not show. A hidden column
+     * keeps its place, its cell values and a dragged width, so it comes back with the rows and the
+     * scroll position unchanged. The filler and the row action remain when every host column is hidden.
+     */
+    hiddenFields: string[];
+    /**
+     * The widths that the user saved, in pixels, keyed by the trimmed `field`. A column with a saved
+     * width shows at that width. The other columns auto-fit to their content. A new map replaces the
+     * old one, the drags and resets in memory included.
+     */
+    savedWidths: Record<string, number>;
+    /**
+     * The owner of `savedWidths`, such as the Cortex site. A new value drops the widths that a drag
+     * held for the session. A new `savedWidths` for the same owner keeps them.
+     */
+    widthScope: string | undefined;
+    /**
+     * Where the row action shows: at the right edge of the host (`host-edge`), or at the end of the
+     * last data column (`row-end`).
+     */
+    rowActionPosition: TableRowActionPosition;
+    assetMap: Map<string, Asset>;
+    private get tabulator();
+    /**
+     * The current Tabulator instance, built or not. Tabulator shows its header and frame as it builds,
+     * but fires `tableBuilt` only after its data-load debounce.
+     */
+    private get buildingTabulator();
+    /** Tabulator's row holder: the one element that scrolls the rows. */
+    private get scrollport();
+    /** Each host column's row key, in order: a field the host repeats takes a key per occurrence. */
+    private resolveColumnKeys;
+    private buildColumnDefinitions;
+    /**
+     * A pixel width for each column, so the `fitData` layout never sizes it from its content. The
+     * auto-fit sets the real width once the columns are built (see `applyColumnLayout`). Until then a
+     * column keeps the width it had in the previous definitions.
+     */
+    private buildDataColumnDefinitions;
+    /**
+     * Tabulator replaces its rows with a placeholder when no columns remain visible. This invisible
+     * column keeps the rows and their actions available when the host hides every data column.
+     * Its small, fixed width gives the final resize handle a buffer without a visible empty column.
+     */
+    private buildFillerColumnDefinition;
+    private get ctaLabel();
+    /** The action overlays its row and takes no column width. */
+    private renderRowAction;
+    private isCtaShown;
+    /** In place, never rebuilt: a new button would drop the keyboard focus the old one held. */
+    private paintCta;
+    private paintRowCta;
+    private paintAssetCta;
+    private trackPointer;
+    private setHoveredRow;
+    /**
+     * Tabulator takes a row that scrolls out of its render window off the page, and a row taken off
+     * the page gets no `mouseleave` to hide its CTA, nor need its button get a `focusout` for the
+     * focus it drops.
+     */
+    private releaseDetachedCta;
+    /** Lays the columns and the rendered rows out again. */
+    private redrawTable;
+    /** The frame ends at the data columns. The scrollport remains available to the row actions. */
+    private syncTableFrame;
+    /**
+     * Tabulator renders the rows again -- for an appended page, a redraw of its own or one of ours --
+     * by taking every rendered row off the page and back, which drops the keyboard focus, so the CTA
+     * that held it gets it back.
+     */
+    private handleRenderStarted;
+    private handleRenderComplete;
+    private toRow;
+    private findRow;
+    /**
+     * `aria-current`, not `aria-selected`: this is a `grid` with no selection model of its own. The
+     * row is never selected in Tabulator, so an import does not paint `cx-table`'s selected-row highlight.
+     */
+    private markCurrentRow;
+    /**
+     * The fonts and the padding of a rendered header title and data cell. A table with no rendered
+     * cell measures the values in the header font, with the header padding.
+     */
+    private readColumnMetrics;
+    private getScrollbarWidth;
+    /** The widest of the title and the values of the loaded rows, plus the padding. */
+    private measureNaturalWidth;
+    /**
+     * Sets the width of each visible host column: a saved or session width as is, and an auto-fit
+     * width for the other columns, inside the width of the table (see `layoutColumnWidths`). A hidden
+     * column keeps its width. A table with no width, as one in a hidden panel, keeps its widths until
+     * it is shown.
+     * @param measure Measure the natural widths again. Leave it false to reuse the natural widths of
+     * the last full layout, for a change of the available width only.
+     */
+    private applyColumnLayout;
+    /**
+     * The canvas measures with a fallback font while a web font loads, so measure again once the fonts
+     * are ready. Guarded by one pending wait, and by the connection of the element.
+     */
+    private layoutAgainWhenFontsLoad;
+    private readonly debouncedApplyColumnLayout;
+    /**
+     * `content-browser` hands over the whole list on every page, so a list that only grows by a page
+     * is appended: reassigning it would call `setData`, which scrolls the table back to the top. Any
+     * other list -- a new search, sort, filter or folder, or a refetch that brings the assets the rows
+     * show as new objects -- replaces the rows.
+     */
+    private syncRows;
+    private handleTableBuilt;
+    /**
+     * Gives the frame, the scrollport and the header their styles. Runs as soon as Tabulator lays out its
+     * columns: until then the frame takes the width of its content, which is not the width of the header.
+     */
+    private prepareFrame;
+    /**
+     * `setData` replaces the rows only once its debounce runs out, and Tabulator emits `dataLoaded` just
+     * before it does. Until then, the old rows stay on the page with their hover and focus.
+     */
+    private handleDataLoaded;
+    /**
+     * Every `setColumns` builds the columns again from the definitions: Tabulator calls it as it builds,
+     * before `tableBuilt`. `cx-table` calls it again from its own `tableBuilt` handler, after this
+     * component's has run, and for every new column set.
+     */
+    private handleColumnsLoaded;
+    willUpdate(changedProperties: PropertyValues<this>): void;
+    /**
+     * The new saved widths replace all the widths in memory: a width that the new map does not hold,
+     * for example one of another site, goes away. Only a positive width counts: a bad entry has no effect.
+     */
+    private applySavedWidths;
+    /**
+     * Through Tabulator's own column visibility: new definitions would reach it through `setColumns`,
+     * and the rows would have to be rebuilt, which scrolls back to the top.
+     */
+    private applyHiddenFields;
+    updated(changedProperties: PropertyValues<this>): void;
+    /** Once `cx-table` has taken the new column definitions. */
+    private rebuildRows;
+    handleAssetsChange(previous?: unknown): void;
+    handleLoadingChange(): Promise<void>;
+    handleSelectedAssetIdChange(previous?: unknown): void;
+    handleBusyAssetIdChange(previous?: unknown): void;
+    handleCtaTextChange(): void;
+    private readonly handleNoHoverChange;
+    /** In place, as a relabel is: a CTA built again would drop the keyboard focus the old one held. */
+    private setNoHover;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private handleResize;
+    /**
+     * A new container width changes the space that the auto-fit shares out, so the columns are laid
+     * out again. `cx-table` renders its rows again for a new container height only until the first drag
+     * of a column divider, so a new height redraws the rows, which leaves no blank area under them.
+     */
+    private refitToContainer;
+    private readonly debouncedRedrawTable;
+    private readonly debouncedCalculatePageSize;
+    private calculatePageSize;
+    /** Counts the rows the last measured height shows, and tells the host when the count changes. */
+    private reportRowCount;
+    /**
+     * Only once the restarted rows are in: the host asks for the next page at once, and a page that
+     * lands while `setData` waits replaces the rows again and holds them back for another half second.
+     * A measurement still in its debounce reports in the same count, because a second count inside the
+     * host's 200 ms fetch debounce cancels the page the first count asked for.
+     */
+    private reportRestartedRowCount;
+    /**
+     * Once the load ends and any rows it brings are in, the count measured meanwhile can ask for the
+     * page after it. A table that is not built yet reports it at once.
+     */
+    private reportHeldRowCount;
+    /**
+     * The rows never size the container (see the styles), so this is the height the host gives the
+     * picker, and it can run past the viewport. No scrollport shows more rows than the viewport, so
+     * while the rows do not overflow the scrollport the count stops there, and the page scrolls to the
+     * rest, where the last row coming into view asks for more (`observeLastRow`). One that overflows,
+     * or holds no rows yet, measures the space its container gives it and is used as is.
+     */
+    private resolveVisibleHeight;
+    private isSizedByRows;
+    /**
+     * A scrollport that holds its rows without overflowing never scrolls, so its own scroll never
+     * reaches the end: the page scrolls instead. Once the table is taller than the viewport its count
+     * is capped and stops fetching, which leaves the last row coming into view as the only sign the
+     * user wants more.
+     */
+    private observeLastRow;
+    private readonly debouncedHandleLastRowVisible;
+    private handleLastRowVisible;
+    private insertAsset;
+    /** The host field of a row key, or `undefined` for the filler. */
+    private fieldOfKey;
+    private handleColumnResized;
+    /**
+     * Holds each other visible auto-fit column at its width when the drag ends, for the session. A drag
+     * on one column must not change the width of another column (L-42CA9K issue 2).
+     */
+    private holdOtherAutoFitWidths;
+    /**
+     * A double click on a column divider removes the saved width, and the column auto-fits again. The
+     * listener runs in the capture phase, before the listener of the divider, so the Tabulator fit to
+     * the content does not run.
+     */
+    private readonly handleResizeHandleDoubleClick;
+    private handleScrollVertical;
+    private readonly debouncedHandleScrollEnd;
+    private handleScrollEnd;
+    private handleRetry;
+    private renderRetry;
+    private renderContent;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-content-browser-table': CxContentBrowserTable;
+    }
+}