import { AfterViewInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
import { BaseDashboard } from '@memberjunction/ng-shared';
import { ResourceData } from '@memberjunction/core-entities';
import * as i0 from "@angular/core";
interface CommunicationDashboardState {
    activeTab: string;
}
export declare class CommunicationDashboardComponent extends BaseDashboard implements AfterViewInit, OnDestroy {
    private cdr;
    isLoading: boolean;
    isRefreshing: boolean;
    activeTab: string;
    selectedIndex: number;
    private visitedTabs;
    navigationItems: string[];
    private stateChangeSubject;
    private selectedLog;
    private selectedProvider;
    private selectedTemplate;
    private selectedRun;
    private logsChild?;
    private providersChild?;
    private templatesChild?;
    private runsChild?;
    private monitorChild?;
    constructor(cdr: ChangeDetectorRef);
    GetResourceDisplayName(data: ResourceData): Promise<string>;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onTabChange(tabId: string): void;
    hasVisited(tabId: string): boolean;
    onRefresh(): void;
    private setupStateManagement;
    private emitStateChange;
    loadUserState(state: Partial<CommunicationDashboardState>): void;
    initDashboard(): void;
    loadData(): void;
    getCurrentTabLabel(): string;
    /**
     * Publish the current Communication dashboard state to the AI agent via
     * NavigationService, then re-scope the tool set to the active tab. Re-invoked on
     * every meaningful state change (tab switch, refresh start/end, agent filter/select
     * action, and a tick after a tab mounts) so the agent always sees a fresh, read-only
     * snapshot. Only the ACTIVE surface's deep state is harvested — context is mode-scoped
     * to whatever tab is open, mirroring the Data Explorer pattern.
     */
    private publishAgentContext;
    /**
     * Harvest the deep, per-surface state slice for the ACTIVE tab from whichever child
     * resource component is mounted. Returns `{ Surface: 'none' }` when the active tab's
     * child isn't available (settings tab, or a tab restored from saved state whose
     * content hasn't loaded yet) — so context truthfully reports "not loaded" rather than
     * fabricating zeros.
     */
    private harvestActiveSurface;
    private harvestMonitorSurface;
    private harvestLogsSurface;
    private harvestProvidersSurface;
    private harvestTemplatesSurface;
    private harvestRunsSurface;
    /** The display label the runs timeline shows for a run ("Run #<short-id>"). */
    private runDisplayName;
    /**
     * The on-screen display summary for a log row ("<provider> · <type> · <status>"),
     * used both for context publishing and for name-based resolution by the agent's
     * Select/Open log tools — so the agent can refer to a row exactly as it's described
     * in context.
     */
    private logDisplayName;
    /** id+name candidates for the visible (filtered) log rows. Empty when the Logs tab isn't mounted. */
    private logCandidates;
    /**
     * Tracks which tool set was last registered, so the mode-scoped re-registration
     * ({@link syncAgentToolsForMode}) only fires on a tab transition rather than on
     * every state change.
     */
    private lastRegisteredToolMode;
    /**
     * Re-scope the agent's client tools to the ACTIVE tab. Each surface exposes a
     * different set of affordances (logs filter by status + search + select/open a log;
     * templates filter by category + search + select/open a template; providers select/
     * open a provider; runs select/open a run; monitor is read-only), so a logs-only tool
     * is never exposed while the Providers tab is open and vice-versa. The COMMON tools
     * (switch tab, refresh) are always present. Because {@link publishAgentContext} fires
     * on every state change but the tool set only changes on the tab flip, this guards on
     * {@link lastRegisteredToolMode} and only calls into NavigationService when the active
     * tab actually changes.
     */
    private syncAgentToolsForMode;
    /**
     * Register the navigational / read-only client tools the agent may invoke. Called
     * once on mount; {@link syncAgentToolsForMode} re-registers the surface-scoped slice
     * on every tab change. See the SAFETY BOUNDARY comment above for the operations
     * intentionally NOT exposed.
     */
    private registerAgentClientTools;
    private buildAgentTool;
    /** COMMON tools — available on EVERY tab (switch tab + refresh). */
    private buildCommonTools;
    /** The surface-scoped tool slice for the active tab. */
    private buildSurfaceTools;
    private buildLogsTools;
    private buildProvidersTools;
    private buildTemplatesTools;
    private buildRunsTools;
    private handleSwitchTabTool;
    private handleFilterLogsTool;
    private handleSearchLogsTool;
    private handleSelectLogTool;
    private handleOpenLogTool;
    private handleSelectProviderTool;
    private handleOpenProviderTool;
    private handleFilterTemplatesTool;
    private handleSearchTemplatesTool;
    private handleSelectTemplateTool;
    private handleOpenTemplateTool;
    private handleSelectRunTool;
    private handleOpenRunTool;
    static ɵfac: i0.ɵɵFactoryDeclaration<CommunicationDashboardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CommunicationDashboardComponent, "mj-communication-dashboard", never, {}, {}, never, never, false, never>;
}
export {};
//# sourceMappingURL=communication-dashboard.component.d.ts.map