/**
 * SmartCanvasElementLit — LitElement shell for the Smart Canvas SDK.
 *
 *   - Config fetching
 *   - Action lifecycle (batch handle, revert/apply, version counter)
 *   - Theme via ThemeController
 *   - Canvas open/close via SmartCanvasController
 *   - Runtime context via @lit/context
 *
 * Renders <syntro-canvas-overlay> as its main child (Lit component).
 *
 * Decorator-free: uses `static override properties` (tsconfig has no
 * experimentalDecorators).
 */
import { LitElement, nothing } from 'lit';
import type { BatchActionHandle } from './actions/types.js';
import './components/SyntroCanvasOverlay.js';
import './components/SyntroInlineShell.js';
import { type SmartCanvasController } from './controller.js';
import type { ExperimentClient } from './experiments/types.js';
import type { SmartCanvasRuntime } from './runtime.js';
import type { TelemetryClient } from './telemetry/types.js';
import type { ActionStep, CanvasConfigFetcher, CanvasThemeConfig, LauncherConfig, TileConfig } from './types.js';
export declare const runtimeContext: {
    __context__: SmartCanvasRuntime | null;
};
/**
 * Props accepted by mountLitApp(). Mirrors SmartCanvasAppProps minus controller
 * (the element owns the controller) and footerSlot/canvasHost (React-only).
 */
export interface SmartCanvasLitProps {
    fetcher?: CanvasConfigFetcher;
    configUri?: string;
    configUriFeatureKey?: string;
    configFeatureKey?: string;
    fetchCredentials?: RequestCredentials;
    experiments?: ExperimentClient;
    telemetry?: TelemetryClient;
    runtime?: SmartCanvasRuntime;
    launcherLabel?: string;
    initialBatchHandle?: BatchActionHandle | null;
    /**
     * The actions that produced `initialBatchHandle`. Seeded into the
     * element's `_configActions` and the JSON diff guard so that:
     *   - A matching first fetch is a no-op (preserves anti-flicker)
     *   - A divergent first fetch triggers the normal revert+apply path
     *   - Subsequent lifecycle triggers (pageUrl change, etc.) re-apply
     *     the eager actions against the new state instead of clearing DOM
     */
    initialBatchActions?: ActionStep[];
    workspaceTheme?: CanvasThemeConfig;
}
export declare class SmartCanvasElementLit extends LitElement {
    #private;
    static shadowRootOptions: ShadowRootInit;
    static styles: import("lit").CSSResult;
    static properties: {
        fetcher: {
            attribute: boolean;
        };
        configUri: {
            type: StringConstructor;
        };
        configUriFeatureKey: {
            type: StringConstructor;
        };
        configFeatureKey: {
            type: StringConstructor;
        };
        fetchCredentials: {
            type: StringConstructor;
        };
        experiments: {
            attribute: boolean;
        };
        telemetry: {
            attribute: boolean;
        };
        runtime: {
            attribute: boolean;
        };
        launcherLabel: {
            type: StringConstructor;
        };
        initialBatchHandle: {
            attribute: boolean;
        };
        initialBatchActions: {
            attribute: boolean;
        };
        workspaceTheme: {
            attribute: boolean;
        };
        _tiles: {
            state: boolean;
        };
        _configActions: {
            state: boolean;
        };
        _isLoading: {
            state: boolean;
        };
        _error: {
            state: boolean;
        };
        _theme: {
            state: boolean;
        };
        _launcher: {
            state: boolean;
        };
        _canvasTitle: {
            state: boolean;
        };
        _displayMode: {
            state: boolean;
        };
        _isOpen: {
            state: boolean;
        };
        _pageUrl: {
            state: boolean;
        };
    };
    fetcher: CanvasConfigFetcher | undefined;
    configUri: string | undefined;
    configUriFeatureKey: string | undefined;
    configFeatureKey: string | undefined;
    fetchCredentials: RequestCredentials;
    experiments: ExperimentClient | undefined;
    telemetry: TelemetryClient | undefined;
    runtime: SmartCanvasRuntime | undefined;
    launcherLabel: string | undefined;
    initialBatchHandle: BatchActionHandle | null;
    initialBatchActions: ActionStep[] | undefined;
    workspaceTheme: CanvasThemeConfig | undefined;
    /** @internal */ _tiles: TileConfig[];
    /** @internal */ _configActions: ActionStep[];
    /** @internal */ _isLoading: boolean;
    /** @internal */ _error: string | undefined;
    /** @internal */ _theme: CanvasThemeConfig | undefined;
    /** @internal */ _launcher: LauncherConfig | undefined;
    /** @internal */ _canvasTitle: string | undefined;
    /** @internal */ _displayMode: 'standard' | 'focused' | 'inline';
    /** @internal */ _isOpen: boolean;
    /** @internal */ _pageUrl: string;
    constructor();
    connectedCallback(): void;
    disconnectedCallback(): void;
    updated(changed: Map<string, unknown>): void;
    render(): import("lit-html").TemplateResult<1> | typeof nothing;
    open(): void;
    close(): void;
    toggle(): void;
    setOverrideFetcher(fetcher: CanvasConfigFetcher): void;
    getMountNode(): HTMLElement;
    getController(): SmartCanvasController;
    /** React portal target inside shadow root (launcher, drawer, toasts) */
    getPortalRoot(): HTMLDivElement | null;
    /** Vanilla JS overlay container inside shadow root (tooltips, modals, spotlights) */
    getOverlayContainer(): HTMLDivElement | null;
    /** Direct access to the shadow root (for style injection) */
    getShadowRoot(): ShadowRoot;
    previewNotification(opts: {
        title: string;
        body?: string;
        icon?: string;
        ttl?: number;
    }): void;
    /**
     * Set properties directly on the element. The Lit property change triggers
     * re-render and re-fetch without React.
     */
    mountLitApp(props: SmartCanvasLitProps): void;
    _loadConfig({ silent }?: {
        silent?: boolean;
    }): Promise<void>;
}
export declare const registerSmartCanvasElement: () => void;
