@memberjunction/ng-entity-viewer 5.39.0 → 5.40.1

package/dist/lib/entity-viewer/entity-viewer.component.d.ts

@@ -1,14 +1,76 @@
-import { EventEmitter, OnInit, OnDestroy, ChangeDetectorRef, NgZone } from '@angular/core';
+import { EventEmitter, OnInit, OnDestroy, AfterViewInit, ChangeDetectorRef, ElementRef, NgZone } from '@angular/core';
 import { BaseAngularComponent } from '@memberjunction/ng-base-types';
-import { EntityInfo, EntityFieldInfo, RunViewParams } from '@memberjunction/core';
+import { EntityInfo } from '@memberjunction/core';
 import { MJUserViewEntityExtended } from '@memberjunction/core-entities';
 import { PageChangeEvent } from '@memberjunction/ng-pagination';
-import { TimelineGroup, TimeSegmentGrouping, TimelineSortOrder, AfterEventClickArgs } from '@memberjunction/ng-timeline';
-import { MapDisplayState, MapRenderMode } from '@memberjunction/ng-map-view';
-import { EntityViewMode, EntityViewerConfig, RecordSelectedEvent, RecordOpenedEvent, DataLoadedEvent, FilteredCountChangedEvent, CardTemplate, GridColumnDef, SortState, SortChangedEvent, PaginationState, ViewGridState, GridStateChangedEvent, TimelineOrientation, TimelineState } from '../types';
-import { AfterRowClickEventArgs, AfterRowDoubleClickEventArgs, AfterSortEventArgs } from '../entity-data-grid/events/grid-events';
-import { GridToolbarConfig, GridSelectionMode, ForeignKeyClickEvent } from '../entity-data-grid/models/grid-types';
+import { EntityViewerConfig, RecordSelectedEvent, RecordOpenedEvent, DataLoadedEvent, FilteredCountChangedEvent, SortState, PaginationState, ViewGridState } from '../types';
+import { IViewTypeDescriptor, ViewRelatedRecordNavigation } from '../view-types';
 import * as i0 from "@angular/core";
+/**
+ * A single entry in the view-type switcher, built from the {@link ViewTypeEngine} registry
+ * (`MJ: View Types`). Every view type is a dynamic-mounted plug-in implementing `IViewRenderer`;
+ * the container has zero knowledge of any specific view type — it mounts the descriptor's
+ * `RendererComponent` and feeds it the generic contract.
+ */
+export interface ViewModeOption {
+    /**
+     * Stable key for this option — the descriptor's `Name` (== `MJ: View Types.DriverClass`),
+     * e.g. "GridViewType", "ClusterViewType". Used as the `@for` track key and to identify the
+     * active option.
+     */
+    key: string;
+    /**
+     * Always `null` — retained on the interface only so any external reader doesn't break. Every
+     * view type is now dynamic-mounted; there is no legacy built-in render mode.
+     */
+    mode: null;
+    /** User-facing label. */
+    label: string;
+    /** Font Awesome icon class. */
+    icon: string;
+    /** Always `true` — every view type is dynamic-mounted via the descriptor's RendererComponent. */
+    isDynamic: boolean;
+    /** The resolved descriptor (carries the RendererComponent + PropSheetComponent). */
+    descriptor: IViewTypeDescriptor;
+    /** The `MJ: View Types` row ID — for ViewTypeID persistence + per-view-type config keying. */
+    viewTypeId: string;
+}
+/**
+ * Event payload for the view-type change lifecycle. Emitted (cancelable) via
+ * {@link EntityViewerComponent.BeforeViewTypeChange} and (notification) via
+ * {@link EntityViewerComponent.AfterViewTypeChange}. A handler may set `Cancel = true` on the
+ * *Before* event to veto the switch (mirrors the grid's `BeforeRowClick` / `BeforeCellEdit`
+ * cancelable pattern).
+ */
+export interface ViewTypeChangeEventArgs {
+    /** The `MJ: View Types` row ID being switched to. */
+    ViewTypeID: string;
+    /** The descriptor `DriverClass` / Name being switched to (e.g. "ClusterViewType"). */
+    DriverClass: string;
+    /** The `MJ: View Types` row ID being switched FROM (null on the first selection). */
+    PreviousViewTypeID: string | null;
+    /** Set to true in a {@link EntityViewerComponent.BeforeViewTypeChange} handler to veto the switch. */
+    Cancel: boolean;
+}
+/**
+ * Event payload for the per-view-type configuration change lifecycle.
+ */
+export interface ViewTypeConfigChangeEventArgs {
+    /** The `MJ: View Types` row ID whose config changed. */
+    ViewTypeID: string;
+    /** The new configuration payload (shape owned by the plug-in). */
+    Config: Record<string, unknown>;
+    /** Set to true in a {@link EntityViewerComponent.BeforeViewTypeConfigChange} handler to veto. */
+    Cancel: boolean;
+}
+/**
+ * Where the entity viewer persists view-type/render-state when {@link EntityViewerComponent.AutoSaveView}
+ * is enabled:
+ * - `'record'` — onto the loaded `UserView` row (shared; everyone who opens that view sees it).
+ * - `'user-settings'` — per-user via `UserInfoEngine` (the default-view case, or a personal layer).
+ * - `'none'` — nothing to persist to (no view + settings disabled).
+ */
+export type ViewPersistenceTarget = 'record' | 'user-settings' | 'none';
 /**
  * EntityViewerComponent - Full-featured composite component for viewing entity data
  *
@@ -25,128 +87,108 @@ import * as i0 from "@angular/core";
  * ```html
  * <!-- Basic usage - loads data automatically -->
  * <mj-entity-viewer
- *   [entity]="selectedEntity"
- *   (recordSelected)="onRecordSelected($event)"
- *   (recordOpened)="onRecordOpened($event)">
+ *   [Entity]="selectedEntity"
+ *   (RecordSelected)="onRecordSelected($event)"
+ *   (RecordOpened)="onRecordOpened($event)">
  * </mj-entity-viewer>
  *
  * <!-- With external state control (like Data Explorer) -->
  * <mj-entity-viewer
- *   [entity]="selectedEntity"
- *   [(viewMode)]="state.viewMode"
- *   [filterText]="state.filterText"
- *   [selectedRecordId]="state.selectedRecordId"
- *   (recordSelected)="onRecordSelected($event)"
- *   (recordOpened)="onRecordOpened($event)"
- *   (sortChanged)="onSortChanged($event)">
+ *   [Entity]="selectedEntity"
+ *   [ViewTypeID]="state.viewTypeId"
+ *   [FilterText]="state.filterText"
+ *   [SelectedRecordID]="state.selectedRecordId"
+ *   (RecordSelected)="onRecordSelected($event)"
+ *   (RecordOpened)="onRecordOpened($event)">
  * </mj-entity-viewer>
  * ```
  */
-export declare class EntityViewerComponent extends BaseAngularComponent implements OnInit, OnDestroy {
+export declare class EntityViewerComponent extends BaseAngularComponent implements OnInit, OnDestroy, AfterViewInit {
     private cdr;
     private ngZone;
+    private elementRef;
     /**
-     * Maximum records to load in map mode. Map view needs all records for
-     * geographic visualization — paging doesn't make sense for maps. This cap
-     * prevents unbounded queries on very large entities.
+     * Safety cap on the number of records loaded when a plug-in renderer asks the container to
+     * load the full set (via a {@link ViewDataRequest} with `loadAll: true`). Prevents unbounded
+     * queries on very large entities. Generic — not tied to any specific view type.
      */
-    private static readonly MAP_MAX_RECORDS;
+    private static readonly LOAD_ALL_MAX_RECORDS;
     private _entity;
     private _records;
     private _config;
-    private _viewMode;
     private _filterText;
     private _sortState;
     private _viewEntity;
-    private _timelineConfig;
     private _initialized;
+    /**
+     * When true, the next {@link LoadData} loads the full record set (up to
+     * {@link LOAD_ALL_MAX_RECORDS}) instead of paginating. Set generically from a plug-in's
+     * {@link ViewDataRequest} (`loadAll`) — never from any view-type check.
+     */
+    private _loadAllRecords;
     /** Whether a deferred reload has been queued via deferReload() */
     private _reloadDeferred;
     /**
      * The entity to display records for
      */
-    get entity(): EntityInfo | null;
-    set entity(value: EntityInfo | null);
+    get Entity(): EntityInfo | null;
+    set Entity(value: EntityInfo | null);
     /**
-     * Pre-loaded records (optional - if not provided, component loads data)
+     * Convenience input: the entity to display by **name**. Resolved internally to an `EntityInfo`
+     * via the active provider and applied through the {@link entity} setter. Use this OR `[entity]`
+     * OR `[EntityID]` — whichever is most convenient for the consumer.
      */
-    get records(): Record<string, unknown>[] | null;
-    set records(value: Record<string, unknown>[] | null);
+    set EntityName(value: string | null);
     /**
-     * Configuration options for the viewer
+     * Convenience input: the entity to display by **ID**. Resolved internally to an `EntityInfo`
+     * and applied through the {@link entity} setter.
      */
-    get config(): Partial<EntityViewerConfig>;
-    set config(value: Partial<EntityViewerConfig>);
+    set EntityID(value: string | null);
     /**
-     * Currently selected record ID (primary key string)
+     * Convenience input: load and display a saved view by its `MJ: User Views` **ID**. The viewer
+     * loads the record via the active provider and applies it through the {@link viewEntity} setter
+     * (which also resolves the entity if `[entity]`/`[EntityName]`/`[EntityID]` weren't supplied).
      */
-    selectedRecordId: string | null;
+    set ViewID(value: string | null);
     /**
-     * External view mode - allows parent to control view mode
-     * Supports two-way binding: [(viewMode)]="state.viewMode"
+     * Pre-loaded records (optional - if not provided, component loads data)
      */
-    get viewMode(): EntityViewMode | null;
-    set viewMode(value: EntityViewMode | null);
+    get Records(): Record<string, unknown>[] | null;
+    set Records(value: Record<string, unknown>[] | null);
     /**
-     * External filter text - allows parent to control filter
-     * Supports two-way binding: [(filterText)]="state.filterText"
+     * Configuration options for the viewer
      */
-    get filterText(): string | null;
-    set filterText(value: string | null);
+    get Config(): Partial<EntityViewerConfig>;
+    set Config(value: Partial<EntityViewerConfig>);
     /**
-     * External sort state - allows parent to control sorting
+     * Currently selected record ID (primary key string)
      */
-    get sortState(): SortState | null;
-    set sortState(value: SortState | null);
+    get SelectedRecordID(): string | null;
+    set SelectedRecordID(value: string | null);
+    private _selectedRecordId;
     /**
-     * Custom grid column definitions
+     * External filter text - allows parent to control filter
+     * Supports two-way binding: [(filterText)]="state.filterText"
      */
-    gridColumns: GridColumnDef[];
+    get FilterText(): string | null;
+    set FilterText(value: string | null);
     /**
-     * Custom card template
+     * External sort state - allows parent to control sorting
      */
-    cardTemplate: CardTemplate | null;
+    get SortState(): SortState | null;
+    set SortState(value: SortState | null);
     /**
      * Optional User View entity that provides view configuration
      * When provided, the component will use the view's WhereClause, GridState, SortState, etc.
      * The view's filter is additive - UserSearchString is applied ON TOP of the view's WhereClause
      */
-    get viewEntity(): MJUserViewEntityExtended | null;
-    set viewEntity(value: MJUserViewEntityExtended | null);
+    get ViewEntity(): MJUserViewEntityExtended | null;
+    set ViewEntity(value: MJUserViewEntityExtended | null);
     /**
      * Grid state configuration from a User View
      * Controls column visibility, widths, order, and sort settings
      */
-    gridState: ViewGridState | null;
-    /**
-     * Timeline configuration state
-     * Controls which date field is used and segment grouping
-     */
-    get timelineConfig(): TimelineState | null;
-    set timelineConfig(value: TimelineState | null);
-    /**
-     * Whether to show the grid toolbar.
-     * When false, the grid is displayed without its own toolbar - useful when
-     * entity-viewer provides its own filter/actions in the header.
-     * @default false
-     */
-    showGridToolbar: boolean;
-    /**
-     * Grid toolbar configuration - controls which buttons are shown and their behavior
-     * When not provided, uses sensible defaults
-     */
-    gridToolbarConfig: Partial<GridToolbarConfig> | null;
-    /**
-     * Grid selection mode
-     * @default 'single'
-     */
-    gridSelectionMode: GridSelectionMode;
-    /**
-     * Show the "Add to List" button in the grid toolbar.
-     * Requires gridSelectionMode to be 'multiple' for best UX.
-     * @default false
-     */
-    showAddToListButton: boolean;
+    GridState: ViewGridState | null;
     /**
      * Whether to render the Recycle Bin chip in the viewer header.
      * The chip auto-hides itself when the entity has no deleted records,
@@ -158,123 +200,150 @@ export declare class EntityViewerComponent extends BaseAngularComponent implemen
     /**
      * Emitted when a record is selected (single click)
      */
-    recordSelected: EventEmitter<RecordSelectedEvent>;
+    RecordSelected: EventEmitter<RecordSelectedEvent>;
     /**
      * Emitted when a record should be opened (double-click or open button)
      */
-    recordOpened: EventEmitter<RecordOpenedEvent>;
+    RecordOpened: EventEmitter<RecordOpenedEvent>;
     /**
      * Emitted when data is loaded
      */
-    dataLoaded: EventEmitter<DataLoadedEvent>;
-    /**
-     * Emitted when the view mode changes (for two-way binding)
-     */
-    viewModeChange: EventEmitter<EntityViewMode>;
+    DataLoaded: EventEmitter<DataLoadedEvent>;
     /**
      * Emitted when filter text changes (for two-way binding)
      */
-    filterTextChange: EventEmitter<string>;
+    FilterTextChange: EventEmitter<string>;
     /**
      * Emitted when filtered count changes
      */
-    filteredCountChanged: EventEmitter<FilteredCountChangedEvent>;
+    FilteredCountChanged: EventEmitter<FilteredCountChangedEvent>;
     /**
-     * Emitted when sort state changes
+     * NAVIGATION request bubbled up from a plug-in renderer to open a *related* record on a
+     * (possibly different) entity — e.g. a grid foreign-key drill-through. Routing lives in the
+     * outer app, so this is one of the few signals that legitimately bubbles up. The container
+     * forwards it untouched.
      */
-    sortChanged: EventEmitter<SortChangedEvent>;
+    OpenRelatedRecordRequested: EventEmitter<ViewRelatedRecordNavigation>;
     /**
-     * Emitted when grid state changes (column resize, reorder, etc.)
+     * NAVIGATION request bubbled up from a plug-in renderer to create a new record of the current
+     * entity (e.g. a grid's "New" button). Opening the create form is a routing concern owned by
+     * the outer app; the container forwards it without acting on it.
      */
-    gridStateChanged: EventEmitter<GridStateChangedEvent>;
+    CreateRecordRequested: EventEmitter<void>;
     /**
-     * Emitted when timeline configuration changes (date field, grouping, etc.)
+     * The initial/active view type to open in, by `MJ: View Types` row ID. Hosts that persist
+     * the selection (e.g. Explorer's `UserView.ViewTypeID`) bind this so the viewer opens in the
+     * saved type — built-in OR plug-in. Applied once the registry resolves; later user switches
+     * emit {@link viewTypeChange} for the host to persist.
      */
-    timelineConfigChange: EventEmitter<import("@memberjunction/core-entities").MJUserViewEntity_ITimelineState>;
+    set ViewTypeID(value: string | null);
+    get ViewTypeID(): string | null;
+    private _initialViewTypeId;
     /**
-     * Emitted when the Add/New button is clicked in the grid toolbar
+     * The view-type options shown in the switcher, sourced from {@link ViewTypeEngine}
+     * (the `MJ: View Types` registry), filtered by each descriptor's availability predicate.
+     * Every option is a dynamic-mounted plug-in.
      */
-    addRequested: EventEmitter<void>;
+    AvailableViewTypes: ViewModeOption[];
+    /** Whether the registry (ViewTypeEngine) successfully sourced the available view types. */
+    ViewTypesFromRegistry: boolean;
     /**
-     * Emitted when the Delete button is clicked in the grid toolbar
-     * Includes the selected records to be deleted
+     * The currently-active view type's stable key (descriptor Name). Null until the registry resolves.
      */
-    deleteRequested: EventEmitter<{
-        records: Record<string, unknown>[];
-    }>;
+    ActiveViewTypeKey: string | null;
     /**
-     * Emitted when the Refresh button is clicked in the grid toolbar
+     * The currently-active view type's option (the plug-in being mounted). Null until the
+     * registry resolves / a type is selected. Drives the dynamic-mount host in the template.
      */
-    refreshRequested: EventEmitter<void>;
+    ActiveDynamicOption: ViewModeOption | null;
+    /** True once a plug-in view type is mounted (drives the dynamic host's visibility). */
+    get IsDynamicViewActive(): boolean;
+    /** Whether the view-type dropdown menu is currently open. */
+    ViewTypeDropdownOpen: boolean;
     /**
-     * Emitted when the Export button is clicked in the grid toolbar
+     * Per-view-type configuration payloads, keyed by `MJ: View Types` row ID. Seeded from
+     * {@link viewTypeConfigsInput} and updated as plug-in renderers emit config changes;
+     * handed to each dynamic renderer on mount.
      */
-    exportRequested: EventEmitter<{
-        format: "excel" | "csv" | "json";
-    }>;
+    private viewTypeConfigById;
     /**
-     * Emitted when the Add to List button is clicked in the grid toolbar.
-     * Parent components should handle this to show the list management dialog.
+     * Per-view-type configuration provided by the host (e.g. Explorer reading
+     * `UserView.DisplayState.viewTypeConfigs`). The active type is controlled separately via
+     * the `viewMode` / ViewTypeID inputs; this carries only the config payloads.
      */
-    addToListRequested: EventEmitter<{
-        entityInfo: EntityInfo;
-        records: Record<string, unknown>[];
-        recordIds: string[];
-    }>;
+    set ViewTypeConfigs(value: Array<{
+        viewTypeId: string;
+        config: Record<string, unknown>;
+    }> | null);
     /**
-     * Emitted when grid selection changes.
-     * Parent components can use this to track selected records for their own toolbar buttons.
+     * When true, the viewer persists view-type/config changes itself — to the loaded `UserView`
+     * record (when a `ViewEntity`/`ViewID` is present) or to per-user User Settings (the default-view
+     * case). When false (the default), the viewer only emits the `Before…`/`After…` events and the
+     * consumer is responsible for persistence. Persistence is provider-based (generic-safe) — never
+     * routing, which stays with the host app.
      */
-    selectionChanged: EventEmitter<{
-        records: Record<string, unknown>[];
-        recordIds: string[];
-    }>;
-    internalViewMode: EntityViewMode;
-    internalFilterText: string;
-    debouncedFilterText: string;
-    isLoading: boolean;
-    loadingMessage: string;
-    internalRecords: Record<string, unknown>[];
-    totalRecordCount: number;
-    filteredRecordCount: number;
+    AutoSaveView: boolean;
+    /**
+     * Emitted (cancelable) BEFORE the active view type changes. A handler may set
+     * `args.Cancel = true` to veto the switch. Fires for both built-in and plug-in types.
+     */
+    BeforeViewTypeChange: EventEmitter<ViewTypeChangeEventArgs>;
+    /**
+     * Emitted AFTER the active view type has changed (and, when {@link AutoSaveView} is on, after
+     * it has been persisted). Notification only.
+     */
+    AfterViewTypeChange: EventEmitter<ViewTypeChangeEventArgs>;
+    /**
+     * Emitted (cancelable) BEFORE a plug-in renderer's configuration change is applied/persisted.
+     */
+    BeforeViewTypeConfigChange: EventEmitter<ViewTypeConfigChangeEventArgs>;
+    /**
+     * Emitted AFTER a plug-in renderer's configuration change has been applied (and persisted when
+     * {@link AutoSaveView} is on).
+     */
+    AfterViewTypeConfigChange: EventEmitter<ViewTypeConfigChangeEventArgs>;
+    /** Anchor for dynamically-mounted plug-in view renderers. */
+    private dynamicViewHost?;
+    /** The currently-ACTIVE (visible) plug-in renderer, if any. */
+    private dynamicRendererRef;
+    /** Input names the active plug-in declares (from `reflectComponentType`), used to push only the
+     *  generic inputs it accepts. Mirrors the active cache entry's input set. */
+    private dynamicInputNames;
+    /**
+     * Cache of mounted plug-in renderer instances for the CURRENT data context (entity + view),
+     * keyed by `MJ: View Types` row ID. Switching view types within the same entity+view SHOWS/HIDES
+     * cached instances (preserving their state — e.g. a computed cluster scatter, grid scroll) instead
+     * of destroy/recreate. The whole cache is destroyed + rebuilt only when the data context changes:
+     * entity change, or view (record / ViewID, including default↔saved) change. See
+     * {@link clearDynamicRendererCache}.
+     */
+    private dynamicRendererCache;
+    InternalFilterText: string;
+    DebouncedFilterText: string;
+    IsLoading: boolean;
+    LoadingMessage: string;
+    InternalRecords: Record<string, unknown>[];
+    TotalRecordCount: number;
+    FilteredRecordCount: number;
     /** Track which records matched on hidden (non-visible) fields */
-    hiddenFieldMatches: Map<string, string>;
+    HiddenFieldMatches: Map<string, string>;
     /** Current sort state */
-    internalSortState: SortState | null;
-    /** Cached grid params to avoid recreating object on every change detection */
-    private _cachedGridParams;
-    private _lastGridParamsEntity;
-    private _lastGridParamsViewEntity;
+    InternalSortState: SortState | null;
     /** Pagination state */
-    pagination: PaginationState;
-    /** Whether the current entity has date fields available for timeline view */
-    hasDateFields: boolean;
-    /** Whether the current entity supports geocoding (has SupportsGeoCoding = 1) */
-    HasGeoCoding: boolean;
-    /** Available date fields from the entity (sorted by priority) */
-    availableDateFields: EntityFieldInfo[];
-    /** Timeline groups configuration for the timeline component */
-    get timelineGroups(): TimelineGroup<Record<string, unknown>>[];
-    set timelineGroups(value: TimelineGroup<Record<string, unknown>>[]);
-    private _timelineGroups;
-    /** Timeline sort order */
-    timelineSortOrder: TimelineSortOrder;
-    /** Timeline segment grouping */
-    timelineSegmentGrouping: TimeSegmentGrouping;
-    /** Timeline orientation (vertical or horizontal) */
-    timelineOrientation: TimelineOrientation;
-    /** Currently selected date field for timeline */
-    selectedTimelineDateField: string | null;
+    Pagination: PaginationState;
     private destroy$;
     private filterInput$;
     /** Track if this is the first load (vs. load more) */
     private isInitialLoad;
-    /** Reference to the data grid component for flushing pending changes */
-    private dataGridRef;
-    constructor(cdr: ChangeDetectorRef, ngZone: NgZone);
+    constructor(cdr: ChangeDetectorRef, ngZone: NgZone, elementRef: ElementRef<HTMLElement>);
+    /** IntersectionObserver used to detect when this viewer is re-attached/re-shown (Explorer caches +
+     *  reattaches resource components without firing Angular lifecycle hooks). See {@link ngAfterViewInit}. */
+    private _visibilityObserver;
+    private _wasVisible;
     /**
-     * Ensures any pending grid state changes are saved immediately without waiting for debounce.
-     * Call this before switching views or entities to ensure changes are saved.
+     * Hook retained for hosts (e.g. the workspace) that call this before switching views/entities.
+     * View-type-specific persistence (e.g. a grid's live column/sort state) is now owned by the
+     * mounted plug-in renderer, so the container has nothing to flush — this is a no-op.
      */
     EnsurePendingChangesSaved(): void;
     /**
@@ -282,7 +351,7 @@ export declare class EntityViewerComponent extends BaseAngularComponent implemen
      * This allows callers to provide just a viewEntity without explicitly setting the entity input.
      * Uses fallback resolution when ViewEntityInfo is not available.
      */
-    get effectiveEntity(): EntityInfo | null;
+    get EffectiveEntity(): EntityInfo | null;
     /**
      * Gets EntityInfo from a ViewEntity with multiple fallback strategies.
      * Priority: 1) ViewEntityInfo property (set by Load)
@@ -291,52 +360,27 @@ export declare class EntityViewerComponent extends BaseAngularComponent implemen
      * Returns null if entity cannot be determined.
      */
     private getEntityInfoFromViewEntity;
-    /**
-     * Get the effective view mode (external or internal)
-     */
-    get effectiveViewMode(): EntityViewMode;
     /**
      * Get the effective filter text (external or internal)
      */
-    get effectiveFilterText(): string;
-    /**
-     * Get the raw ID value from selectedRecordId for timeline selection.
-     * The selectedRecordId is in composite key format (e.g., "ID|abc-123" or "ID=abc-123"),
-     * but the timeline stores just the raw ID value.
-     */
-    get timelineSelectedEventId(): string | null;
+    get EffectiveFilterText(): string;
     /**
      * Get the effective sort state (external or internal)
      */
-    get effectiveSortState(): SortState | null;
-    /**
-     * Get the OrderBy string for mj-entity-data-grid from the effective sort state
-     */
-    get effectiveSortOrderBy(): string;
+    get EffectiveSortState(): SortState | null;
     /**
      * Get merged configuration with defaults
      */
-    get effectiveConfig(): Required<EntityViewerConfig>;
-    /**
-     * Get cached grid params - only recreates object when entity or viewEntity changes
-     * This prevents Angular from seeing a new object reference on every change detection
-     * which would cause the grid to reinitialize
-     */
-    get gridParams(): RunViewParams | null;
-    /**
-     * Get the effective grid toolbar configuration
-     * Merges user-provided config with defaults appropriate for entity-viewer context
-     */
-    get effectiveGridToolbarConfig(): GridToolbarConfig;
+    get EffectiveConfig(): Required<EntityViewerConfig>;
     /**
      * Get the records to display (external or internal)
      */
-    get displayRecords(): Record<string, unknown>[];
+    get DisplayRecords(): Record<string, unknown>[];
     /**
      * Get filtered records - when using server-side filtering, records are already filtered
      * When using client-side filtering, apply filter locally
      */
-    get filteredRecords(): Record<string, unknown>[];
+    get FilteredRecords(): Record<string, unknown>[];
     /**
      * Check if a record matches the filter text (client-side)
      */
@@ -356,11 +400,11 @@ export declare class EntityViewerComponent extends BaseAngularComponent implemen
     /**
      * Check if a record matched on a hidden field
      */
-    hasHiddenFieldMatch(record: Record<string, unknown>): boolean;
+    HasHiddenFieldMatch(record: Record<string, unknown>): boolean;
     /**
      * Get the name of the hidden field that matched for display
      */
-    getHiddenMatchFieldName(record: Record<string, unknown>): string;
+    GetHiddenMatchFieldName(record: Record<string, unknown>): string;
     ngOnInit(): void;
     /**
      * Defers a data reload to a microtask so that all Angular input bindings
@@ -368,6 +412,14 @@ export declare class EntityViewerComponent extends BaseAngularComponent implemen
      * Multiple calls within the same change detection cycle collapse into one load.
      */
     private deferReload;
+    ngAfterViewInit(): void;
+    /**
+     * Called when the viewer becomes visible again after being detached (cached-tab reattach). Mounts
+     * the active plug-in if it was never created (host wasn't ready at selection time), or re-pushes the
+     * current inputs so a host-fed grid re-renders its rows (the "N records in header but empty grid on
+     * return" symptom).
+     */
+    private onViewerReattached;
     ngOnDestroy(): void;
     /**
      * Extracts sort state from a view entity, checking ViewSortInfo first then
@@ -392,201 +444,164 @@ export declare class EntityViewerComponent extends BaseAngularComponent implemen
     /**
      * Load data for the current entity with server-side filtering/sorting/pagination
      */
-    loadData(): Promise<void>;
+    LoadData(): Promise<void>;
     /**
      * Handle page change from PaginationComponent
      */
-    onPageChange(event: PageChangeEvent): void;
+    OnPageChange(event: PageChangeEvent): void;
     /**
      * Refresh data (re-load from server, starting at page 1)
      * Keeps existing records visible during refresh for better UX
      */
-    refresh(): void;
-    /**
-     * Set the view mode and emit change event
-     */
-    setViewMode(mode: EntityViewMode): void;
-    /**
-     * Handle filter input change
-     */
-    onFilterChange(value: string): void;
-    /**
-     * Clear the filter
-     */
-    clearFilter(): void;
-    /**
-     * Handle sort change from grid component
-     */
-    onSortChanged(event: SortChangedEvent): void;
-    /**
-     * Handle record selection from child components (grid or cards)
-     */
-    onRecordSelected(event: RecordSelectedEvent): void;
-    /**
-     * Handle record opened from child components (grid or cards)
-     */
-    onRecordOpened(event: RecordOpenedEvent): void;
-    /**
-     * Handle grid state changes (column resize, reorder, etc.)
-     */
-    onGridStateChanged(event: GridStateChangedEvent): void;
+    Refresh(): void;
     /**
-     * Handle page change from the data grid's pager
+     * Loads the ViewTypeEngine once, then recomputes the available view types for the
+     * current entity. Fire-and-forget from lifecycle/setters — failures simply leave the
+     * switcher empty until the registry is available.
      */
-    onGridPageChange(event: PageChangeEvent): void;
+    private ensureViewTypesLoaded;
     /**
-     * Handle row click from mj-entity-data-grid
-     * Maps to recordSelected event for parent components
+     * Recomputes {@link AvailableViewTypes} from the registry for the current entity. Every
+     * available view type is a dynamic-mounted plug-in. Reconciles the active selection when the
+     * previously-active type is no longer available (e.g. the entity changed).
      */
-    onDataGridRowClick(event: AfterRowClickEventArgs): void;
+    private refreshAvailableViewTypes;
     /**
-     * Handle row double-click from mj-entity-data-grid
-     * Maps to recordOpened event for parent components
+     * Returns the switcher option for the active view type (for the current-type chip in the
+     * switcher), or null before the registry resolves.
      */
-    onDataGridRowDoubleClick(event: AfterRowDoubleClickEventArgs): void;
+    get ActiveViewTypeOption(): ViewModeOption | null;
     /**
-     * Handle sort changed from mj-entity-data-grid
-     * Maps to sortChanged event for parent components
+     * Selects a view type from the switcher. Built-in types route to {@link setViewMode}
+     * (preserving the rich grid/cards/timeline/map integration); plug-in types are
+     * dynamic-mounted via the descriptor's RendererComponent. Emits {@link viewTypeChange}
+     * so hosts can persist `UserView.ViewTypeID`.
      */
-    onDataGridSortChanged(event: AfterSortEventArgs): void;
+    SelectViewType(option: ViewModeOption): void;
     /**
-     * Handle foreign key link click from mj-entity-data-grid
-     * Bubbles the event up for parent components to handle navigation
+     * Selects a view type by its `MJ: View Types` row ID. This is the entry point used by external
+     * chrome (e.g. the workspace toolbar's {@link ViewTypeSwitcherComponent}) that surfaces the
+     * switcher outside the viewer's own header. Resolves the matching available option and applies
+     * it through the same lifecycle as a header-driven switch (cancelable events + persistence).
+     * No-op when the ID isn't an available view type or is already active.
+     *
+     * @param viewTypeId the `MJ: View Types` row ID to switch to.
      */
+    SelectViewTypeById(viewTypeId: string | null): void;
     /**
-     * Handle foreign key link click from mj-entity-data-grid
-     * Converts to recordOpened event for seamless navigation integration
+     * The `MJ: View Types` row ID of the currently-active view type, or null before the registry
+     * resolves. Lets external chrome (the workspace toolbar switcher) reflect the viewer's active
+     * type without reaching into the viewer's internal {@link ViewModeOption}s.
      */
-    onForeignKeyClick(event: ForeignKeyClickEvent): void;
+    get ActiveViewTypeId(): string | null;
     /**
-     * Handle Add/New button click from data grid toolbar
+     * Applies a view-type selection. `emit` is true for user-initiated switches (fires the
+     * cancelable {@link BeforeViewTypeChange}, persists when {@link AutoSaveView} is on, then fires
+     * {@link AfterViewTypeChange}) and false for internal reconciliation (no events, no persist).
+     *
+     * Every view type is a dynamic-mounted plug-in: this tears down the previous renderer and mounts
+     * the selected descriptor's `RendererComponent`. The container resets its generic load mode (a
+     * fresh plug-in that needs the full set will re-request it via `dataRequest({loadAll:true})`) and
+     * reloads page-based data when the active type changes.
      */
-    onGridAddRequested(): void;
+    private applyViewTypeSelection;
     /**
-     * Handle Refresh button click from data grid toolbar
+     * Where view-type/config persists when {@link AutoSaveView} is on: a loaded `UserView` record,
+     * per-user User Settings (the default-view case), or nowhere.
      */
-    onGridRefreshRequested(): void;
+    private persistenceTarget;
+    /** Persist the active view-type selection to the resolved target. */
+    private persistActiveViewType;
+    /** Persist a per-view-type config change to the resolved target. */
+    private persistViewTypeConfig;
+    /** Save the loaded view record, logging (not throwing) on failure. */
+    private saveViewEntity;
+    /** User Settings key for this entity's per-user default-view state. */
+    private defaultViewSettingKey;
+    /** Persist the per-user default-view state (active view type + per-type configs) to User Settings. */
+    private saveDefaultViewSetting;
+    /** Convert the in-memory per-view-type config map to the persisted array shape. */
+    private serializeViewTypeConfigs;
     /**
-     * Handle Delete button click from data grid toolbar
+     * Resolve which view type the viewer should open in, in priority order:
+     * explicit `ViewTypeID` input → the loaded `UserView` record's `ViewTypeID` → the per-user
+     * default-view setting (User Settings). Returns null to let the caller fall back to the legacy
+     * mode / first available type. This is how the viewer is self-contained for both the saved-view
+     * and default-view cases without the consumer wiring anything.
      */
-    onGridDeleteRequested(records: Record<string, unknown>[]): void;
+    private resolveInitialViewTypeId;
     /**
-     * Handle Export button click from data grid toolbar
+     * Load a saved view by ID via the active provider and apply it through the {@link viewEntity}
+     * setter. Backs the {@link ViewID} convenience input. Logs (does not throw) on failure.
      */
-    onGridExportRequested(): void;
+    private loadViewById;
+    /** Read the per-user default-view setting for the current entity (or null). */
+    private readDefaultViewSetting;
     /**
-     * Handle Add to List button click from data grid toolbar.
-     * Forwards the event to parent components for list management.
+     * Seed the in-memory per-view-type config map from the available sources when the consumer
+     * hasn't supplied them via the {@link ViewTypeConfigs} input: the loaded `UserView` record's
+     * `DisplayState.viewTypeConfigs` (saved-view case) or the per-user default-view setting.
+     * Only seeds when the map is empty, so an explicit input always wins.
      */
-    onGridAddToListRequested(event: {
-        entityInfo: EntityInfo;
-        records: Record<string, unknown>[];
-        recordIds: string[];
-    }): void;
+    private seedViewTypeConfigsIfEmpty;
     /**
-     * Handle selection change from data grid.
-     * Converts selected keys to records and forwards to parent components.
+     * Makes `option`'s plug-in the ACTIVE view: reuses its cached instance when present (preserving
+     * state), otherwise creates it. All other cached instances are hidden (kept mounted). The container
+     * has zero knowledge of which plug-in this is — it only knows the {@link IViewRenderer} contract.
      */
-    onGridSelectionChange(selectedKeys: string[]): void;
+    private selectDynamicRenderer;
     /**
-     * Handle timeline event click - emit as record selection
+     * Creates a plug-in renderer instance, wires its generic outputs, captures its declared inputs,
+     * and caches it by `MJ: View Types` row ID. (Does not show/activate it — {@link selectDynamicRenderer}
+     * does that.)
      */
-    onTimelineEventClick(event: AfterEventClickArgs): void;
+    private createDynamicRenderer;
     /**
-     * Update HasGeoCoding based on the current effectiveEntity.
-     * Called from entity setter and after data loads (when effectiveEntity may resolve via viewEntity).
+     * Toggle a cached renderer's host element visibility without destroying it (preserves state).
+     * When visible, force `display: block` + `height: 100%` rather than clearing the style: the wrapper
+     * components use `ViewEncapsulation.None`, under which their `:host { display:block; height:100% }`
+     * rule is a no-op, so a custom element defaults to `display: inline` — which gives AG Grid a
+     * zero-width viewport (no rows/columns render), especially after a hide → show cycle. Forcing block
+     * here guarantees every view-type plug-in gets a full-size block container.
      */
-    private updateGeoCodingSupport;
+    private setRendererVisible;
     /**
-     * Handle map marker click — emit the record for the parent to handle (open record, etc.)
+     * Destroys ALL cached plug-in instances and clears the host. Called when the data context changes
+     * (entity change / view (record / ViewID) change) so the next selection rebuilds fresh. NOT called
+     * on a plain view-type switch within the same context — that path reuses cached instances.
      */
-    onMapMarkerClick(event: {
-        RecordID: string;
-        Latitude: number;
-        Longitude: number;
-        Record: Record<string, unknown>;
-    }): void;
-    /** Map display state (zoom, center) — passed from parent for persistence across reloads. */
-    mapDisplayState: Partial<MapDisplayState> | null;
-    /** Map render mode — separate from DisplayState for clear single-source-of-truth. */
-    mapRenderMode: MapRenderMode;
-    /** Emitted when the map's display state changes (zoom, center). */
-    mapDisplayStateChange: EventEmitter<MapDisplayState>;
-    /** Emitted when the map's render mode changes (user clicks mode buttons). */
-    mapRenderModeChange: EventEmitter<MapRenderMode>;
+    private clearDynamicRendererCache;
     /**
-     * Handle map display state changes — bubble up to parent for persistence.
+     * Pushes the current generic data-context into the mounted plug-in renderer via `setInput`.
+     * Every input is part of the generic {@link IViewRenderer} contract; lean plug-ins may not declare
+     * all of them, so each `setInput` is wrapped in try/catch (Angular throws on undeclared inputs).
      */
-    onMapDisplayStateChange(state: MapDisplayState): void;
-    onMapRenderModeChange(mode: MapRenderMode): void;
+    private pushDynamicRendererInputs;
     /**
-     * Toggle timeline orientation between vertical and horizontal
+     * Guarded `setInput`: lean plug-ins implement only the core contract, so we only set an input the
+     * mounted plug-in actually declares (per {@link dynamicInputNames}, captured at mount via
+     * `reflectComponentType`). This avoids NG0303 dev errors for optional inputs the plug-in omits and
+     * keeps the container plug-in-agnostic.
      */
-    toggleTimelineOrientation(): void;
+    private setDynamicInput;
+    private onDynamicRecordSelected;
+    private onDynamicRecordOpened;
+    private onDynamicConfigChanged;
     /**
-     * Toggle timeline sort order between newest first (desc) and oldest first (asc)
+     * Honors a generic {@link ViewDataRequest} from the mounted plug-in. Fully view-type-agnostic —
+     * the container applies whatever is present (sort / page / pageSize / loadAll) against its
+     * existing generic data-loading path. No per-view-type branching.
      */
-    toggleTimelineSortOrder(): void;
+    private onDynamicDataRequest;
     /**
-     * Change the date field used for the timeline
-     */
-    setTimelineDateField(fieldName: string): void;
-    /**
-     * Get the display name of the currently selected timeline date field
-     */
-    get selectedDateFieldDisplayName(): string;
-    /**
-     * Emit the current timeline configuration for persistence
-     */
-    private emitTimelineConfigChange;
-    /**
-     * Detect and configure timeline based on entity's date fields
-     * Called when entity changes
-     */
-    private detectDateFields;
-    /**
-     * If currently on timeline view but timeline is no longer available,
-     * fall back to grid view
-     */
-    private fallbackFromTimelineIfNeeded;
-    /**
-     * If currently on map view but geocoding is no longer available,
-     * fall back to grid view
-     */
-    private fallbackFromMapIfNeeded;
-    /**
-     * Sort date fields by priority:
-     * 1. DefaultInView=true fields, sorted by Sequence (lowest first)
-     * 2. Other date fields, sorted by Sequence (lowest first)
-     */
-    private sortDateFieldsByPriority;
-    /**
-     * Configure the timeline with the current date field and records
-     */
-    private configureTimeline;
-    /**
-     * Get the effective date field to use for timeline
-     * Priority: timelineConfig > first available date field
-     */
-    private getEffectiveTimelineDateField;
-    /**
-     * Update timeline groups with current records
-     * Called when records change
-     */
-    private updateTimelineGroups;
-    /**
-     * Find the best field to use as the title
-     */
-    private findTitleField;
-    /**
-     * Find a suitable description field
+     * Handle filter input change
      */
-    private findDescriptionField;
+    OnFilterChange(value: string): void;
     /**
-     * Find a suitable subtitle field (different from title)
+     * Clear the filter
      */
-    private findSubtitleField;
+    ClearFilter(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<EntityViewerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<EntityViewerComponent, "mj-entity-viewer", never, { "entity": { "alias": "entity"; "required": false; }; "records": { "alias": "records"; "required": false; }; "config": { "alias": "config"; "required": false; }; "selectedRecordId": { "alias": "selectedRecordId"; "required": false; }; "viewMode": { "alias": "viewMode"; "required": false; }; "filterText": { "alias": "filterText"; "required": false; }; "sortState": { "alias": "sortState"; "required": false; }; "gridColumns": { "alias": "gridColumns"; "required": false; }; "cardTemplate": { "alias": "cardTemplate"; "required": false; }; "viewEntity": { "alias": "viewEntity"; "required": false; }; "gridState": { "alias": "gridState"; "required": false; }; "timelineConfig": { "alias": "timelineConfig"; "required": false; }; "showGridToolbar": { "alias": "showGridToolbar"; "required": false; }; "gridToolbarConfig": { "alias": "gridToolbarConfig"; "required": false; }; "gridSelectionMode": { "alias": "gridSelectionMode"; "required": false; }; "showAddToListButton": { "alias": "showAddToListButton"; "required": false; }; "ShowRecycleBin": { "alias": "ShowRecycleBin"; "required": false; }; "mapDisplayState": { "alias": "mapDisplayState"; "required": false; }; "mapRenderMode": { "alias": "mapRenderMode"; "required": false; }; }, { "recordSelected": "recordSelected"; "recordOpened": "recordOpened"; "dataLoaded": "dataLoaded"; "viewModeChange": "viewModeChange"; "filterTextChange": "filterTextChange"; "filteredCountChanged": "filteredCountChanged"; "sortChanged": "sortChanged"; "gridStateChanged": "gridStateChanged"; "timelineConfigChange": "timelineConfigChange"; "addRequested": "addRequested"; "deleteRequested": "deleteRequested"; "refreshRequested": "refreshRequested"; "exportRequested": "exportRequested"; "addToListRequested": "addToListRequested"; "selectionChanged": "selectionChanged"; "mapDisplayStateChange": "mapDisplayStateChange"; "mapRenderModeChange": "mapRenderModeChange"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityViewerComponent, "mj-entity-viewer", never, { "Entity": { "alias": "Entity"; "required": false; }; "EntityName": { "alias": "EntityName"; "required": false; }; "EntityID": { "alias": "EntityID"; "required": false; }; "ViewID": { "alias": "ViewID"; "required": false; }; "Records": { "alias": "Records"; "required": false; }; "Config": { "alias": "Config"; "required": false; }; "SelectedRecordID": { "alias": "SelectedRecordID"; "required": false; }; "FilterText": { "alias": "FilterText"; "required": false; }; "SortState": { "alias": "SortState"; "required": false; }; "ViewEntity": { "alias": "ViewEntity"; "required": false; }; "GridState": { "alias": "GridState"; "required": false; }; "ShowRecycleBin": { "alias": "ShowRecycleBin"; "required": false; }; "ViewTypeID": { "alias": "ViewTypeID"; "required": false; }; "ViewTypeConfigs": { "alias": "ViewTypeConfigs"; "required": false; }; "AutoSaveView": { "alias": "AutoSaveView"; "required": false; }; }, { "RecordSelected": "RecordSelected"; "RecordOpened": "RecordOpened"; "DataLoaded": "DataLoaded"; "FilterTextChange": "FilterTextChange"; "FilteredCountChanged": "FilteredCountChanged"; "OpenRelatedRecordRequested": "OpenRelatedRecordRequested"; "CreateRecordRequested": "CreateRecordRequested"; "BeforeViewTypeChange": "BeforeViewTypeChange"; "AfterViewTypeChange": "AfterViewTypeChange"; "BeforeViewTypeConfigChange": "BeforeViewTypeConfigChange"; "AfterViewTypeConfigChange": "AfterViewTypeConfigChange"; }, never, never, false, never>;
 }
 //# sourceMappingURL=entity-viewer.component.d.ts.map