/**
 * Runtime config consumed by the chat panel.
 */
export interface ChatRuntime {
    endpoints: {
        /** POST streaming chat. Hub: '/api/docs/chat'. */
        chatStreamUrl: string;
        /** POST agent approve/reject. Hub: '/api/chat/agent/confirm-tool'. */
        approvalToolUrl: string;
        /** GET slash-command catalog. Hub: '/api/docs/commands'. */
        commandsUrl: string;
        /** Build entity-card list URL for a content type + ids. Hub delegates
         *  to the rag-table-config registry; embedded app provides its own
         *  per-type URL builder against the reverse proxy. Returns null when
         *  the type has no list endpoint (caller skips rendering). */
        buildListUrl: (type: string, ids: string[]) => string | null;
        /** Chat-attachment endpoints — added for the v2 attachment feature.
         *
         *  Three concerns:
         *    - `attachmentUploadUrl` — POSTed by the chat-attachment hook
         *      to mint a Supabase signed-upload-URL + HMAC view token.
         *    - `attachmentViewUrlPrefix` — embedded in markdown URLs the
         *      chat hosts in user message bubbles (`![]()` / `[Attached]`).
         *      Stored in chat history; chosen at SEND time. In host mode the
         *      relative `/api/storage/view/chat-attachments/` is sufficient
         *      (same-origin); embedders supply an absolute hub URL so the
         *      browser can fetch cross-origin.
         *    - `identityUrl` — GET endpoint the `useChatIdentity` hook
         *      hits to learn the `{authTier, source, attachmentsEnabled}`
         *      capability bag for the current session. Used beyond chat
         *      (tickets / contact form / any embedded surface that needs
         *      to identify the proxied customer), so the name has no
         *      "chat" prefix even though the consuming hook still does. */
        attachmentUploadUrl: string;
        attachmentViewUrlPrefix: string;
        identityUrl: string;
        /** Optional URL prefix for the image proxy (`<prefix>?url=<external>`).
         *  When unset, lib's `getProxiedImageUrl` returns the original URL
         *  unchanged. Hub default: '/api/image-proxy'. Embedders that don't
         *  host an image-proxy route leave this undefined → images load
         *  directly cross-origin (CORS-permitting). */
        imageProxyUrlPrefix?: string;
        /** Optional list of hostnames that should bypass the image proxy
         *  (rendered direct). Hub uses ['openmsp.ai']; embedders typically
         *  leave it unset. Matches the `skipDomains` parameter of
         *  `getProxiedImageUrl`. */
        imageProxySkipDomains?: string[];
    };
    navigation: {
        /** ONE knob, two behaviors:
         *  - 'host' = use the host page's existing click-routing untouched.
         *    The chat panel calls `navigate?.()` for in-app routing.
         *  - 'embed' = guest inside another app: short-circuit at the top
         *    of click handlers to force new-tab + absolutize via
         *    resolveExternalNavigation. */
        mode: 'host' | 'embed';
        /** Embed-only fallback origin for relative URLs whose target platform
         *  can't be inferred. Used by resolveExternalNavigation when
         *  `targetPlatform` is null — without this, a relative `/foo` href would
         *  window.open against the embedder's origin, which is WRONG.
         *  Set to your content host (e.g. 'https://hub.openframe.ai').
         *  Required by the embedded app whenever mode='embed'. */
        defaultContentOrigin?: string;
        /** Override for opening external URLs. MUST BE SYNCHRONOUS —
         *  Safari/Firefox block popups opened outside a direct user gesture.
         *  Default: window.open(href, '_blank', 'noopener,noreferrer'). */
        openExternal?: (href: string) => void;
        /** Optional in-app navigation callback (host-mode only).
         *  Returns `true` if the host handled the click in-app
         *  (router.push + docNav.navigate); returns `false`, `undefined`,
         *  or `void` → lib falls back to window.location.assign(href).
         *  Hub wires this via HubRuntimeProvider's HubNavigationWiring;
         *  embedders not in Next.js leave it undefined. */
        navigate?: (input: {
            href: string;
            path?: string | null;
            targetPlatform?: string | null;
        }) => boolean | void;
        /** Optional new-tab decision callback. Returns true → lib opens in
         *  new tab; false → same tab via `navigate`. Hub wires the existing
         *  `decideNewTab` logic from use-nav-link.tsx (re-imports the pure
         *  helper from lib). Embedders may omit; lib defaults to:
         *  same-origin/same-platform → same tab, else new tab. */
        decideNewTab?: (args: {
            href: string;
            targetPlatform?: string | null;
        }) => boolean;
    };
    /** Chat source identifier — REQUIRED. Used for localStorage
     *  namespacing (`mingo-chat-<source>-v1`). Hub sets via
     *  `currentPlatform()`; embedders set explicitly.
     *  `useEmbeddedChat()` throws if source is empty/missing. */
    source: string;
}
export declare const ChatRuntimeContext: import("react").Context<ChatRuntime | null>;
/**
 * Returns the active runtime, or null when no provider is mounted.
 * NULL is a first-class value — it signals "no chat runtime configured."
 * Optional consumers fall back to no-op behavior; strict consumers
 * use `useRequiredChatRuntime` (below).
 */
export declare function useChatRuntime(): ChatRuntime | null;
/**
 * Strict variant used INSIDE the chat panel. Throws if no provider.
 * The hub guarantees one exists by mounting `<HubRuntimeProvider>` at
 * root; the embedded app mounts its own `<ChatRuntimeContext.Provider>`
 * at the tree root. In Jest / Storybook tests that render chat
 * internals directly, wrap with `<HubRuntimeProvider>` (hub defaults)
 * or supply `<ChatRuntimeContext.Provider value={mockedRuntime}>`.
 */
export declare function useRequiredChatRuntime(): ChatRuntime;
//# sourceMappingURL=chat-runtime-context.d.ts.map