import { OnInit, OnDestroy, AfterViewInit, ChangeDetectorRef, EventEmitter, OnChanges, SimpleChanges, ElementRef, NgZone } from '@angular/core';
import { Subject } from 'rxjs';
import { BaseDashboard } from '@memberjunction/ng-shared';
import { RecentAccessService } from '@memberjunction/ng-shared-generic';
import { EntityInfo } from '@memberjunction/core';
import { ResourceData } from '@memberjunction/core-entities';
import { RecordSelectedEvent, RecordOpenedEvent, DataLoadedEvent, FilteredCountChangedEvent, EntityViewerConfig, NavigateToRelatedEvent, ViewWorkspaceComponent, ViewRelatedRecordNavigation } from '@memberjunction/ng-entity-viewer';
import { MJUserViewEntityExtended } from '@memberjunction/core-entities';
import { ExplorerStateService } from './services/explorer-state.service';
import { DataExplorerState, DataExplorerFilter, BreadcrumbItem, DataExplorerDeepLink, RecentRecordAccess, FavoriteRecord, AppEntityGroup } from './models/explorer-state.interface';
import { OpenRecordEvent, SelectRecordEvent } from './components/navigation-panel/navigation-panel.component';
import * as i0 from "@angular/core";
/**
 * Data Explorer Dashboard - Power user interface for exploring data across entities
 * Combines card-based browsing with grid views and relationship visualization
 *
 * Uses mj-entity-viewer composite component for the main content area,
 * which handles data loading, filtering, and view mode switching.
 */
export declare class DataExplorerDashboardComponent extends BaseDashboard implements OnInit, OnDestroy, OnChanges, AfterViewInit {
    stateService: ExplorerStateService;
    private cdr;
    private recentAccessService;
    private ngZone;
    protected destroy$: Subject<void>;
    private metadata;
    /** Reference to the filter input for keyboard shortcuts */
    filterInputRef: ElementRef<HTMLInputElement> | undefined;
    /** Reference to the view workspace (owns view CRUD + the inner data renderer) */
    viewWorkspaceRef: ViewWorkspaceComponent | undefined;
    /**
     * Optional filter to constrain which entities are shown in the explorer.
     * Can filter by applicationId, schemaNames, or explicit entityNames.
     */
    entityFilter: DataExplorerFilter | null;
    /**
     * Optional deep link to navigate to a specific entity/record on load.
     * Parsed from URL query parameters (e.g., ?entity=Users&record=123)
     */
    deepLink: DataExplorerDeepLink | null;
    /**
     * Optional context name to display in the header instead of "Data Explorer".
     * Use this to customize the explorer for specific applications (e.g., "CRM", "Association Demo").
     */
    contextName: string | null;
    /**
     * Optional context icon (Font Awesome class) to display in the header.
     * Use this alongside contextName for a fully customized header (e.g., "fa-solid fa-users" for CRM).
     */
    contextIcon: string | null;
    /**
     * Initial query params forwarded from the resource wrapper.
     * On hard refresh, the shell delivers params to the wrapper (which has Data.Configuration.queryParams),
     * not to this inner dashboard component. This input bridges that gap.
     */
    initialQueryParams: Record<string, string>;
    /**
     * Emitted when the display title should change (entity selected, record opened, etc.)
     */
    DisplayNameChanged: EventEmitter<string>;
    state: DataExplorerState;
    private allEntities;
    entities: EntityInfo[];
    appEntityGroups: AppEntityGroup[];
    private applicationEntityIds;
    selectedEntity: EntityInfo | null;
    totalRecordCount: number;
    filteredRecordCount: number;
    selectedRecord: Record<string, unknown> | null;
    detailPanelEntity: EntityInfo | null;
    private loadedRecords;
    selectedViewEntity: MJUserViewEntityExtended | null;
    liveFilterText: string;
    debouncedFilterText: string;
    private filterInput$;
    entityFilterText: string;
    breadcrumbs: BreadcrumbItem[];
    isLoadingEntities: boolean;
    recentRecords: RecentRecordAccess[];
    favoriteRecords: FavoriteRecord[];
    isLoadingRecentRecords: boolean;
    recentRecordsEntityFilter: string | null;
    GetResourceDisplayName(data: ResourceData): Promise<string>;
    /**
     * Get app entity groups filtered by current entityFilterText and homeViewMode.
     * When searching, auto-expands groups that contain matches.
     */
    get filteredAppEntityGroups(): AppEntityGroup[];
    /**
     * Filter a single group's entities by text and favorites mode.
     * Returns a new group with filtered entities and auto-expansion when searching.
     */
    private filterGroupEntities;
    /**
     * Get a flat filtered entity list for single-application mode.
     * Used when entityFilter.applicationId is set, bypassing app grouping.
     */
    get flatFilteredEntities(): EntityInfo[];
    /**
     * Total count of entities matching current filters (across all groups or flat list)
     */
    get filteredEntityCount(): number;
    /** No-results message for the entity list (echoes the filter text). */
    get NoEntityResultsMessage(): string;
    /**
     * Count of applications that have at least one visible entity
     */
    get applicationCount(): number;
    /**
     * Get recent entities for home screen display (max 5)
     */
    get recentEntities(): EntityInfo[];
    /**
     * Get favorite entities for home screen display
     */
    get favoriteEntities(): EntityInfo[];
    /**
     * Recent records limited to 3 for the quick access panel
     */
    get quickAccessRecentRecords(): RecentRecordAccess[];
    /**
     * Recent entities limited to 3 for the quick access panel
     */
    get quickAccessRecentEntities(): EntityInfo[];
    /**
     * Favorite records limited to 3 for the quick access panel
     */
    get quickAccessFavoriteRecords(): FavoriteRecord[];
    /**
     * Check if a quick access section is expanded
     */
    isQuickAccessSectionExpanded(sectionId: string): boolean;
    /**
     * Get unique entities from recent records for the filter strip.
     * Returns up to 5 entities, sorted by frequency in the recent records.
     */
    get uniqueRecentRecordEntities(): {
        entityId: string;
        entityName: string;
        icon: string;
        count: number;
    }[];
    /**
     * Check if we should show the entity filter strip for recent records.
     * Only show when there are 2+ unique entities.
     */
    get showRecentRecordsEntityFilter(): boolean;
    /**
     * Get filtered recent records based on entity filter.
     */
    get filteredRecentRecords(): RecentRecordAccess[];
    /**
     * Set the entity filter for recent records
     */
    setRecentRecordsEntityFilter(entityId: string | null): void;
    /**
     * Get the display title for the header.
     * Priority: contextName > entityFilter.applicationName > "Data Explorer"
     */
    get displayTitle(): string;
    /**
     * Get the display icon for the header (when at home level).
     * Returns contextIcon if provided, otherwise null.
     */
    get displayIcon(): string | null;
    /**
     * Configuration for mj-entity-viewer composite component
     * Hides the built-in header since we have a custom header in the dashboard
     * Uses server-side pagination with 100 records per page (default)
     */
    viewerConfig: Partial<EntityViewerConfig>;
    constructor(stateService: ExplorerStateService, cdr: ChangeDetectorRef, recentAccessService: RecentAccessService, ngZone: NgZone);
    ngOnInit(): Promise<void>;
    /**
     * After the view initializes, publish the initial agent context and register the
     * mode-scoped client tools the AI agent can invoke against this surface (the initial
     * mode is 'home' until an entity is selected). The ongoing context re-emit and tool
     * re-scoping both happen in the state subscription set up in {@link ngOnInit}.
     */
    ngAfterViewInit(): void;
    /**
     * Publish the current Data Explorer state to the AI agent via NavigationService.
     *
     * When an entity is selected this reports the record-browsing surface
     * (SelectedEntityName, ViewMode, ActiveViewId, FilterText, Total/Filtered record
     * counts, SelectedRecordName, DetailPanelOpen). At the home level it instead reports
     * the entity-browsing surface (HomeViewMode, EntitySearchText, VisibleEntityCount).
     * The shaping lives in the pure {@link buildDataExplorerAgentContext} helper so it
     * stays unit-testable. Called on init and on every state change.
     */
    private publishAgentContext;
    /**
     * Normalize the grid's SortDirection (`'asc' | 'desc' | null`) for the agent context.
     * The viewer can carry a null direction as "unsorted"; we only report 'asc'/'desc'.
     */
    private normalizeSortDirection;
    /**
     * Names of the entities related to the selected entity, read straight from in-memory
     * {@link EntityInfo.RelatedEntities} metadata (no lookup). Bounded to a sane number so the
     * streamed context stays small; the context helper bounds it again. Returns [] at the home level.
     */
    private getRelatedEntityNames;
    /**
     * Display values of the records currently loaded in the grid (from {@link loadedRecords}),
     * in grid order, using the same name-field logic the detail panel / state use
     * ({@link getRecordDisplayName}). Drives the agent's VisibleRecordNames context and the
     * SelectRecord tool. Returns [] when no entity is selected or nothing is loaded.
     */
    private getVisibleRecordNames;
    /**
     * Resolve an agent-supplied entity reference to one of the available entities, matching
     * the way the user names things (display name with the "MJ: " prefix stripped, e.g.
     * "ML Models" → "MJ: ML Models"). Delegates to the pure {@link resolveEntityByName} helper.
     */
    private resolveEntityByName;
    /**
     * The record-view modes the CURRENT entity actually supports. Mirrors the gating in
     * {@link reconcileViewModeForEntity}: 'grid' and 'cards' are always available; 'timeline'
     * requires at least one Date field; 'map' requires geocoding support. Returns [] at the
     * home level. Read straight from in-memory {@link EntityInfo} metadata (no lookup).
     */
    private getAvailableViewTypesForSelectedEntity;
    /**
     * The grid's server-side page size. The dashboard forwards {@link viewerConfig} to the inner
     * viewer; when it doesn't set `pageSize` the viewer's default (100) applies. We surface that
     * effective value so the agent can derive total pages from the record counts.
     */
    private getEffectivePageSize;
    /**
     * Summaries of the application groups currently shown on the home-screen entity browser
     * (name, visible-entity count, expanded flag). Reuses the same filtered grouping the UI
     * renders ({@link filteredAppEntityGroups}), so the agent sees exactly what the user sees.
     * Returns [] when scoped to a single application (no grouping).
     */
    private getAgentAppGroupSummaries;
    /**
     * Saved views accessible to the current user for the selected entity, read from the
     * already-loaded {@link UserViewEngine} cache (no new RunView). Returns [] at the home
     * level. The engine's cache is populated lazily elsewhere (e.g. {@link restoreViewFromUrl}
     * and the view workspace); if it hasn't loaded yet this returns [] and the next state
     * change re-publishes once it has.
     */
    private getAccessibleViewsForSelectedEntity;
    /**
     * Resolve the display name for the active view id. Prefers the live
     * {@link selectedViewEntity}, then the accessible-views list, then the engine cache.
     */
    private resolveActiveViewName;
    /**
     * Column/field names visible in the grid for the selected entity — the entity's
     * default-in-view fields, read straight from in-memory {@link EntityInfo} metadata
     * (no lookup). Falls back to all fields when none are flagged for view display.
     * Returns [] at the home level.
     */
    private getVisibleColumnNames;
    /**
     * Tracks which tool set was last registered with the NavigationService, so the
     * mode-scoped re-registration ({@link syncAgentToolsForMode}) only fires on the
     * home↔entity transition rather than on every state change.
     */
    private lastRegisteredToolMode;
    /**
     * Re-scope the agent's client tools to the CURRENT mode. The Data Explorer has two
     * surfaces with very different affordances:
     * - 'home' (no entity selected): the entity browser — browse/search entities, favorites,
     *   application groups.
     * - 'entity' (an entity is selected): the record view — views, view types, filter, sort,
     *   paginate, open record, export, view properties.
     *
     * We register the COMMON tools plus exactly one mode's tools, so a browser-only tool is
     * never exposed in record-view mode and vice-versa. Because {@link publishAgentContext}
     * fires on every state change but the tool set only changes on the mode flip, this guards
     * on {@link lastRegisteredToolMode} and only calls into NavigationService when the mode
     * actually changes.
     */
    private syncAgentToolsForMode;
    /** The tool-definition shape the NavigationService accepts. */
    private buildAgentTool;
    /**
     * COMMON tools — available in BOTH modes. Currently just {@link BackToEntityBrowser},
     * which deselects the current entity and returns to the entity browser (the home screen).
     */
    private buildCommonTools;
    /**
     * ENTITY-BROWSER tools — only registered at the home level (no entity selected).
     * Browse/search entities, manage favorites, expand/collapse application groups.
     */
    private buildEntityBrowserTools;
    /**
     * RECORD-VIEW tools — only registered when an entity is selected. Views, view types,
     * filter, sort, paginate, open/create record, navigate-to-related, export, view properties.
     */
    private buildRecordViewTools;
    /**
     * Build a tolerant "entity not found" error listing a few of the DISPLAY names the user
     * actually sees, so the agent can correct itself.
     */
    private entityNotFoundError;
    /** Resolve an entity by name and open its data. */
    private toolOpenEntityData;
    /** Apply a record filter for the selected entity. */
    private toolFilterRecords;
    /** Switch the record-view mode after validating it. */
    private toolSetViewMode;
    /**
     * Select a saved view by name OR id. The agent now sees view names via the
     * AvailableViews context field, so this resolves a supplied name (case-insensitive)
     * to its id against the in-memory {@link UserViewEngine} cache for the current entity.
     * A value that already matches a known view id is used directly.
     */
    private toolSelectView;
    /**
     * Select a record/row in the current view by position or name, then drive the same
     * selection path a user row-click takes (open the detail panel, track recent, highlight
     * the grid row via the viewer's additive SelectRecord). Tolerant: clear errors when no
     * records are loaded or the position/name doesn't match.
     */
    private toolSelectRecord;
    /**
     * Coerce the agent's loosely-typed SelectRecord params into a {@link RecordSelectionRequest}.
     * `position` may arrive as a string ('first'/'last'/'2') or a number; `name` as a string.
     */
    private parseRecordSelectionRequest;
    /**
     * Drive the selection of a loaded record exactly like {@link onViewerRecordSelected}: set the
     * selected record + detail-panel entity, open the detail panel via the state service, and ask
     * the inner viewer to highlight the matching grid row (additive viewer.SelectRecord). Mirrors
     * the user row-click path so the detail panel opens and the grid reflects the selection.
     */
    private applyRecordSelection;
    /** Open the currently-selected record in its full form. */
    private toolOpenSelectedRecord;
    /** Open a new-record form for the selected entity. */
    private toolCreateNewRecord;
    /** Navigate to a related entity, optionally applying a filter. */
    private toolNavigateToRelated;
    /** Drive the home-screen entity-search box. */
    private toolSearchEntities;
    /** Switch the home-screen entity browser between 'all' and 'favorites'. */
    private toolSetEntityBrowserMode;
    /** Add or remove an entity from favorites by name (reversible). */
    private toolToggleEntityFavorite;
    /**
     * Expand or collapse an application group by its application NAME (the agent sees names,
     * not the internal application IDs). Resolves the name against the currently-shown groups.
     */
    private toolSetAppGroupExpanded;
    /** Change the record-view type (alias of SetViewMode). */
    private toolChangeViewType;
    /** Deselect the current entity and return to the entity browser (home screen). */
    private toolBackToEntityBrowser;
    /**
     * Export the current entity/view's records. Delegates to the inner grid's Export()
     * (via the view workspace). Optional format: csv | excel | json (defaults to excel).
     */
    private toolExportView;
    /** Narrow an untrusted export-format param to a supported value, or 'invalid'. */
    private normalizeExportFormat;
    /** Open the view configuration / properties panel (same as Cmd+,). */
    private toolOpenViewProperties;
    /** Advance the record grid to the next page. */
    private toolNextPage;
    /** Move the record grid to the previous page. */
    private toolPreviousPage;
    /** Jump the record grid to a specific 1-based page number. */
    private toolGoToPage;
    /**
     * Shared executor for the three pagination tools: run the workspace passthrough,
     * report the resulting page, and re-publish context. A null result means the grid
     * isn't paging (e.g. not mounted, or externally-supplied records).
     */
    private applyPageChange;
    /** Set the record grid's server-side page size (reloads from page 1). */
    private toolSetPageSize;
    /** Sort the record grid by a column + optional direction (asc | desc, default asc). */
    private toolSetSort;
    /**
     * Deselect the current entity and return to the entity browser. Mirrors the home path
     * used by {@link onBreadcrumbClick} (application level) and {@link applyParams} (no params):
     * clear the selected entity / record / detail panel and notify the state service.
     */
    private goToEntityBrowser;
    /**
     * Handle keyboard shortcuts
     * "/" or Cmd+K focuses the filter input
     */
    handleKeyboardShortcut(event: KeyboardEvent): void;
    /**
     * Focus the filter input
     */
    private focusFilterInput;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): Promise<void>;
    protected initDashboard(): void;
    protected loadData(): void;
    /**
     * Load all available entities the user can access, applying any configured filter
     * @param urlState Optional URL state - if provided, skip restoring persisted entity to avoid race conditions
     */
    private loadEntities;
    /**
     * Load entity IDs associated with a specific application
     */
    private loadApplicationEntityIds;
    /**
     * Apply the configured filter to the entity list
     */
    private applyEntityFilter;
    /**
     * Handle entity selection from navigation panel or home screen
     */
    onEntitySelected(entity: EntityInfo): void;
    /**
     * Handle state changes from external sources
     */
    private onStateChanged;
    /**
     * Reset viewMode to 'grid' if the current mode isn't supported by the given entity
     * (e.g., switching to an entity without geocoding while viewMode is 'map').
     */
    private reconcileViewModeForEntity;
    /**
     * Reset record counts when entity changes.
     * The actual counts will be updated when mj-entity-viewer emits dataLoaded event.
     */
    private resetRecordCounts;
    /**
     * Handle a view selection emitted by the workspace. Tracks the selected view for routing/export
     * and syncs the selected-view-id + smart-filter into the Explorer state service for URL sync.
     * Grid-state application is owned by the workspace.
     */
    onWorkspaceViewSelected(view: MJUserViewEntityExtended | null): void;
    /**
     * Handle the workspace's "open view in tab" request — route via NavigationService.
     */
    onOpenInTabRequested(viewId: string): void;
    /**
     * Handle the workspace's "create new record" request — route via NavigationService.
     */
    onCreateNewRecordRequested(entity: EntityInfo): void;
    /**
     * Clear the Explorer "view modified" flag after the workspace persists/reverts a view.
     */
    onWorkspaceViewSaved(): void;
    /**
     * Handle smart filter change from dashboard header
     */
    onSmartFilterChanged(prompt: string): void;
    /**
     * Handle direct keyboard input in the filter text box.
     * Only updates the live display text and pushes to the debounce subject.
     * Does NOT trigger state changes or URL updates — those happen after the debounce.
     */
    onFilterInputChanged(filterText: string): void;
    /**
     * Clear the record filter (called by the X button).
     */
    clearRecordFilter(): void;
    /**
     * Handle filter text change from mj-entity-viewer (two-way binding)
     */
    onFilterTextChanged(filterText: string): void;
    /**
     * Handle record selection from mj-entity-viewer
     */
    onViewerRecordSelected(event: RecordSelectedEvent): void;
    /**
     * Handle record opened from mj-entity-viewer (double-click or open button)
     */
    onViewerRecordOpened(event: RecordOpenedEvent): void;
    /**
     * Handle the workspace's OpenRecordRequested (record open from the inner viewer). Builds the
     * composite key from the record and routes to the full record view via the OpenEntityRecord output.
     */
    onWorkspaceOpenRecord(event: {
        entity: EntityInfo;
        record: Record<string, unknown>;
    }): void;
    /**
     * Handle data loaded from mj-entity-viewer
     */
    onDataLoaded(event: DataLoadedEvent): void;
    /**
     * Handle filtered count change from mj-entity-viewer
     */
    onFilteredCountChanged(event: FilteredCountChangedEvent): void;
    /**
     * Handle detail panel close
     */
    onDetailPanelClosed(): void;
    /**
     * Handle opening a record in full view (from detail panel)
     * Uses detailPanelEntity since the panel may be showing a different entity than the grid
     */
    onOpenRecord(record: Record<string, unknown>): void;
    /**
     * Handle creating a new record for the current entity
     */
    onCreateNewRecord(): void;
    /**
     * Show a notification to the user
     */
    private showNotification;
    /**
     * Handle navigation to a related entity from detail panel.
     * Navigates within the explorer and applies filter to show related records.
     */
    onNavigateToRelated(event: NavigateToRelatedEvent): void;
    /**
     * Handle opening a related record - display in detail panel (not new tab)
     * The record is already loaded, so just update the detail panel
     */
    onOpenRelatedRecord(event: {
        entityName: string;
        record: Record<string, unknown>;
    }): void;
    /**
     * Handle opening a foreign key record (from FK field link in detail panel)
     * Loads the record and displays it in the detail panel
     */
    onOpenForeignKeyRecord(event: {
        entityName: string;
        recordId: string;
    }): Promise<void>;
    /**
     * Show an already-loaded record in the detail panel
     * Note: This does NOT change selectedEntity (the main grid's entity)
     * It only updates detailPanelEntity which is used by the detail panel
     */
    private showRecordInDetailPanel;
    /**
     * Load a record by ID and show it in the detail panel
     */
    private loadAndShowRecordInDetailPanel;
    /**
     * Handle opening a record from navigation panel (recent/favorites)
     */
    onOpenRecordFromNav(event: OpenRecordEvent): void;
    /**
     * Handle selecting a record from navigation panel (recent/favorites).
     * Navigates to the entity within Data Explorer and selects the record
     * in the detail panel (instead of opening full record view).
     */
    onSelectRecordFromNav(event: SelectRecordEvent): void;
    /**
     * Toggle navigation panel
     */
    toggleNavigationPanel(): void;
    /**
     * Handle expand and focus from collapsed nav icon click
     */
    onExpandAndFocus(section: 'favorites' | 'recent' | 'entities'): void;
    /**
     * Apply a deep link to navigate to a specific entity/record
     */
    private applyDeepLink;
    /** Record ID to select once data loads (from deep link) */
    private pendingRecordSelection;
    /**
     * Handle breadcrumb click - navigate to that level
     */
    onBreadcrumbClick(breadcrumb: BreadcrumbItem, index: number): void;
    /**
     * Get the set of allowed entity names for filtering favorites/recents.
     * Returns null if no filter is active (all entities allowed).
     */
    get allowedEntityNames(): Set<string> | null;
    /**
     * Get display name for a record
     */
    private getRecordDisplayName;
    /**
     * Get the icon class for an entity
     */
    getEntityIcon(entity: EntityInfo): string;
    /**
     * Format entity icon to ensure proper Font Awesome class format
     */
    private formatEntityIcon;
    /**
     * Build a DataExplorerDeepLink from framework query params.
     * Returns null if no relevant params found.
     */
    private buildDeepLinkFromParams;
    /**
     * React to back/forward navigation or deep-link entry.
     * The base class calls this when query params change via popstate or deeplink.
     */
    protected OnQueryParamsChanged(params: Record<string, string>, _source: 'popstate' | 'deeplink'): void;
    /**
     * Public entry point for the resource wrapper to forward query param changes.
     * The wrapper receives OnQueryParamsChanged from the framework and delegates here.
     */
    HandleQueryParamsChanged(params: Record<string, string>, _source: 'popstate' | 'deeplink'): void;
    /**
     * Apply a params map (from framework query params) to the component state.
     */
    private applyParams;
    /**
     * Push current navigation state to the URL via the framework.
     * Called whenever state changes so users can bookmark/share URLs.
     */
    private pushCurrentStateToUrl;
    /**
     * Apply URL state to the component.
     * Used both during init and for popstate handling.
     */
    private applyUrlState;
    /**
     * Restore a saved view from the URL's viewId parameter.
     * Looks up the view by ID and sets it as selected; the workspace applies its grid state once
     * selectedViewEntity flows into its [SelectedView] input. Must be async because UserViewEngine's
     * cache may not be populated yet on cold page loads.
     */
    private restoreViewFromUrl;
    /**
     * Emit the current display name based on selected entity/record.
     */
    private emitDisplayName;
    /**
     * Toggle entity favorite status
     */
    toggleEntityFavorite(entity: EntityInfo, event: Event): Promise<void>;
    /**
     * Check if entity is favorited (for template)
     */
    isEntityFavorited(entity: EntityInfo): boolean;
    /**
     * Toggle show all entities vs common entities
     */
    toggleShowAllEntities(): void;
    /**
     * Toggle an application group's expanded/collapsed state
     */
    toggleAppGroup(groupId: string): void;
    /**
     * Set the home view mode (all vs favorites)
     */
    setHomeViewMode(mode: 'all' | 'favorites'): void;
    /**
     * Toggle the quick access (right) panel
     */
    toggleQuickAccessPanel(): void;
    /**
     * Toggle a section in the quick access panel
     */
    toggleQuickAccessSection(sectionId: string): void;
    /**
     * Build application entity groups from metadata.
     * Groups entities by their first application membership.
     * Entities not in any application go into "System & Other".
     */
    private buildAppEntityGroups;
    /**
     * Add an entity to its application group in the map, creating the group if needed
     */
    private addEntityToGroup;
    /**
     * Handle clicking on a recent record from home screen.
     * Navigates to the entity and sets up pending selection to select the record
     * and open the detail panel once data loads.
     */
    onRecentRecordClick(record: RecentRecordAccess): void;
    /**
     * Handle clicking on a favorite record from home screen.
     * Navigates to the entity and sets up pending selection to select the record
     * and open the detail panel once data loads.
     */
    onFavoriteRecordClick(record: FavoriteRecord): void;
    /**
     * Get the icon for an entity by ID (for recent records)
     */
    getEntityIconById(entityId: string): string;
    private relativeTimeCache;
    /**
     * Format relative time for display (e.g., "2 hours ago")
     * Cached to prevent ExpressionChangedAfterItHasBeenCheckedError
     */
    formatRelativeTime(date: Date): string;
    /**
     * Check if we're at the home level (no entity selected)
     */
    get isAtHomeLevel(): boolean;
    /**
     * NAVIGATION handler: open a *related* record on a (possibly different) entity, bubbled up from a
     * plug-in renderer through the workspace (e.g. a grid foreign-key drill-through). Resolves the
     * target entity and shows the record in the detail panel, mirroring the FK navigation path used
     * by {@link onOpenForeignKeyRecord}.
     *
     * @param nav the related-record navigation payload: the target entity name and the record's key.
     */
    onOpenRelatedRecordRequested(nav: ViewRelatedRecordNavigation): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataExplorerDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataExplorerDashboardComponent, "mj-data-explorer-dashboard", never, { "entityFilter": { "alias": "entityFilter"; "required": false; }; "deepLink": { "alias": "deepLink"; "required": false; }; "contextName": { "alias": "contextName"; "required": false; }; "contextIcon": { "alias": "contextIcon"; "required": false; }; "initialQueryParams": { "alias": "initialQueryParams"; "required": false; }; }, { "DisplayNameChanged": "DisplayNameChanged"; }, never, never, false, never>;
}
//# sourceMappingURL=data-explorer-dashboard.component.d.ts.map