/**
 * SyntroCanvasOverlay — Lit web component equivalent of ShadowCanvasOverlay.tsx.
 *
 * Composes three child custom elements:
 *   - <syntro-launcher>    FAB button
 *   - <syntro-drawer>      Side panel
 *   - <syntro-toast-stack> Notification toasts
 *
 * Wiring responsibilities:
 *   - Manages open/closed state via isOpen property
 *   - Runs NotifyWatcher loop (equivalent of useNotifyWatcher) to fire
 *     notification events even when the drawer is closed
 *   - Handles notification clicks: publish telemetry events, open canvas,
 *     deep-link, dismiss toast
 *   - Tracks tile viewed telemetry when canvas opens
 *   - Publishes canvas.opened / canvas.closed on each toggle
 *   - Forwards all properties to child elements via Lit bindings
 *
 * Uses light DOM (createRenderRoot returns this) so that host-page CSS
 * variables reach the child elements without piercing shadow boundaries.
 *
 * Decorator-free: uses `static override properties` (tsconfig has no
 * experimentalDecorators).
 */
import { LitElement } from 'lit';
import './SyntroBottomSheet.js';
import type { SmartCanvasRuntime } from '../runtime.js';
import type { TelemetryClient } from '../telemetry/types.js';
import type { TileConfig } from '../types.js';
export declare class SyntroCanvasOverlay extends LitElement {
    static properties: {
        isOpen: {
            type: BooleanConstructor;
        };
        tiles: {
            attribute: boolean;
        };
        isLoading: {
            type: BooleanConstructor;
        };
        error: {
            type: StringConstructor;
        };
        canvasTitle: {
            type: StringConstructor;
        };
        displayMode: {
            type: StringConstructor;
        };
        runtimeRef: {
            attribute: boolean;
        };
        telemetry: {
            attribute: boolean;
        };
        themeConfig: {
            attribute: boolean;
        };
        launcherAnimate: {
            type: BooleanConstructor;
        };
        isMobileMode: {
            attribute: boolean;
        };
    };
    isOpen: boolean;
    tiles: TileConfig[];
    isLoading: boolean;
    error: string | undefined;
    canvasTitle: string | undefined;
    displayMode: 'standard' | 'focused';
    runtimeRef: SmartCanvasRuntime | null;
    telemetry: TelemetryClient | null;
    themeConfig: Record<string, any>;
    launcherAnimate: boolean;
    /** Tracks ``runtime.context.surface.mode === 'mobile'`` so the
     *  template can switch between ``<syntro-drawer>`` and
     *  ``<syntro-bottom-sheet>``. Agent surfaces are handled at a higher
     *  level by ``SmartCanvasElementLit`` (which renders inline-shell
     *  before this overlay ever mounts), so this overlay only ever runs
     *  on web — mobile vs desktop is the only branch it needs. */
    isMobileMode: boolean;
    private _notifications;
    private _surfaceUnsub;
    private _toggleCooldown;
    private _toggleCooldownTimer;
    /** Prev-state map: entry.id → last evaluated boolean */
    private _notifyPrevState;
    /** Unsubscribe for the EventBus notify-watcher subscription */
    private _notifyUnsub;
    /** Unsubscribe for the sessionMetrics notify-watcher subscription */
    private _notifyUnsubMetrics;
    constructor();
    createRenderRoot(): this;
    connectedCallback(): void;
    disconnectedCallback(): void;
    private _subscribeSurface;
    updated(changed: Map<string, unknown>): void;
    private _syncNotificationsController;
    private _startNotifyWatcher;
    private _stopNotifyWatcher;
    private _restartNotifyWatcher;
    private _trackTilesViewed;
    private get _resolvedThemeConfig();
    private _surfaceMeta;
    private _toggle;
    private _handleNotificationClick;
    private _handleNotificationDismiss;
    previewNotification(opts: {
        title: string;
        body?: string;
        icon?: string;
        ttl?: number;
    }): void;
    private _onLauncherToggle;
    private _onDrawerClose;
    render(): import("lit-html").TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'syntro-canvas-overlay': SyntroCanvasOverlay;
    }
}
