@gengage/assistant-fe 0.5.7 → 0.6.0

package/dist/chat/components/PhotoAnalysisCard.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Structured photo analysis card — rendered inline in the chat message stream.
+ *
+ * The backend sends a `PhotoAnalysisCard` UISpec with skin/beauty analysis
+ * findings. This component renders them as a visually distinct card so the
+ * user can scan the highlights quickly.
+ */
+import type { UIElement } from '../../common/types.js';
+import type { ChatUISpecRenderContext } from '../types.js';
+export interface PhotoAnalysisData {
+    summary: string;
+    strengths?: string[];
+    focusPoints?: string[];
+    celebStyle?: string;
+    celebStyleReason?: string;
+    nextQuestion?: string;
+}
+/** Extract structured photo-analysis data from a UISpec element's props. */
+export declare function parsePhotoAnalysisProps(props: Record<string, unknown>): PhotoAnalysisData | null;
+export declare function renderPhotoAnalysisCard(element: UIElement, ctx: ChatUISpecRenderContext): HTMLElement;
+/** Renders the structured PhotoAnalysisCard data captured from the UISpec. */
+export declare function renderPhotoAnalysisBubble(container: HTMLElement, labels: {
+    badge: string;
+    strengths: string;
+    focus: string;
+    celebStyle: string;
+}, structured?: PhotoAnalysisData): void;

package/dist/chat/components/ProductSummaryCard.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Compact horizontal product card for inline chat-pane rendering.
+ *
+ * Production parity: mirrors the prior engine's `LaunchSingleProduct` component.
+ * Renders when `productDetails` arrives — the full ProductDetailsPanel goes
+ * to the left panel while this compact summary appears inline in chat messages.
+ *
+ * Layout: [image 64×64] [name · rating · price] [View link]
+ */
+import type { UIElement } from '../../common/types.js';
+import type { ChatUISpecRenderContext } from '../types.js';
+export declare function renderProductSummaryCard(element: UIElement, ctx: ChatUISpecRenderContext): HTMLElement;

package/dist/chat/components/ProsAndCons.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Renders a Pros & Cons list for a product.
+ *
+ * XSS safety: All text is set via textContent. No innerHTML.
+ */
+export declare function renderProsAndCons(element: {
+    props?: Record<string, unknown>;
+}): HTMLElement;

package/dist/chat/components/ReviewHighlights.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ReviewHighlights — subject-first review intelligence panel.
+ *
+ * Subjects are neutral topics (e.g., "Build quality").
+ * Sentiment is represented by per-subject positive/negative mention counts.
+ * Clicking a subject shows short snippets, not full review bodies.
+ */
+import type { UIElement } from '../../common/types.js';
+export declare function renderReviewHighlights(element: UIElement, options?: {
+    emptyReviewsMessage?: string | undefined;
+    reviewFilterPositive?: string | undefined;
+    reviewFilterNegative?: string | undefined;
+    reviewCustomersMentionSingular?: string | undefined;
+    reviewCustomersMentionPlural?: string | undefined;
+    reviewSubjectsHeading?: string | undefined;
+}): HTMLElement;

package/dist/chat/components/actionClassifier.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Classifies suggested actions into input-area chips vs message-flow pills.
+ *
+ * Input-area chips: compact shortcuts above the input field (search, info, review, similar).
+ * Message-flow pills: larger interactive cards in the suggestion row.
+ */
+export declare function isInputAreaAction(btn: {
+    icon?: string;
+    action?: {
+        type?: string;
+    };
+}): boolean;

package/dist/chat/components/product-price-layout.d.ts

@@ -0,0 +1,17 @@
+import type { ChatUISpecRenderContext, ProductPriceOriginalStyle } from '../types.js';
+export declare function campaignReasonForDisplay(ctx: ChatUISpecRenderContext, product: Record<string, unknown> | undefined): string | undefined;
+/**
+ * Per-product `originalPriceStyle` / `price_original_style` override config.
+ * Default `strikethrough`; `inline` uses a separator row without a strike line.
+ */
+export declare function resolveOriginalPriceStyle(ctx: ChatUISpecRenderContext, product: Record<string, unknown> | undefined): ProductPriceOriginalStyle;
+export declare function createCampaignReasonElement(text: string): HTMLDivElement;
+export declare function resolveCampaignBadgeLogoUrl(ctx: ChatUISpecRenderContext, product: Record<string, unknown> | undefined): string | undefined;
+/**
+ * Single bordered badge: optional logo, campaign line (body text), sale price — gradient border, transparent fill.
+ */
+export declare function createCampaignPriceBadge(options: {
+    reasonText: string;
+    salePriceFormatted: string;
+    logoUrl?: string;
+}): HTMLElement;

package/dist/chat/components/productMentionLinker.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Product mention linker.
+ *
+ * After sanitiseHtml() renders bot text, this module walks text nodes and
+ * wraps product name occurrences with clickable links that dispatch a
+ * `launchSingleProduct` action.
+ *
+ * XSS safety: Uses DOM text-node manipulation only — no innerHTML.
+ */
+interface ProductMention {
+    sku: string;
+    short_name: string;
+}
+export interface ProductMentionLinkerOptions {
+    container: HTMLElement;
+    mentions: ProductMention[];
+    onProductClick: (sku: string) => void;
+}
+/**
+ * Walk text nodes in `container` and wrap occurrences of each mention's
+ * `short_name` with a clickable `<a>` element.
+ *
+ * Only the first occurrence of each mention is linked to avoid visual clutter.
+ */
+export declare function linkProductMentions(options: ProductMentionLinkerOptions): void;
+export {};

package/dist/chat/components/renderUISpec.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Renders a json-render UISpec into DOM elements.
+ *
+ * XSS safety: All text is set via textContent. URLs are validated for safe protocols.
+ * No innerHTML is used anywhere in this module.
+ */
+import type { UISpec, UIElement } from '../../common/types.js';
+import type { UISpecDomRegistry, UISpecDomUnknownRenderer } from '../../common/renderer/index.js';
+import type { ChatUISpecRenderContext } from '../types.js';
+export type UISpecRenderContext = ChatUISpecRenderContext;
+export type ChatUISpecRegistry = UISpecDomRegistry<UISpecRenderContext>;
+export declare const defaultChatUnknownUISpecRenderer: UISpecDomUnknownRenderer<UISpecRenderContext>;
+export declare function createDefaultChatUISpecRegistry(): ChatUISpecRegistry;
+export declare function renderUISpec(spec: UISpec, ctx: UISpecRenderContext, registry?: ChatUISpecRegistry, unknownRenderer?: UISpecDomUnknownRenderer<UISpecRenderContext>): HTMLElement;
+export declare function renderProductCard(element: UIElement, ctx: UISpecRenderContext): HTMLElement;

package/dist/chat/components/typewriter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Block-by-block HTML typewriter effect.
+ *
+ * Parses sanitised HTML into top-level blocks and reveals them one at a time
+ * with a configurable stagger delay. Respects prefers-reduced-motion.
+ */
+export interface TypewriterOptions {
+    container: HTMLElement;
+    html: string;
+    /** Delay in ms between block reveals (default: 30). */
+    delayMs?: number;
+    /** Called after each block is revealed — useful for scroll tracking. */
+    onTick?: () => void;
+    /** Called when all blocks have been revealed. */
+    onComplete?: () => void;
+}
+export interface TypewriterHandle {
+    /** Skip animation and show all content immediately. */
+    complete(): void;
+    /** Cancel animation, leave content as-is. */
+    cancel(): void;
+    readonly isRunning: boolean;
+}
+export declare function typewriteHtml(options: TypewriterOptions): TypewriterHandle;

package/dist/chat/extendedModeManager.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Extended Mode Manager — production lock-count system for panel extension.
+ *
+ * Controls whether the host page PDP area should be maximized or minimized
+ * based on a combination of conditions: lock count, user visibility preference,
+ * favorites mode, panel content type, and chat visibility.
+ */
+export type PanelContentType = 'comparisonTable' | 'groupList' | 'productDetails' | 'productDetailsSimilars' | 'productList';
+export interface ExtendedModeManagerOptions {
+    onChange: (extended: boolean) => void;
+    /** Whether `productDetails` should trigger panel extension (default: false, true for demo sites). */
+    productDetailsInPanel?: boolean;
+}
+export declare class ExtendedModeManager {
+    private _lockCount;
+    private _hiddenByUser;
+    private _lastPanelContentType;
+    private _chatShown;
+    private _isFavoritesMode;
+    private _lastExtended;
+    private _onChange;
+    private _panelContentTypes;
+    constructor(options: ExtendedModeManagerOptions);
+    get isExtended(): boolean;
+    unlock(): void;
+    lock(): void;
+    setHiddenByUser(hidden: boolean): void;
+    setChatShown(shown: boolean): void;
+    setFavoritesMode(fav: boolean): void;
+    setPanelContentType(type: PanelContentType | null): void;
+    private _checkStateChange;
+}

package/dist/chat/features/beauty-consulting/consulting-grid.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Consulting-aware ProductGrid helper — determines whether a ProductGrid
+ * should render as a consulting style picker instead of a standard grid.
+ *
+ * Extracted from renderProductGrid() in renderUISpec.ts so the generic
+ * grid renderer doesn't contain mode-specific branching inline.
+ */
+import type { UIElement } from '../../../common/types.js';
+import type { ChatUISpecRenderContext } from '../../types.js';
+import type { StyleVariation } from '../../components/ConsultingStylePicker.js';
+export interface ConsultingGridResult {
+    isConsulting: boolean;
+    source: string | undefined;
+    styleVariations: StyleVariation[];
+}
+/**
+ * Check whether a ProductGrid element should render as a consulting style picker.
+ * Returns the check result plus pre-parsed data for {@link renderConsultingGrid}.
+ */
+export declare function detectConsultingGrid(element: UIElement): ConsultingGridResult;
+/**
+ * Render a consulting style picker into the ProductGrid wrapper.
+ * Call only when `detectConsultingGrid` returned `isConsulting: true`.
+ */
+export declare function renderConsultingGrid(wrapper: HTMLElement, grid: HTMLElement, detected: ConsultingGridResult, ctx?: ChatUISpecRenderContext): void;
+/**
+ * Whether at least one variation is not actively `loading`, so the panel can
+ * paint the first ready style immediately (fast-first). Remaining `loading`
+ * tabs stream in and update in place via {@link patchConsultingGridDom} without
+ * replacing the whole panel.
+ */
+export declare function isConsultingGridReady(detected: ConsultingGridResult): boolean;
+/**
+ * Apply a streaming consulting ProductGrid update to the visible panel without
+ * `setPanelContent` (avoids full DOM swap / blink). Returns false if the
+ * panel is not currently showing a consulting picker.
+ */
+export declare function patchConsultingGridDom(wrapper: HTMLElement, detected: ConsultingGridResult, ctx?: ChatUISpecRenderContext): boolean;

package/dist/chat/features/beauty-consulting/drawer-extensions.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Beauty consulting drawer extensions — DOM helpers for beauty-specific
+ * elements in the chat drawer.
+ *
+ * Extracted from ChatDrawer so the 2,700-line drawer file doesn't grow
+ * with each new consulting mode.
+ */
+import type { ChatI18n } from '../../types.js';
+export interface BeautyPhotoStepCardOptions {
+    visible: boolean;
+    processing?: boolean;
+    onSkip?: (() => void) | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    uploadLabel?: string | undefined;
+    skipLabel?: string | undefined;
+}
+/**
+ * Show or hide the beauty photo step card.
+ * Returns the slot element (possibly newly created).
+ */
+export declare function applyBeautyPhotoStepCard(slotEl: HTMLElement | null, conversationEl: HTMLElement | null, options: BeautyPhotoStepCardOptions, i18n: ChatI18n, openAttachmentPicker: () => void): HTMLElement | null;

package/dist/chat/features/beauty-consulting/mode-controller.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Assistant mode controller — encapsulates mode state and UI hints.
+ *
+ * Extracted from GengageChat (index.ts) so the 3,900-line widget file
+ * stays focused on stream orchestration and drawer coordination.
+ */
+import type { AssistantMode } from '../../assistant-mode.js';
+/**
+ * Minimal drawer interface consumed by the mode controller.
+ * Keeps the controller decoupled from ChatDrawer internals.
+ */
+export interface ModeDrawerAdapter {
+    setAttachmentControlsVisible(visible: boolean): void;
+    setInputPlaceholder(text: string): void;
+    setBeautyPhotoStepCard(options: {
+        visible: boolean;
+    }): void;
+}
+export declare class AssistantModeController {
+    private _mode;
+    private _uiHints;
+    get mode(): AssistantMode;
+    set mode(value: AssistantMode);
+    get uiHints(): Record<string, unknown> | null;
+    set uiHints(value: Record<string, unknown> | null);
+    get isShopping(): boolean;
+    get isBeautyConsulting(): boolean;
+    /** Whether choice prompter is hidden by backend ui_hints. */
+    get isChoicePrompterHidden(): boolean;
+    /**
+     * Apply backend ui_hints to the drawer.
+     *
+     * @param drawer  Drawer adapter (null when drawer not yet created).
+     * @param defaultPlaceholder  Default input placeholder for shopping mode.
+     * @param removePersistentChoicePrompter  Callback to remove persistent choice prompter from Shadow DOM.
+     */
+    applyUiHints(drawer: ModeDrawerAdapter | null, defaultPlaceholder: string, removePersistentChoicePrompter?: () => void): void;
+    /**
+     * Handle redirect metadata from a backend metadata event.
+     * Returns true if the mode actually switched.
+     */
+    handleRedirect(redirectPayload: unknown): boolean;
+    /** Switch to a new assistant mode. */
+    switchMode(mode: AssistantMode): void;
+    /**
+     * Derive mode and ui_hints from a backend CONTEXT panel payload.
+     * Missing `assistant_mode` field preserves current mode (old backends).
+     * Explicit `null` resets to shopping.
+     */
+    updateFromContext(panel: Record<string, unknown>): void;
+    /**
+     * Reset to shopping mode. Returns true if mode was non-shopping before reset.
+     */
+    reset(): boolean;
+    /** Resolve attachment action type based on current mode. */
+    resolveAttachmentActionType(): 'user_message' | 'findSimilar';
+    /** Non-shopping modes condense thinking step lists. */
+    shouldCondenseThinking(): boolean;
+}

package/dist/chat/features/beauty-consulting/registry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Beauty consulting UISpec component registry entries.
+ *
+ * Spread into the default chat UISpec registry so central renderUISpec.ts
+ * only has a one-line integration point.
+ */
+import type { UISpecDomRegistry } from '../../../common/renderer/index.js';
+import type { ChatUISpecRenderContext } from '../../types.js';
+export declare const beautyConsultingRegistry: Partial<UISpecDomRegistry<ChatUISpecRenderContext>>;

package/dist/chat/features/beauty-consulting/stream-handler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Beauty consulting stream handler — intercepts beauty-specific UISpec
+ * components during NDJSON stream processing.
+ *
+ * Extracted from GengageChat._startStream() so index.ts only has thin
+ * delegation calls for beauty-specific stream events.
+ */
+import type { PhotoAnalysisData } from '../../components/PhotoAnalysisCard.js';
+import type { ChatMessage } from '../../types.js';
+/** Per-stream state for beauty consulting features. */
+export interface BeautyStreamState {
+    streamIncludedBeautyPhotoStep: boolean;
+    pendingPhotoStepSkip: boolean;
+}
+export declare function createBeautyStreamState(): BeautyStreamState;
+/** Callbacks needed by the beauty stream handler. */
+export interface BeautyStreamContext {
+    drawer: {
+        updateBotMessage(messageId: string, html: string, renderHint?: string, photoAnalysis?: PhotoAnalysisData): void;
+        setBeautyPhotoStepCard(options: {
+            visible: boolean;
+            processing?: boolean;
+            onSkip?: (() => void) | undefined;
+            title?: string | undefined;
+            description?: string | undefined;
+            uploadLabel?: string | undefined;
+            skipLabel?: string | undefined;
+        }): void;
+    } | null;
+    ensureRendered: () => void;
+    cancelTypewriter: () => void;
+    sendSkipMessage: () => void;
+    streamDone: boolean;
+}
+/**
+ * Handle a beauty-specific UISpec component during stream processing.
+ * Returns true if the component was handled (caller should `return`).
+ */
+export declare function handleBeautyUISpec(componentType: string, rootElementProps: Record<string, unknown>, state: BeautyStreamState, ctx: BeautyStreamContext, botMsg: ChatMessage): boolean;
+/** Returns true if the bot message should render as a photo analysis card. */
+export declare function isPhotoAnalysisMessage(botMsg: ChatMessage): boolean;
+/** Flush pending beauty photo step state on stream complete. */
+export declare function flushBeautyStreamComplete(state: BeautyStreamState, ctx: BeautyStreamContext): void;
+/** Flush pending beauty photo step skip on stream error. */
+export declare function flushBeautyStreamError(state: BeautyStreamState, ctx: BeautyStreamContext): void;

package/dist/chat/history-storage.d.ts

@@ -0,0 +1,85 @@
+import type { BackendContext, UISpec } from '../common/types.js';
+import type { ChatMessage } from './types.js';
+type LegacyThumbnailEntry = {
+    sku: string;
+    imageUrl: string;
+    threadId: string;
+};
+interface StoredHistoryMessage {
+    id: string;
+    threadId?: string | undefined;
+    role: 'user' | 'assistant';
+    content?: string | undefined;
+    uiSpec?: UISpec | undefined;
+    frontendOnly?: boolean | undefined;
+    silent?: boolean | undefined;
+    renderHint?: string | undefined;
+    photoAnalysis?: {
+        summary: string;
+        strengths?: string[];
+        focusPoints?: string[];
+        celebStyle?: string;
+        celebStyleReason?: string;
+        nextQuestion?: string;
+    } | undefined;
+    timestamp: number;
+    status: 'done' | 'error';
+}
+export interface ChatHistoryIndexEntry {
+    id: string;
+    title: string;
+    preview: string;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+    pageType?: string | undefined;
+    sku?: string | undefined;
+    sourceSessionId: string;
+}
+export interface ChatHistorySessionRecord extends ChatHistoryIndexEntry {
+    version: number;
+    userId: string;
+    appId: string;
+    messages: StoredHistoryMessage[];
+    currentThreadId: string | null;
+    lastThreadId: string | null;
+    panelThreads?: string[] | undefined;
+    /** Legacy thumbnail-strip data kept optional for backward compatibility with older local history. */
+    thumbnailEntries?: LegacyThumbnailEntry[] | undefined;
+    panelSnapshotHtml?: Record<string, string> | undefined;
+    panelSnapshotTypes?: Record<string, string> | undefined;
+    panelAiSpecByThread?: Record<string, UISpec> | undefined;
+    lastBackendContext: BackendContext | null;
+}
+export interface SaveHistorySessionParams {
+    historyId: string;
+    userId: string;
+    appId: string;
+    sourceSessionId: string;
+    messages: ChatMessage[];
+    currentThreadId: string | null;
+    lastThreadId: string | null;
+    chatCreatedAt: string;
+    panelSnapshots: Map<string, HTMLElement>;
+    panelSnapshotTypes: Map<string, string>;
+    panelThreads: string[];
+    panelAiSpecByThread?: Map<string, UISpec> | undefined;
+    lastBackendContext: BackendContext | null;
+    pageType?: string | undefined;
+    sku?: string | undefined;
+}
+export declare class ChatHistoryStorage {
+    private readonly _appId;
+    private readonly _userId;
+    private readonly _storage;
+    private readonly _scope;
+    constructor(_appId: string, _userId: string, _storage?: Storage | null);
+    createHistoryId(): string;
+    findSessionId(sourceSessionId: string, createdAt: string): string | null;
+    listSessions(): ChatHistoryIndexEntry[];
+    loadSession(historyId: string): ChatHistorySessionRecord | null;
+    saveSession(params: SaveHistorySessionParams): ChatHistorySessionRecord | null;
+    deleteSession(historyId: string): void;
+    private _commitRecord;
+}
+export {};

package/dist/chat/index.d.ts

@@ -0,0 +1,6 @@
+export * from './runtime.js';
+export { chatCatalog } from './catalog.js';
+export type { ChatCatalog, ChatComponentName } from './catalog.js';
+export { createFloatingLauncher } from './components/FloatingLauncher.js';
+export type { FloatingLauncherOptions } from './components/FloatingLauncher.js';
+export type { ActionEnrichmentContext, BackendRequestMeta, InjectorAdapter, ProcessActionRequest, StreamCallbacks, } from '../common/transport.js';

package/dist/chat/kvkk.d.ts

@@ -0,0 +1,20 @@
+/**
+ * KVKK notice filtering and caching helpers.
+ *
+ * KVKK (Kişisel Verilerin Korunması Kanunu) is Turkey's data protection law.
+ * When the backend streams a response containing a KVKK notice, we:
+ * 1. Strip the KVKK block from the visible bot text
+ * 2. Show a banner on first encounter (per account)
+ * 3. Mark it as shown in localStorage to avoid repeat banners
+ */
+export declare function containsKvkk(html: string): boolean;
+export declare function isKvkkShown(accountId: string): boolean;
+export declare function markKvkkShown(accountId: string): void;
+/**
+ * Strip the KVKK portion from bot HTML.
+ * KVKK is typically wrapped in a `<div style="...">` at the start.
+ * We remove the first block-level element that contains a KVKK marker.
+ */
+export declare function stripKvkkBlock(html: string): string;
+export declare function extractKvkkBlock(html: string): string | null;
+export declare function localeToOutputLanguage(locale?: string): string;

package/dist/chat/locales/en.d.ts

@@ -0,0 +1,2 @@
+import type { ChatI18n } from '../types.js';
+export declare const CHAT_I18N_EN: ChatI18n;

package/dist/chat/locales/index.d.ts

@@ -0,0 +1,5 @@
+import type { ChatI18n } from '../types.js';
+import { CHAT_I18N_TR } from './tr.js';
+import { CHAT_I18N_EN } from './en.js';
+export declare function resolveChatLocale(locale?: string): ChatI18n;
+export { CHAT_I18N_TR, CHAT_I18N_EN };

package/dist/chat/locales/tr.d.ts

@@ -0,0 +1,2 @@
+import type { ChatI18n } from '../types.js';
+export declare const CHAT_I18N_TR: ChatI18n;

package/dist/chat/panel-manager.d.ts

@@ -0,0 +1,142 @@
+/**
+ * PanelManager — manages the two-pane panel state for the chat widget.
+ *
+ * Owns panel snapshots, snapshot types, active message highlighting,
+ * panel thread navigation, topbar updates, and extended mode coordination.
+ *
+ * Extracted from chat/index.ts to improve cohesion and reduce file size.
+ */
+import type { ChatDrawer } from './components/ChatDrawer.js';
+import type { CommunicationBridge } from '../common/communication-bridge.js';
+import type { ExtendedModeManager } from './extendedModeManager.js';
+import type { ChatI18n } from './types.js';
+import type { UISpec } from '../common/types.js';
+/** Minimal interface the panel manager needs from its host widget. */
+export interface PanelManagerDeps {
+    drawer: () => ChatDrawer | null;
+    shadow: () => ShadowRoot | null;
+    currentThreadId: () => string | null;
+    bridge: () => CommunicationBridge | null;
+    extendedModeManager: () => ExtendedModeManager | null;
+    i18n: () => ChatI18n;
+    rollbackToThread: (threadId: string) => void;
+}
+/**
+ * Rebuild source for local drilldown history and stream-end snapshots.
+ * `productDetailsWithSimilars` keeps PDP + appended similar grid in sync when
+ * similars arrive in a second stream chunk (DOM append does not update `spec` alone).
+ */
+export type PanelSource = {
+    kind: 'spec';
+    spec: UISpec;
+} | {
+    kind: 'productDetailsWithSimilars';
+    pdpSpec: UISpec;
+    similarsSpec: UISpec;
+} | {
+    kind: 'favorites';
+} | {
+    kind: 'history';
+};
+export type PanelSnapshotOptions = {
+    rebuild?: (() => HTMLElement) | undefined;
+    source?: PanelSource | undefined;
+    threadId?: string | undefined;
+};
+export declare class PanelManager {
+    private readonly deps;
+    /** Panel content snapshots keyed by bot message ID for history navigation. */
+    readonly snapshots: Map<string, HTMLElement>;
+    /** Rebuild functions keyed by message ID — produce fresh DOM with live event listeners. */
+    private readonly _snapshotRebuilders;
+    private readonly _snapshotSources;
+    private readonly _threadSources;
+    /** Component type for each panel snapshot (for topbar title restoration). */
+    readonly snapshotTypes: Map<string, string>;
+    /** Currently active (highlighted) message ID in the chat pane. */
+    activePanelMessageId: string | null;
+    /** Current panel component type. */
+    currentType: string | null;
+    /** Thread IDs that have panel content, in order of creation. */
+    threads: string[];
+    /** Action type that triggered the current stream (for panel title disambiguation). */
+    lastActionType: string | null;
+    constructor(deps: PanelManagerDeps);
+    /**
+     * Panel nav lists threads that received panel content; the conversation cursor may be
+     * newer (`indexOf` === -1). Anchor to the newest listed thread at/before the cursor.
+     * UUIDv7 ids sort chronologically as strings.
+     */
+    private _resolvePanelHistoryIdx;
+    clearSnapshots(): void;
+    deleteSnapshotForMessage(messageId: string): void;
+    pruneThreadsAfter(threadId: string): void;
+    sourceForMessage(messageId: string): PanelSource | null;
+    sourceForThread(threadId: string): PanelSource | null;
+    componentTypeForSource(source: PanelSource): string;
+    /**
+     * Snapshot the current panel state for a message. Stores a rebuild function
+     * (preferred — produces fresh DOM with live event listeners) alongside a
+     * static DOM clone as fallback.
+     */
+    snapshotForMessage(messageId: string, options?: PanelSnapshotOptions | (() => HTMLElement) | undefined): void;
+    /**
+     * Restore the panel content snapshot associated with a given message ID.
+     * Highlights the active message and de-highlights the previous one.
+     * Also restores the panel topbar title for the snapshot's component type.
+     * Returns true if the snapshot was found and restored.
+     */
+    restoreForMessage(messageId: string, highlightMessageId?: string): boolean;
+    /**
+     * Send maximize-pdp / minify-pdp bridge messages with production-matching delays.
+     * Called by the extended mode manager when panel extension state changes.
+     */
+    notifyExtension(extended: boolean): void;
+    /**
+     * Derive panel title from UISpec root element type using i18n strings.
+     * When the backend provides a `panelTitle` prop, it takes precedence.
+     */
+    titleForComponent(componentType: string, backendTitle?: string): string;
+    /**
+     * Update the panel top bar navigation state and title.
+     * When the backend provides a `panelTitle`, it takes precedence over i18n defaults.
+     */
+    /** @param displayTitle When passed (including empty string), used instead of titleForComponent. */
+    updateTopBar(componentType: string, backendTitle?: string, displayTitle?: string): void;
+    /**
+     * Set panel topbar title during loading (before actual panel content arrives).
+     * Maps backend pending types to the same i18n titles used for final content.
+     */
+    updateTopBarForLoading(pendingType: string): void;
+    /**
+     * Map UISpec component types to PanelContentType for the extended mode manager.
+     */
+    updateExtendedMode(componentType: string): void;
+    /** Navigate to the previous panel thread. */
+    navigateBack(): void;
+    /** Navigate to the next panel thread. */
+    navigateForward(): void;
+    /**
+     * Panel route shaping:
+     * - product details => expanded LHS panel (`ProductDetailsPanel`)
+     * - all other panel-routed specs keep their original component types
+     */
+    toPanelSpec(spec: UISpec): UISpec;
+    destroy(): void;
+}
+/**
+ * Decide how to apply incoming panel UISpec content.
+ *
+ * - `'replace'` — set as sole panel content (new search, comparison, product details)
+ * - `'append'` — add below existing content (similar products grid after product details)
+ * - `'appendSimilars'` — append via the dedicated similars helper
+ */
+export type PanelUpdateAction = 'replace' | 'append' | 'appendSimilars';
+export declare function determinePanelUpdateAction(opts: {
+    componentType: string;
+    similarsAppend: boolean;
+    currentPanelType: string | null;
+    hasPanelContent: boolean;
+    isPanelLoading: boolean;
+    isFirstPanelContentInStream: boolean;
+}): PanelUpdateAction;