import { OnInit, OnDestroy, ChangeDetectorRef, EventEmitter, OnChanges, SimpleChanges, ElementRef, NgZone } from '@angular/core';
import { Router } from '@angular/router';
import { BaseDashboard, NavigationService } 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, EntityViewMode, NavigateToRelatedEvent, EntityViewerComponent, ViewGridState, GridStateChangedEvent, ViewSaveEvent, ViewConfigPanelComponent, ViewConfigSummary, QuickSaveEvent, QuickSaveAdvancedEvent, DuplicateViewEvent, SharedViewAction } from '@memberjunction/ng-entity-viewer';
import { ViewSelectedEvent, SaveViewRequestedEvent, ViewSelectorComponent } from './components/view-selector/view-selector.component';
import { CompositeFilterDescriptor, FilterFieldInfo } from '@memberjunction/ng-filter-builder';
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 { ListManagementDialogConfig, ListManagementResult } from '@memberjunction/ng-list-management';
import { ExportService, ExportDialogConfig, ExportDialogResult } from '@memberjunction/ng-export-service';
import { ExportData } from '@memberjunction/export-engine';
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 {
    stateService: ExplorerStateService;
    private cdr;
    private router;
    private recentAccessService;
    private navigationService;
    private exportService;
    private ngZone;
    private destroy$;
    private metadata;
    /** Reference to the filter input for keyboard shortcuts */
    filterInputRef: ElementRef<HTMLInputElement> | undefined;
    /** Reference to the view selector for refreshing after save */
    viewSelectorRef: ViewSelectorComponent | undefined;
    /** Reference to the entity viewer for refreshing after view save */
    entityViewerRef: EntityViewerComponent | undefined;
    /** Reference to the view config panel for passing filter state */
    viewConfigPanelRef: ViewConfigPanelComponent | 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;
    /**
     * 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;
    isDateFieldDropdownOpen: boolean;
    private skipUrlUpdates;
    private lastNavigatedUrl;
    recentRecords: RecentRecordAccess[];
    favoriteRecords: FavoriteRecord[];
    isLoadingRecentRecords: boolean;
    recentRecordsEntityFilter: string | null;
    showExportDialog: boolean;
    exportDialogConfig: ExportDialogConfig | null;
    showListManagementDialog: boolean;
    listManagementConfig: ListManagementDialogConfig | null;
    selectedRecordIds: string[];
    selectedRecords: Record<string, unknown>[];
    showQuickSaveDialog: boolean;
    quickSaveSummary: ViewConfigSummary | null;
    pendingNewViewName: string;
    pendingNewViewDescription: string;
    pendingNewViewIsShared: boolean;
    showDuplicateDialog: boolean;
    duplicateSourceViewName: string;
    duplicateSummary: ViewConfigSummary | null;
    private duplicateTargetViewId;
    showSharedViewWarning: boolean;
    private pendingQuickSaveEvent;
    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;
    /**
     * 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;
    /**
     * Check if the currently selected entity has date fields available for timeline view.
     * Used to conditionally show the timeline toggle button in the header.
     */
    get entityHasDateFields(): boolean;
    /**
     * Get available date fields for the currently selected entity.
     * Used for the date field selector in timeline view.
     */
    get availableDateFields(): {
        name: string;
        displayName: string;
    }[];
    /**
     * Get the effective timeline date field name.
     * Returns stored value if valid, otherwise first available date field.
     */
    get effectiveTimelineDateField(): string | null;
    /**
     * Get the display name of the effective timeline date field.
     */
    get effectiveTimelineDateFieldDisplayName(): string;
    /**
     * Set the timeline date field.
     */
    setTimelineDateField(fieldName: string): void;
    /**
     * Toggle the date field dropdown open/closed.
     */
    toggleDateFieldDropdown(): void;
    /**
     * Close the date field dropdown.
     */
    closeDateFieldDropdown(): void;
    /**
     * Toggle timeline orientation between vertical and horizontal.
     */
    toggleTimelineOrientation(): void;
    /**
     * Toggle timeline sort order between newest first (desc) and oldest first (asc).
     */
    toggleTimelineSortOrder(): void;
    /**
     * Get the current timeline configuration for the entity-viewer.
     */
    get currentTimelineConfig(): {
        dateFieldName: string;
        orientation: 'vertical' | 'horizontal';
        sortOrder: 'asc' | 'desc';
    } | 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>;
    /**
     * Current grid state (built from view entity or local state changes)
     * This is passed to mj-entity-viewer to control column display
     */
    currentGridState: ViewGridState | null;
    isFilterDialogOpen: boolean;
    filterDialogFields: FilterFieldInfo[];
    filterDialogState: CompositeFilterDescriptor;
    filterDialogDisabled: boolean;
    isSavingView: boolean;
    constructor(stateService: ExplorerStateService, cdr: ChangeDetectorRef, router: Router, recentAccessService: RecentAccessService, navigationService: NavigationService, exportService: ExportService, ngZone: NgZone);
    ngOnInit(): Promise<void>;
    /**
     * 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 record counts when entity changes.
     * The actual counts will be updated when mj-entity-viewer emits dataLoaded event.
     */
    private resetRecordCounts;
    /**
     * Handle view selection from view selector dropdown
     */
    onViewSelected(event: ViewSelectedEvent): void;
    /**
     * Load user's saved default grid state from UserInfoEngine
     * Returns null if no saved state exists
     */
    private loadUserDefaultGridState;
    /**
     * Parse GridState JSON from a UserView entity
     * Returns null if no valid GridState is present
     */
    private parseViewGridState;
    /**
     * Handle grid state changes from entity-viewer (column resize, reorder, etc.)
     * Updates the local currentGridState and marks view as modified
     */
    onGridStateChanged(event: GridStateChangedEvent): void;
    /**
     * Whether the config panel should default to save-as-new mode (BUG-011)
     */
    defaultSaveAsNew: boolean;
    /**
     * Handle save view request from view selector (BUG-011: forward saveAsNew intent)
     */
    onSaveViewRequested(event: SaveViewRequestedEvent): void;
    /**
     * Handle manage views request - opens view browser
     */
    onManageViewsRequested(): void;
    /**
     * Handle open in tab request - opens the view as a ViewResource in a new tab
     */
    onOpenInTabRequested(viewId: string): void;
    /**
     * Handle configure view request - opens the configuration panel
     */
    onConfigureViewRequested(): void;
    /**
     * Close the view configuration panel
     */
    onCloseViewConfigPanel(): void;
    private clearPendingNewViewState;
    /**
     * Handle request to open filter dialog from view config panel
     * The dialog is rendered at dashboard level to allow full viewport width
     */
    onOpenFilterDialogRequest(event: {
        filterState: CompositeFilterDescriptor;
        filterFields: FilterFieldInfo[];
    }): void;
    /**
     * Close the filter dialog
     */
    onCloseFilterDialog(): void;
    /**
     * Handle filter applied from dialog - pass back to view config panel
     */
    onFilterApplied(filter: CompositeFilterDescriptor): void;
    /**
     * Handle save view from config panel
     * BUG-001: Panel only closes on success (not on failure)
     * BUG-002: Shows success/error notifications
     * BUG-008: Consistent filter handling for both create and update paths
     */
    onSaveView(event: ViewSaveEvent): Promise<void>;
    /**
     * Handle saving default view settings to user settings
     * Used for dynamic/default views that persist to MJ: User Settings
     */
    onSaveDefaultViewSettings(event: ViewSaveEvent): Promise<void>;
    /**
     * Build GridState in Kendo-compatible format
     * Format: { columnSettings: [...], sortSettings: [...], aggregates: {...} }
     *
     * Priority for column settings:
     * 1. If event.columns provided (from config panel) - use those
     * 2. If currentGridState exists (from grid interactions) - use that
     * 3. Otherwise return null
     */
    private buildGridState;
    /**
     * Build SortState in Kendo-compatible format
     * Format: [{field, direction}] where direction is 'asc' or 'desc'
     * Supports multi-column sorting via sortItems array
     */
    private buildSortState;
    /**
     * Handle delete view from config panel
     */
    onDeleteView(): Promise<void>;
    /**
     * Handle quick save request from view selector (F-001)
     * Builds a summary from the current config panel state and opens the Quick Save dialog
     * @param saveAsNew - true when user explicitly clicked "Save As New"
     */
    onQuickSaveRequested(saveAsNew: boolean): void;
    /**
     * Handle quick save event from Quick Save dialog (F-001)
     * If updating a shared view, intercepts to show the shared view warning first.
     * Otherwise constructs a ViewSaveEvent and delegates to onSaveView.
     */
    onQuickSave(event: QuickSaveEvent): Promise<void>;
    /**
     * Execute the actual quick save (called directly or after shared view warning confirmation)
     */
    private executeQuickSave;
    /**
     * Handle shared view warning dialog action
     */
    onSharedViewAction(action: SharedViewAction): Promise<void>;
    /**
     * Handle shared view warning cancel
     */
    onSharedViewWarningCancel(): void;
    /**
     * Handle quick save dialog close
     */
    onQuickSaveClose(): void;
    /**
     * Handle quick save "Open Advanced" - close dialog and open full config panel
     */
    onQuickSaveOpenAdvanced(event: QuickSaveAdvancedEvent): void;
    /**
     * Handle duplicate view request (F-005)
     * Opens the Duplicate View Dialog so user can choose a name for the copy
     */
    onDuplicateView(viewId?: string): Promise<void>;
    /**
     * Build a ViewConfigSummary from a view entity for the duplicate dialog
     */
    private buildDuplicateSummary;
    /**
     * Handle duplicate dialog confirmation - actually creates the copy
     */
    onDuplicateConfirmed(event: DuplicateViewEvent): Promise<void>;
    /**
     * Handle duplicate dialog cancel
     */
    onDuplicateCancel(): void;
    /**
     * Handle duplicate from config panel (F-005)
     * Duplicates the currently selected view
     */
    onDuplicateFromPanel(): void;
    /**
     * Handle revert view request (F-007)
     * Re-parses the saved view's GridState and resets modified flag
     */
    onRevertView(): Promise<void>;
    /**
     * Handle inline view name change from ViewHeader (F-002)
     * Updates the view entity name and saves immediately
     */
    onViewNameChanged(newName: string): Promise<void>;
    /**
     * Handle view mode toggle from dashboard header
     */
    onViewModeChanged(mode: EntityViewMode): 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 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;
    /**
     * Handle export request - opens the export dialog
     */
    onExport(): Promise<void>;
    /**
     * Handle export dialog close
     */
    onExportDialogClosed(result: ExportDialogResult): void;
    /**
     * Get visible columns for export based on current grid/view state
     */
    private getExportColumns;
    /**
     * Map MemberJunction field types to export column types
     */
    private mapFieldTypeToExportType;
    /**
     * Get the data for export - loads all records for the current view/entity
     */
    protected getExportData(): Promise<ExportData>;
    /**
     * Build the ExtraFilter string based on current view and filter state
     */
    private buildExtraFilter;
    /**
     * Build the OrderBy string based on current view state
     */
    private buildOrderBy;
    /**
     * 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;
    /**
     * Parse URL query string and return a deep link object.
     * Returns null if no relevant params found.
     *
     * Query params:
     * - entity: Selected entity name
     * - record: Selected record ID (URL segment format via CompositeKey)
     * - filter: Current filter text
     * - view: View mode (grid or cards)
     */
    private parseUrlState;
    /**
     * Apply URL state to the component.
     * Used both during init and for popstate handling.
     */
    private applyUrlState;
    /**
     * Emit the current display name based on selected entity/record.
     */
    private emitDisplayName;
    /**
     * Update the URL query string to reflect current navigation state.
     * This enables deep linking - users can bookmark or share URLs to specific views.
     * Called immediately on state changes (not debounced).
     * Uses NavigationService for proper URL management that respects app-scoped routes.
     */
    private updateUrl;
    /**
     * Handle external navigation (back/forward buttons).
     * Parses the URL and applies the state without triggering a new navigation.
     */
    private onExternalNavigation;
    /**
     * Parse URL state from a URL string (used for external navigation).
     */
    private parseUrlFromString;
    /**
     * 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;
    /**
     * Handle selection changes from entity-viewer grid.
     * Tracks selected records to enable the Add to List button in the header toolbar.
     */
    onSelectionChanged(event: {
        records: Record<string, unknown>[];
        recordIds: string[];
    }): void;
    /**
     * Check if there are selected records (for enabling Add to List button)
     */
    get hasSelectedRecords(): boolean;
    /**
     * Handle Add to List button click from header toolbar.
     * Opens the list management dialog for selected records.
     */
    onAddToListClick(): void;
    /**
     * Handle Add to List request from entity-viewer grid toolbar.
     * Opens the list management dialog for multiple selected records.
     */
    onAddToListRequested(event: {
        entityInfo: EntityInfo;
        records: Record<string, unknown>[];
        recordIds: string[];
    }): void;
    /**
     * Open the list management dialog for the currently selected record
     */
    openListManagementDialog(): void;
    /**
     * Handle completion of the list management dialog
     */
    onListManagementComplete(result: ListManagementResult): void;
    /**
     * Handle cancellation of the list management dialog
     */
    onListManagementCancel(): 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; }; }, { "DisplayNameChanged": "DisplayNameChanged"; }, never, never, false, never>;
}
//# sourceMappingURL=data-explorer-dashboard.component.d.ts.map