/**
 * MCP Display Helpers — return prefab UIs as MCP tool results.
 *
 * These functions wrap PrefabApp / Component trees into MCP-compatible
 * tool result content arrays, ready to return from tool handlers.
 *
 * @example
 * ```ts
 * import { display, display_error } from '@maxhealth.tech/prefab/mcp'
 * import { autoTable } from '@maxhealth.tech/prefab'
 *
 * // In a FastMCP tool handler:
 * async function listPatients(args, context) {
 *   const patients = await fetchPatients()
 *   return display(autoTable(patients), { title: 'Patient List' })
 * }
 * ```
 */
import { type Component } from '../core/component.js';
import { PrefabApp } from '../app.js';
import type { Theme, LayoutHints, ColorMode } from '../app.js';
import type { Action, ActionJSON } from '../actions/types.js';
import type { PipeFn } from '../rx/pipes.js';
import type { McpToolResult } from './types.js';
export interface DisplayOptions {
    /** Page / app title. */
    title?: string;
    /** Initial reactive state. */
    state?: Record<string, unknown>;
    /** Light/dark theme overrides. */
    theme?: Theme;
    /** Reusable component definitions. */
    defs?: Record<string, Component>;
    /** Action(s) to run when the UI mounts. */
    onMount?: Action | Action[];
    /** Keyboard shortcuts. */
    keyBindings?: Record<string, Action | Action[]>;
    /** Extra CSS class on root element. */
    cssClass?: string;
    /** Size hints for the host container (iframe, panel, etc.). */
    layout?: LayoutHints;
    /** Inline CSS blocks injected as `<style>` (merged after the compiled theme). */
    css?: string[];
    /** External CSS URLs loaded as `<link rel="stylesheet">`. */
    stylesheets?: string[];
    /** Force a color scheme regardless of OS preference. */
    mode?: ColorMode;
    /** Custom pipe functions for reactive expressions. */
    pipes?: Record<string, PipeFn>;
}
/**
 * Wrap a Component (or PrefabApp) as an MCP tool result.
 *
 * If given a Component, it's wrapped in a PrefabApp automatically.
 * If given a PrefabApp, it's serialized as-is.
 *
 * @returns MCP tool result with the prefab wire format JSON as text content.
 */
export declare function display(viewOrApp: Component | PrefabApp, options?: DisplayOptions): McpToolResult;
import type { AutoFormField, AutoFormOptions } from '../auto/form.js';
export interface DisplayFormOptions extends AutoFormOptions, DisplayOptions {
}
/**
 * Return a form UI as an MCP tool result.
 *
 * The form submits back to the specified MCP tool via CallTool.
 * Field definitions map to Input components; the submit action
 * invokes `submitTool` with all field values.
 *
 * @returns MCP tool result with form prefab UI.
 */
export declare function display_form(fields: AutoFormField[], submitTool: string, options?: DisplayFormOptions): McpToolResult;
export interface StateUpdate {
    /** State key-value pairs to merge into the existing UI state. */
    state: Record<string, unknown>;
    /** Actions to fire after the state delta is applied. */
    actions?: ActionJSON | ActionJSON[];
}
export interface PrefabUpdateWire {
    $prefab: {
        version: string;
    };
    update: StateUpdate;
}
export interface DisplayUpdateOptions {
    /** Actions to fire after the state delta is applied. */
    actions?: Action | Action[];
}
/**
 * Return a partial state update for an existing prefab UI.
 *
 * Instead of re-rendering the entire UI, this sends a state delta
 * that the renderer merges into its reactive store. Optionally fires
 * actions after the state is applied.
 *
 * @returns MCP tool result with a $prefab update payload.
 */
export declare function display_update(state: Record<string, unknown>, options?: DisplayUpdateOptions): McpToolResult;
export interface DisplayErrorOptions {
    /** Error detail / stack trace to show in a code block. */
    detail?: string;
    /** Hint for the user on how to fix the issue. */
    hint?: string;
    /** Theme overrides. */
    theme?: Theme;
}
/**
 * Return a standardized error view as an MCP tool result.
 *
 * Renders a destructive Alert with title + message, optional detail
 * code block, and optional hint. Sets `isError: true` on the MCP result.
 *
 * @returns MCP tool result with error UI and isError flag.
 */
export declare function display_error(title: string, message: string, options?: DisplayErrorOptions): McpToolResult;
export interface DisplaySuccessOptions {
    /** Additional detail text below the message. */
    detail?: string;
    /** Theme overrides. */
    theme?: Theme;
}
/**
 * Return a standardized success view as an MCP tool result.
 *
 * Renders a success Alert with title + message, optional detail text.
 *
 * @returns MCP tool result with success UI.
 */
export declare function display_success(title: string, message: string, options?: DisplaySuccessOptions): McpToolResult;
export declare const displayForm: typeof display_form;
export declare const displayUpdate: typeof display_update;
export declare const displayError: typeof display_error;
export declare const displaySuccess: typeof display_success;
/** CSP configuration for MCP Apps resources. */
export interface McpAppCsp {
    /** Origins allowed for scripts, styles, images, fonts, media. */
    resourceDomains?: string[];
    /** Origins allowed for fetch/XHR/WebSocket. */
    connectDomains?: string[];
    /** Origins allowed for nested iframes. */
    frameDomains?: string[];
    /** Additional allowed base URIs. */
    baseUriDomains?: string[];
}
/** Permission Policy requests for MCP Apps resources. */
export interface McpAppPermissions {
    /** Request camera access (video capture, QR scanning). */
    camera?: boolean;
    /** Request microphone access (audio recording, voice input). */
    microphone?: boolean;
    /** Request geolocation access (location-aware apps, maps). */
    geolocation?: boolean;
    /** Request clipboard write access (copy-to-clipboard). */
    clipboardWrite?: boolean;
}
export interface ResourceMetaOptions {
    /** CSP domains configuration. */
    csp?: McpAppCsp;
    /** Permission Policy requests (camera, mic, etc.). */
    permissions?: McpAppPermissions;
}
/**
 * Generate the `_meta` object for MCP Apps `ui://` resource registration.
 *
 * Includes CSP and Permission Policy configuration per the MCP Apps spec.
 * Use on both the resource listing AND the content item (VS Code reads
 * only the content item; other hosts may read either).
 *
 * @example
 * ```ts
 * const meta = resourceMeta({
 *   csp: { resourceDomains: ['https://cdn.jsdelivr.net'] },
 *   permissions: { camera: true },
 * })
 *
 * mcp.resource('viewer', 'ui://my/viewer', {
 *   mimeType: 'text/html;profile=mcp-app',
 *   _meta: meta,
 * }, async (uri) => ({
 *   contents: [{ uri: uri.toString(), mimeType: 'text/html;profile=mcp-app', text: html, _meta: meta }],
 * }))
 * ```
 */
/** Spec-compliant permissions shape: each granted permission is `{}`. */
interface McpAppPermissionsWire {
    camera?: Record<string, never>;
    microphone?: Record<string, never>;
    geolocation?: Record<string, never>;
    clipboardWrite?: Record<string, never>;
}
export declare function resourceMeta(options?: ResourceMetaOptions): {
    ui: {
        csp?: McpAppCsp;
        permissions?: McpAppPermissionsWire;
    };
};
/** Default CSP meta for prefab apps using jsDelivr CDN. */
export declare const PREFAB_CDN_META: {
    ui: {
        csp?: McpAppCsp;
        permissions?: McpAppPermissionsWire;
    };
};
/** Default URI for the prefab viewer resource. */
export declare const PREFAB_RESOURCE_URI = "ui://prefab/viewer";
export interface RendererHtmlOptions {
    /** Page title. @default 'Prefab' */
    title?: string;
    /** Additional `<script>` URLs to load after the renderer. */
    scripts?: string[];
    /** Additional `<link rel="stylesheet">` URLs. */
    stylesheets?: string[];
    /** Override CDN base URL (no trailing slash). @default jsdelivr CDN */
    cdnBase?: string;
}
/**
 * Generate the HTML page for a prefab MCP Apps viewer resource.
 *
 * Returns the minimal HTML that loads `prefab.css` and `renderer.auto.min.js`
 * from the CDN, plus any additional scripts/stylesheets you specify.
 *
 * @example
 * ```ts
 * import { rendererHtml } from '@maxhealth.tech/prefab/mcp'
 * const html = rendererHtml()
 * // or with extra scripts:
 * const html = rendererHtml({ scripts: ['https://cdn.example.com/plugin.js'] })
 * ```
 */
export declare function rendererHtml(options?: RendererHtmlOptions): string;
export interface ViewerResourceOptions {
    /** Resource URI. @default PREFAB_RESOURCE_URI */
    uri?: string;
    /** Resource title. @default 'Prefab Viewer' */
    title?: string;
    /** CSP configuration. @default { resourceDomains: ['https://cdn.jsdelivr.net'] } */
    csp?: McpAppCsp;
    /** Permission Policy requests. */
    permissions?: McpAppPermissions;
    /** Additional `<script>` URLs to load after the renderer. */
    scripts?: string[];
    /** Additional `<link rel="stylesheet">` URLs. */
    stylesheets?: string[];
    /** Override CDN base URL (no trailing slash). */
    cdnBase?: string;
}
/**
 * MCP server interface expected by registerViewerResource.
 * Compatible with @modelcontextprotocol/sdk McpServer and fastmcp Server.
 */
interface McpServerLike {
    resource(name: string, uri: string, options: {
        title?: string;
        mimeType: string;
        description?: string;
        _meta?: Record<string, unknown>;
    }, handler: (uri: URL) => Promise<{
        contents: {
            uri: string;
            mimeType: string;
            text: string;
            _meta?: Record<string, unknown>;
        }[];
    }>): void;
}
/**
 * Register the prefab viewer as a `ui://` resource on an MCP server.
 *
 * Handles MIME type, CSP on both listing and content item, and HTML generation.
 * Eliminates the three most common registration mistakes in one call.
 *
 * @example
 * ```ts
 * import { registerViewerResource, PREFAB_RESOURCE_URI } from '@maxhealth.tech/prefab/mcp'
 *
 * registerViewerResource(server)
 *
 * server.tool('browse', schema, async (args) => ({
 *   content: [{ type: 'text', text: JSON.stringify(data) }],
 *   structuredContent: data,
 *   _meta: { ui: { resourceUri: PREFAB_RESOURCE_URI } },
 * }))
 * ```
 */
export declare function registerViewerResource(server: McpServerLike, options?: ViewerResourceOptions): void;
export {};
//# sourceMappingURL=display.d.ts.map