@theseam/ui-common 0.4.30 → 1.0.0-beta.0

package/datatable-alterations-display/index.d.ts

@@ -0,0 +1,101 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
+import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
+import { TheSeamLayoutService } from '@theseam/ui-common/layout';
+
+interface AlterationDisplayItem {
+    id: string;
+    type: string;
+    summary: string;
+    details?: string[];
+    sortOrder?: number;
+    diffState?: AlterationVisualState;
+}
+interface AlterationDiffState {
+    added: AlterationDisplayItem[];
+    removed: AlterationDisplayItem[];
+    changed: AlterationDisplayItem[];
+    unchanged: AlterationDisplayItem[];
+}
+type AlterationDiffMode = 'auto' | 'manual';
+type AlterationVisualState = 'added' | 'removed' | 'changed' | 'unchanged';
+
+declare class AlterationDisplayService {
+    /**
+     * Calculate the differences between current and pending alterations
+     */
+    calculateDiff(current: AlterationDisplayItem[], pending: AlterationDisplayItem[]): AlterationDiffState;
+    /**
+     * Group and sort alteration items by type and sort order
+     */
+    groupAndSortItems(items: AlterationDisplayItem[]): AlterationDisplayItem[];
+    /**
+     * Get a user-friendly type display name
+     */
+    getTypeDisplayName(type: string): string;
+    /**
+     * Get an icon name for the alteration type (FontAwesome icon names)
+     */
+    getTypeIconName(type: string): string;
+    private _areItemsEqual;
+    private _areArraysEqual;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlterationDisplayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlterationDisplayService>;
+}
+
+declare class AlterationItemComponent {
+    private alterationDisplayService;
+    item: AlterationDisplayItem;
+    compact: boolean;
+    private readonly typeIcons;
+    constructor(alterationDisplayService: AlterationDisplayService);
+    get typeDisplayName(): string;
+    get typeIcon(): _fortawesome_fontawesome_common_types.IconDefinition;
+    get borderClass(): string;
+    get badgeClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlterationItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlterationItemComponent, "seam-alteration-item", never, { "item": { "alias": "item"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AlterationsListComponent {
+    private alterationDisplayService;
+    items: AlterationDisplayItem[];
+    title?: string;
+    diffState?: 'current' | 'pending';
+    groupByType: boolean;
+    sortWithinType: boolean;
+    compact: boolean;
+    constructor(alterationDisplayService: AlterationDisplayService);
+    get sortedItems(): AlterationDisplayItem[];
+    get hasItems(): boolean;
+    trackByItemId(index: number, item: AlterationDisplayItem): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlterationsListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlterationsListComponent, "seam-alterations-list", never, { "items": { "alias": "items"; "required": false; }; "title": { "alias": "title"; "required": false; }; "diffState": { "alias": "diffState"; "required": false; }; "groupByType": { "alias": "groupByType"; "required": false; }; "sortWithinType": { "alias": "sortWithinType"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AlterationsDiffComponent implements OnInit, OnDestroy {
+    private layoutService;
+    private alterationDisplayService;
+    currentItems: AlterationDisplayItem[];
+    pendingItems: AlterationDisplayItem[];
+    diffMode: AlterationDiffMode;
+    initialDiffState?: AlterationDiffState;
+    compact: boolean;
+    isMobile: boolean;
+    diffState: AlterationDiffState | null;
+    private destroy$;
+    constructor(layoutService: TheSeamLayoutService, alterationDisplayService: AlterationDisplayService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get currentItemsWithDiffState(): AlterationDisplayItem[];
+    get pendingItemsWithDiffState(): AlterationDisplayItem[];
+    get hasDifferences(): boolean;
+    get differenceSummary(): string;
+    private calculateDiffState;
+    private getItemDiffState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlterationsDiffComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlterationsDiffComponent, "seam-alterations-diff", never, { "currentItems": { "alias": "currentItems"; "required": false; }; "pendingItems": { "alias": "pendingItems"; "required": false; }; "diffMode": { "alias": "diffMode"; "required": false; }; "initialDiffState": { "alias": "initialDiffState"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { AlterationDisplayService, AlterationItemComponent, AlterationsDiffComponent, AlterationsListComponent };
+export type { AlterationDiffMode, AlterationDiffState, AlterationDisplayItem, AlterationVisualState };

package/datatable-dynamic/index.d.ts

@@ -1,5 +1,548 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/datatable-dynamic" />
-export * from './public-api';
+import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
+import { Observable } from 'rxjs';
+import { DynamicValue, DynamicValueBaseType, DynamicActionDef, DynamicActionContext, DynamicValueHelperService, DynamicActionHelperService } from '@theseam/ui-common/dynamic';
+import * as i7 from '@theseam/ui-common/datatable';
+import { TheSeamDatatableRow, TheSeamDatatableColumn } from '@theseam/ui-common/datatable';
+import { ThemeTypes, ComponentType as ComponentType$1 } from '@theseam/ui-common/models';
+import { TableCellTypeName, TableCellTypeConfig, TheSeamTableColumn } from '@theseam/ui-common/table-cell-type';
+import * as i12 from '@angular/cdk/portal';
+import { ComponentType, ComponentPortal } from '@angular/cdk/portal';
+import * as i9 from '@theseam/ui-common/data-exporter';
+import { IDataExporter } from '@theseam/ui-common/data-exporter';
+import * as i10 from '@theseam/ui-common/data-filters';
+import { IDataFilter } from '@theseam/ui-common/data-filters';
+import * as i0 from '@angular/core';
+import { OnInit, Injector, InjectionToken, Renderer2, ElementRef, OnDestroy, OnChanges, SimpleChanges } from '@angular/core';
+import { TheSeamDynamicComponentLoader } from '@theseam/ui-common/dynamic-component-loader';
+import * as i5 from '@angular/common';
+import { LocationStrategy } from '@angular/common';
+import * as i13 from '@angular/router';
+import { Router, ActivatedRoute, RouterLink, RouterLinkWithHref, QueryParamsHandling } from '@angular/router';
+import { AssetReaderHelperService } from '@theseam/ui-common/asset-reader';
+import * as i6 from '@theseam/ui-common/shared';
+import * as i8 from '@theseam/ui-common/table-cell-types';
+import * as i11 from '@theseam/ui-common/icon';
+import * as i14 from '@theseam/ui-common/menu';
+import * as i15 from '@theseam/ui-common/buttons';
+
+interface DynamicDatatableMenuBarItem<C extends DynamicValueBaseType = any> {
+    /**
+     * Styles added to the root cell elements `style` attribute.
+     */
+    /**
+     * Classes added to the root cell elements `class` attribute.
+     */
+    component: DynamicValue<string>;
+    data?: DynamicValue<C>;
+}
+interface DynamicDatatableMenuBarColumn {
+    /**
+     * Styles added to the root cell elements `style` attribute.
+     */
+    styles?: DynamicValue<string | string[]>;
+    /**
+     * Classes added to the root cell elements `class` attribute.
+     */
+    cssClass?: DynamicValue<string | string[]>;
+    items: DynamicDatatableMenuBarItem[];
+}
+interface DynamicDatatableMenuBarRowLayout<T extends string> {
+    type: T;
+}
+/**
+ * Tri column tries layout the content with the center column aligned with the
+ * center of the menu bar, only considering the left and right columns content
+ * when width would cause them to overlap.
+ *
+ * If the center column is undefined, then the left column should fill the
+ * remaining space to the left of the right column.
+ */
+interface DynamicDatatableMenuBarRowLayoutTriColumn extends DynamicDatatableMenuBarRowLayout<'tri-column'> {
+    columnLeft?: DynamicDatatableMenuBarColumn;
+    columnCenter?: DynamicDatatableMenuBarColumn;
+    columnRight?: DynamicDatatableMenuBarColumn;
+}
+interface DynamicDatatableMenuBarRow {
+    /**
+     * Styles added to the root cell elements `style` attribute.
+     */
+    styles?: DynamicValue<string | string[]>;
+    /**
+     * Classes added to the root cell elements `class` attribute.
+     */
+    cssClass?: DynamicValue<string | string[]>;
+    /**
+     * In a situation where the datatable has to many rows and needs to start
+     * removing rows, or moving them to an overflow drawer, the priority will be
+     * used to decide which rows stay.
+     *
+     * When choosing rows the highest priority will be chosen first. If a value is
+     * not provided, then the priority will be considered lowest. Rows that have
+     * the same priority will be ordered from lowest to highest array index
+     * position.
+     */
+    priority?: DynamicValue<number>;
+    layout: DynamicDatatableMenuBarRowLayoutTriColumn;
+}
+interface DynamicDatatableMenuBar {
+    rows: DynamicDatatableMenuBarRow[];
+}
+
+interface DynamicDatatableRowAction {
+    /**
+     * Label displayed on the menu item.
+     */
+    label: DynamicValue<string>;
+    /** */
+    action: DynamicActionDef<string>;
+    /**
+     * Default: false
+     */
+    disabled?: DynamicValue<boolean>;
+    /**
+     * Expression executed each row to decide if the action will be visible.
+     */
+    hidden?: DynamicValue<boolean>;
+}
+
+type DynamicDatatableColumn<T extends TableCellTypeName = any, C extends TableCellTypeConfig<T> = any> = TheSeamDatatableColumn<T, C> | TheSeamTableColumn<T, C>;
+type DynamicDatatableRow = TheSeamDatatableRow;
+interface DynamicDatatableFilterMenuItemDef<O = any> {
+    /** */
+    name: string;
+    /**
+     * TODO: Refactor filter menu items to use locations instead of trying to
+     * maintain a mix of generic and specific types.
+     *
+     * Default: 'common'
+     */
+    type: 'common' | 'full-search';
+    /**
+     * Default: 0
+     */
+    order?: number;
+    /** */
+    options?: O;
+}
+interface DynamicDatatableFilterMenu {
+    /**
+     * Default 'default'
+     */
+    state?: 'hidden' | 'always-visible' | 'default';
+    /**
+     *
+     */
+    filters?: DynamicDatatableFilterMenuItemDef[];
+    /**
+     *
+     * Example: [ 'exporter:csv', 'exporter:xlsx' ]
+     */
+    exporters?: string[];
+}
+type DynamicDatatableFooterMenuItemType = 'button' | 'text';
+interface DynamicDatatableFooterMenuItem<T = DynamicDatatableFooterMenuItemType> {
+    type: T;
+}
+interface DynamicDatatableFooterMenuItemButton extends DynamicDatatableFooterMenuItem<'button'> {
+    text: string;
+    theme: ThemeTypes;
+}
+interface DynamicDatatableFooterMenuItemText extends DynamicDatatableFooterMenuItem<'text'> {
+    text: string;
+}
+interface DynamicDatatableOptions {
+    /**
+     * Default: false
+     */
+    virtualization?: boolean;
+}
+interface DynamicDatatableFooterMenu {
+    /**
+     * Default 'default'
+     */
+    state?: 'hidden' | 'always-visible' | 'default';
+    items?: DynamicDatatableFooterMenuItem[];
+}
+interface DatatableDynamicDef {
+    readonly menuBar?: DynamicDatatableMenuBar;
+    readonly filterMenu?: DynamicDatatableFilterMenu;
+    readonly columns: DynamicDatatableColumn<TableCellTypeName, TableCellTypeConfig<TableCellTypeName>>[];
+    readonly rows: DynamicDatatableRow[];
+    readonly rowActions?: DynamicDatatableRowAction[];
+    readonly options?: DynamicDatatableOptions;
+}
+
+type DynamicDatatableActionMenuElementTypes = 'a' | 'button';
+interface DynamicDatatableActionMenuRecord {
+    /** Row input. */
+    _row: DynamicDatatableRow;
+    /** Def input. */
+    _def: DynamicDatatableRowAction;
+    /**
+     * Row action.
+     */
+    rowAction: DynamicDatatableRowAction;
+    /**
+     * Expected html element type to be used.
+     */
+    elementType: DynamicDatatableActionMenuElementTypes;
+}
+
+interface DynamicDatatableFilterMenuItem extends DynamicDatatableFilterMenuItemDef {
+    /** Filter menu item component. */
+    component: ComponentType<IDataFilter> | undefined;
+}
+
+interface DynamicDatatableRowActionContext extends DynamicActionContext {
+    row: DynamicDatatableRow;
+}
+
+/**
+ * Manages the data defined in the `DatatableDynamicDef`. Simplifies accessing
+ * and observing the needed data based on the `DatatableDynamicDef`.
+ */
+declare class DynamicDatatableDefService {
+    private _valueHelper;
+    /**
+     * @deprecated
+     * @ignore
+     */
+    private _dataExporters;
+    /**
+     * @deprecated
+     * @ignore
+     */
+    private _dataFilters;
+    /** @ignore */
+    private readonly _defSubject;
+    /** Dynamic datatable definition. */
+    readonly def$: Observable<DatatableDynamicDef | undefined>;
+    /**
+     * Exporters in the def that are available.
+     * @deprecated
+     */
+    readonly exporters$: Observable<IDataExporter[]>;
+    /**
+     * Filter menu items in the def that are available.
+     * @deprecated
+     */
+    readonly filterMenuItems$: Observable<DynamicDatatableFilterMenuItem[]>;
+    /**
+     * Observes whether the datatable has a filter menu.
+     * @deprecated
+     */
+    readonly hasFilterMenu$: Observable<boolean>;
+    /** Observes datatable options. */
+    readonly options$: Observable<DynamicDatatableOptions | undefined>;
+    /** Observes the datatable def menu bar. */
+    readonly menuBar$: Observable<DynamicDatatableMenuBar | undefined>;
+    constructor(dataExporters: IDataExporter[], dataFilters: {
+        name: string;
+        component: ComponentType<IDataFilter>;
+    }[], _valueHelper: DynamicValueHelperService);
+    /** Sets the `DatatableDynamicDef` that defines the datatable.  */
+    setDef(def: DatatableDynamicDef | undefined): void;
+    /** Map the def exporters to the provided `IDataExporter` objects. */
+    private _mapExporters;
+    /** Map the def filter menu items to provided components. */
+    private _mapFilterMenuItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicDatatableDefService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicDatatableDefService>;
+}
+
+declare class DynamicDatatableRowActionsService {
+    private _valueHelper;
+    private _dynamicDef;
+    constructor(_valueHelper: DynamicValueHelperService, _dynamicDef: DynamicDatatableDefService);
+    /**
+     * Observe actions for specified row
+     */
+    rowActions(row: DynamicDatatableRow): Observable<DynamicDatatableRowAction[]>;
+    /** @ignore */
+    private _getRowActionContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicDatatableRowActionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicDatatableRowActionsService>;
+}
+
+declare class DatatableDynamicActionMenuComponent {
+    private _valueHelper;
+    private _dynamicRowActions;
+    faEllipsisH: _fortawesome_fontawesome_common_types.IconDefinition;
+    get row(): DynamicDatatableRow | undefined;
+    set row(value: DynamicDatatableRow | undefined);
+    private _row;
+    get actionDefs(): DynamicDatatableRowAction[];
+    set actionDefs(value: DynamicDatatableRowAction[]);
+    private _actionDefs;
+    _menuRecords$: Observable<DynamicDatatableActionMenuRecord[]>;
+    /** @ignore */
+    _actionMenuPositions: {
+        originX: string;
+        originY: string;
+        overlayX: string;
+        overlayY: string;
+    }[];
+    constructor(_valueHelper: DynamicValueHelperService, _dynamicRowActions: DynamicDatatableRowActionsService);
+    private _mapRecords;
+    /** @ignore */
+    private _getRowActionContext;
+    private _expectedElementType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableDynamicActionMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableDynamicActionMenuComponent, "seam-datatable-dynamic-action-menu", never, { "row": { "alias": "row"; "required": false; }; "actionDefs": { "alias": "actionDefs"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DatatableDynamicFilterContainerComponent<C> implements OnInit {
+    private _injector;
+    set filterComponent(value: ComponentType$1<C> | undefined | null);
+    get filterComponent(): ComponentType$1<C> | undefined | null;
+    private _filterComponent;
+    options: any;
+    _portal: ComponentPortal<C> | null;
+    constructor(_injector: Injector);
+    ngOnInit(): void;
+    private _setPortal;
+    private _createInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableDynamicFilterContainerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableDynamicFilterContainerComponent<any>, "seam-datatable-dynamic-filter-container", never, { "filterComponent": { "alias": "filterComponent"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface IDatatableDynamicMenuBarItemManifest<T = any> {
+    /**
+     * Unique name to represent this item in JSON def.
+     */
+    name: string;
+    /**
+     * Component to render for this item.
+     */
+    component: ComponentType<object> | string;
+    /**
+     * InjectionToken to inject data as.
+     */
+    dataToken?: InjectionToken<T>;
+}
+
+interface IDatatableDynamicMenuBarContentItem {
+    portal?: ComponentPortal<object>;
+}
+interface IDatatableDynamicMenuBarContentColumn {
+    styles?: string | string[];
+    cssClass?: string | string[];
+    items?: IDatatableDynamicMenuBarContentItem[];
+}
+interface IDatatableDynamicMenuBarContentRowLayoutTriColumn {
+    columnLeft?: IDatatableDynamicMenuBarContentColumn;
+    columnCenter?: IDatatableDynamicMenuBarContentColumn;
+    columnRight?: IDatatableDynamicMenuBarContentColumn;
+}
+interface IDatatableDynamicMenuBarContentRow {
+    styles?: string | string[];
+    cssClass?: string | string[];
+    priority?: number;
+    layoutType?: string;
+    layout?: IDatatableDynamicMenuBarContentRowLayoutTriColumn;
+}
+interface IDatatableDynamicMenuBarContentRowContext {
+    row: DynamicDatatableMenuBarRow;
+}
+interface IDatatableDynamicMenuBarContentColumnContext {
+    column: DynamicDatatableMenuBarColumn;
+    row: DynamicDatatableMenuBarRow;
+}
+interface IDatatableDynamicMenuBarContentItemContext {
+    item: DynamicDatatableMenuBarItem;
+    row: DynamicDatatableMenuBarRow;
+    column: DynamicDatatableMenuBarColumn;
+}
+declare class DatatableDynamicMenuBarContentComponent {
+    private readonly _valueHelper;
+    private readonly _dynamicComponentLoader;
+    private readonly _injector;
+    private readonly _menuBarItemManifests?;
+    private readonly _def;
+    set def(value: DynamicDatatableMenuBar | undefined);
+    get def(): DynamicDatatableMenuBar | undefined;
+    readonly def$: Observable<DynamicDatatableMenuBar | undefined>;
+    readonly _rows$: Observable<IDatatableDynamicMenuBarContentRow[]>;
+    constructor(_valueHelper: DynamicValueHelperService, _dynamicComponentLoader: TheSeamDynamicComponentLoader, _injector: Injector, _menuBarItemManifests?: IDatatableDynamicMenuBarItemManifest[] | undefined);
+    private _mapRows;
+    private _mapRow;
+    private _mapRowLayout;
+    private _mapColumn;
+    private _mapItem;
+    private _createRowContext;
+    private _createColumnContext;
+    private _createItemContext;
+    private _getComponentPortal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableDynamicMenuBarContentComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableDynamicMenuBarContentComponent, "seam-datatable-dynamic-menu-bar-content", never, { "def": { "alias": "def"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * Class to act as a substitute to `routerLink` directive until the menu items
+ * can be dynamically built in a clean way with or without `routerLink`.
+ */
+declare class DatatableDynamicActionMenuItemRouterLink {
+    private router;
+    private route;
+    private renderer;
+    private el;
+    private locationStrategy;
+    private _rLink?;
+    private _rLinkWithHref?;
+    private _rLinkClickEventListener?;
+    constructor(router: Router, route: ActivatedRoute, tabIndex: string | null, renderer: Renderer2, el: ElementRef, locationStrategy: LocationStrategy);
+    get routerLink(): RouterLink | undefined;
+    get routerLinkWithHref(): RouterLinkWithHref | undefined;
+    set routerLinkInput(commands: any[] | string);
+    set queryParams(value: {
+        [k: string]: any;
+    });
+    set fragment(value: string);
+    set queryParamsHandling(value: QueryParamsHandling);
+    set preserveFragment(value: boolean);
+    set skipLocationChange(value: boolean);
+    set replaceUrl(value: boolean);
+    set state(value: {
+        [k: string]: any;
+    });
+    set target(value: string | undefined);
+    destroy(): void;
+}
+declare class DatatableDynamicActionMenuItemDirective implements OnDestroy, OnChanges {
+    private _elementRef;
+    private _renderer;
+    private _valueHelper;
+    private _actionHelper;
+    private _assetReaderHelper;
+    private _router;
+    private _route;
+    private _locationStrategy;
+    set seamDatatableDynamicActionMenuItem(value: DynamicDatatableActionMenuRecord);
+    private _record;
+    private _clickSubscription?;
+    private _menuRouterLink?;
+    private _recordSubscription;
+    constructor(_elementRef: ElementRef<HTMLElement>, _renderer: Renderer2, _valueHelper: DynamicValueHelperService, _actionHelper: DynamicActionHelperService, _assetReaderHelper: AssetReaderHelperService, _router: Router, _route: ActivatedRoute, _locationStrategy: LocationStrategy);
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    _update(record: DynamicDatatableActionMenuRecord): Observable<void>;
+    private _updateAnchorElement;
+    private _updateButtonElement;
+    private _updateAssetElement;
+    private _updateClickElement;
+    private _unsubClick;
+    private _setAttr;
+    private _tryInitTabIndex;
+    private _tryInitBlockClick;
+    private _blockClickExprObservable;
+    private _initMenuItemRouterLink;
+    private _isAnchor;
+    private _getUiProps;
+    /** @ignore */
+    private _getContext;
+    private _setInvalidActionState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableDynamicActionMenuItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableDynamicActionMenuItemDirective, "[seamDatatableDynamicActionMenuItem]", ["seamDatatableDynamicActionMenuItem"], { "seamDatatableDynamicActionMenuItem": { "alias": "seamDatatableDynamicActionMenuItem"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function setDynamicDatatableColumnsDefaults(columns: DynamicDatatableColumn[]): void;
+
+declare function setDynamicDatatableFilterMenuDefaults(filterMenu: DynamicDatatableFilterMenu): void;
+
+declare function setDynamicDatatableOptionsDefaults(options: DynamicDatatableOptions): void;
+
+declare function setDynamicDatatableDefDefaults(def: DatatableDynamicDef): void;
+
+declare const THESEAM_DATATABLE_DYNAMIC_MENUBAR_ITEM: InjectionToken<IDatatableDynamicMenuBarItemManifest<any>>;
+
+/**
+ * # EXPERIMENTAL
+ *
+ * NOTE: This component is still experimental. When stable all standard
+ * datatables must use this component, unless there is a good reason not to, in
+ * our apps.
+ *
+ * ----------------------------------------------------------------------------
+ *
+ * Datatable that is built from a json definition.
+ *
+ * All standard datatables in our apps must use this component, unless there is
+ * a good reason not to. If a standard datatable does not use this component
+ * then an explaination comment needs to be clearly provided in the code to
+ * avoid getting migrated to this component.
+ *
+ * A few reasons this component should to be used:
+ * - We can, more easily, control what a datatable in our app does by requiring
+ *   the definition follow a json schema, instead of having full scripting
+ *   access available to the developer.
+ *   + By using json we can maintain the tables from any external app/language
+ *     that can produce a json string.
+ *   + More scripting access often leads to different hacks across the tables
+ *     that should have just been supported by this component if it is a feature
+ *     a datatable should be able to do in an app of ours.
+ * - We can allow any of our tables to be configured by the server.
+ *   + By supporting configuration on the server we can change the tables
+ *     without a new build and do things like allowing non-developers/clients to
+ *     maintain the tables functionality.
+ */
+declare class DatatableDynamicComponent {
+    private readonly _dynamicDef;
+    /** The `DatatableDynamicDef` that defines the datatable. */
+    set def(value: DatatableDynamicDef | undefined | null);
+    /**
+     * Observes whether the datatable has a def.
+     * @ignore
+     */
+    _hasDef$: Observable<boolean>;
+    /**
+     * Observes whether the datatable has a menu bar.
+     */
+    menuBar$: Observable<DynamicDatatableMenuBar | undefined>;
+    /**
+     * The available exporters.
+     * @ignore
+     */
+    _exporters$: Observable<IDataExporter[]>;
+    /**
+     * The 'common' type filter menu items.
+     * @ignore
+     */
+    _commonFilterMenuItems$: Observable<DynamicDatatableFilterMenuItem[]>;
+    /**
+     * Observes whether the datatable has a 'full-search' menu item.
+     * @ignore
+     */
+    _hasFullSearch$: Observable<boolean>;
+    /**
+     * Observes whether the datatable has a filter menu.
+     * @ignore
+     */
+    _hasFilterMenu$: Observable<boolean>;
+    /**
+     * Observes datatable options.
+     * @ignore
+     */
+    _options$: Observable<DynamicDatatableOptions | undefined>;
+    /**
+     * TODO: Implement def columns parser.
+     * @ignore
+     */
+    _tmp_columns$: Observable<any>;
+    /**
+     * TODO: Implement def rows parser.
+     * @ignore
+     */
+    _tmp_rows$: Observable<any>;
+    constructor(_dynamicDef: DynamicDatatableDefService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableDynamicComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableDynamicComponent, "seam-datatable-dynamic", never, { "def": { "alias": "def"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TheSeamDatatableDynamicModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDatatableDynamicModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamDatatableDynamicModule, [typeof DatatableDynamicComponent, typeof DatatableDynamicFilterContainerComponent, typeof DatatableDynamicActionMenuComponent, typeof DatatableDynamicMenuBarContentComponent], [typeof i5.CommonModule, typeof i6.TheSeamSharedModule, typeof i7.TheSeamDatatableModule, typeof i8.TheSeamTableCellTypesModule, typeof i9.TheSeamDataExporterModule, typeof i10.TheSeamDataFiltersModule, typeof i11.TheSeamIconModule, typeof i12.PortalModule, typeof i13.RouterModule, typeof i14.TheSeamMenuModule, typeof i15.TheSeamButtonsModule, typeof DatatableDynamicActionMenuItemDirective], [typeof DatatableDynamicComponent, typeof i7.TheSeamDatatableModule, typeof DatatableDynamicActionMenuItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamDatatableDynamicModule>;
+}
+
+export { DatatableDynamicActionMenuComponent, DatatableDynamicActionMenuItemDirective, DatatableDynamicActionMenuItemRouterLink, DatatableDynamicComponent, DatatableDynamicFilterContainerComponent, DatatableDynamicMenuBarContentComponent, DynamicDatatableDefService, DynamicDatatableRowActionsService, THESEAM_DATATABLE_DYNAMIC_MENUBAR_ITEM, TheSeamDatatableDynamicModule, setDynamicDatatableColumnsDefaults, setDynamicDatatableDefDefaults, setDynamicDatatableFilterMenuDefaults, setDynamicDatatableOptionsDefaults };
+export type { DatatableDynamicDef, DynamicDatatableActionMenuElementTypes, DynamicDatatableActionMenuRecord, DynamicDatatableColumn, DynamicDatatableFilterMenu, DynamicDatatableFilterMenuItem, DynamicDatatableFilterMenuItemDef, DynamicDatatableFooterMenu, DynamicDatatableFooterMenuItem, DynamicDatatableFooterMenuItemButton, DynamicDatatableFooterMenuItemText, DynamicDatatableFooterMenuItemType, DynamicDatatableMenuBar, DynamicDatatableMenuBarColumn, DynamicDatatableMenuBarItem, DynamicDatatableMenuBarRow, DynamicDatatableMenuBarRowLayout, DynamicDatatableMenuBarRowLayoutTriColumn, DynamicDatatableOptions, DynamicDatatableRow, DynamicDatatableRowAction, DynamicDatatableRowActionContext, IDatatableDynamicMenuBarContentColumn, IDatatableDynamicMenuBarContentColumnContext, IDatatableDynamicMenuBarContentItem, IDatatableDynamicMenuBarContentItemContext, IDatatableDynamicMenuBarContentRow, IDatatableDynamicMenuBarContentRowContext, IDatatableDynamicMenuBarContentRowLayoutTriColumn, IDatatableDynamicMenuBarItemManifest };