import { z } from 'zod/v4';
import * as _angular_core from '@angular/core';
import { InjectionToken, EnvironmentProviders } from '@angular/core';
import { AbstractAgent } from '@ag-ui/client';
import { ActivityRenderer, RenderActivityMessageConfig } from '@copilotkit/angular';

/**
 * Content schema for `activityType: "mcp-apps"` activity messages: a snapshot
 * of an MCP Apps tool call, carrying the middleware server hash, optional
 * stable server id, the ui:// resource to render, and its tool exchange.
 *
 * Kept local and declared with the `zod/v4` API so the Angular browser bundle
 * validates protocol data without taking a direct MCP client SDK dependency.
 */
declare const mcpAppsSnapshotContentSchema: z.ZodObject<{
    serverHash: z.ZodString;
    serverId: z.ZodOptional<z.ZodString>;
    resourceUri: z.ZodString;
    result: z.ZodObject<{
        content: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            type: z.ZodLiteral<"text">;
            text: z.ZodString;
            annotations: z.ZodOptional<z.ZodObject<{
                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                    user: "user";
                    assistant: "assistant";
                }>>>;
                priority: z.ZodOptional<z.ZodNumber>;
                lastModified: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"image">;
            data: z.ZodString;
            mimeType: z.ZodString;
            annotations: z.ZodOptional<z.ZodObject<{
                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                    user: "user";
                    assistant: "assistant";
                }>>>;
                priority: z.ZodOptional<z.ZodNumber>;
                lastModified: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"audio">;
            data: z.ZodString;
            mimeType: z.ZodString;
            annotations: z.ZodOptional<z.ZodObject<{
                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                    user: "user";
                    assistant: "assistant";
                }>>>;
                priority: z.ZodOptional<z.ZodNumber>;
                lastModified: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"resource">;
            resource: z.ZodUnion<readonly [z.ZodObject<{
                uri: z.ZodString;
                mimeType: z.ZodOptional<z.ZodString>;
                text: z.ZodString;
            }, z.core.$loose>, z.ZodObject<{
                uri: z.ZodString;
                mimeType: z.ZodOptional<z.ZodString>;
                blob: z.ZodString;
            }, z.core.$loose>]>;
            annotations: z.ZodOptional<z.ZodObject<{
                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                    user: "user";
                    assistant: "assistant";
                }>>>;
                priority: z.ZodOptional<z.ZodNumber>;
                lastModified: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"resource_link">;
            uri: z.ZodString;
            name: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            mimeType: z.ZodOptional<z.ZodString>;
            annotations: z.ZodOptional<z.ZodObject<{
                audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                    user: "user";
                    assistant: "assistant";
                }>>>;
                priority: z.ZodOptional<z.ZodNumber>;
                lastModified: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>>;
        }, z.core.$loose>]>>>;
        structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        isError: z.ZodOptional<z.ZodBoolean>;
        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$loose>;
    toolInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$loose>;
/** Parsed content of an `mcp-apps` activity message. */
type MCPAppsSnapshotContent = z.infer<typeof mcpAppsSnapshotContentSchema>;

/**
 * Renders one MCP App snapshot through the same agent-mediated protocol used
 * by the other CopilotKit frontends. Each instance owns its queued work and
 * sandbox listener, while requests remain serialized per agent thread.
 */
declare class CopilotMCPAppsWidget {
    private readonly config;
    private readonly copilotKit;
    private readonly platformId;
    private readonly ownerId;
    private readonly queue;
    private renderVersion;
    readonly data: _angular_core.InputSignal<{
        [x: string]: unknown;
        serverHash: string;
        resourceUri: string;
        result: {
            [x: string]: unknown;
            content: ({
                [x: string]: unknown;
                type: "text";
                text: string;
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            } | {
                [x: string]: unknown;
                type: "image";
                data: string;
                mimeType: string;
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            } | {
                [x: string]: unknown;
                type: "audio";
                data: string;
                mimeType: string;
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            } | {
                [x: string]: unknown;
                type: "resource";
                resource?: {
                    [x: string]: unknown;
                    uri: string;
                    text: string;
                    mimeType?: string;
                } | {
                    [x: string]: unknown;
                    uri: string;
                    blob: string;
                    mimeType?: string;
                };
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            } | {
                [x: string]: unknown;
                type: "resource_link";
                uri: string;
                name: string;
                description?: string;
                mimeType?: string;
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            })[];
            structuredContent?: Record<string, unknown>;
            isError?: boolean;
            _meta?: Record<string, unknown>;
        };
        serverId?: string;
        toolInput?: Record<string, unknown>;
    }>;
    readonly agent: _angular_core.InputSignal<AbstractAgent>;
    private readonly renderSession;
    private readonly appFrame;
    protected readonly loading: _angular_core.WritableSignal<boolean>;
    protected readonly error: _angular_core.WritableSignal<string>;
    constructor();
    private renderApp;
    private connectSandbox;
    private handleMessage;
    private handleUIMessage;
    private handleOpenLink;
    private handleToolCall;
    private sendResponse;
    private sendError;
    private sendNotification;
    private fail;
    private resetFrame;
    private throwIfStale;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotMCPAppsWidget, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotMCPAppsWidget, "copilot-mcp-apps-widget", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "agent": { "alias": "agent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Activity renderer for `mcp-apps` snapshots. Renders the referenced MCP App
 * inline via {@link CopilotMCPAppsWidget}. Resource and tool requests are
 * proxied through the activity's selected AG-UI agent.
 */
declare class CopilotMCPAppsActivityRenderer implements ActivityRenderer<MCPAppsSnapshotContent> {
    readonly activityType: _angular_core.InputSignal<string>;
    readonly content: _angular_core.InputSignal<{
        [x: string]: unknown;
        serverHash: string;
        resourceUri: string;
        result: {
            [x: string]: unknown;
            content: ({
                [x: string]: unknown;
                type: "text";
                text: string;
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            } | {
                [x: string]: unknown;
                type: "image";
                data: string;
                mimeType: string;
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            } | {
                [x: string]: unknown;
                type: "audio";
                data: string;
                mimeType: string;
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            } | {
                [x: string]: unknown;
                type: "resource";
                resource?: {
                    [x: string]: unknown;
                    uri: string;
                    text: string;
                    mimeType?: string;
                } | {
                    [x: string]: unknown;
                    uri: string;
                    blob: string;
                    mimeType?: string;
                };
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            } | {
                [x: string]: unknown;
                type: "resource_link";
                uri: string;
                name: string;
                description?: string;
                mimeType?: string;
                annotations?: {
                    [x: string]: unknown;
                    audience?: ("user" | "assistant")[];
                    priority?: number;
                    lastModified?: string;
                };
            })[];
            structuredContent?: Record<string, unknown>;
            isError?: boolean;
            _meta?: Record<string, unknown>;
        };
        serverId?: string;
        toolInput?: Record<string, unknown>;
    }>;
    readonly message: _angular_core.InputSignal<{
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    }>;
    readonly agent: _angular_core.InputSignal<AbstractAgent>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotMCPAppsActivityRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotMCPAppsActivityRenderer, "copilot-mcp-apps-activity-renderer", never, { "activityType": { "alias": "activityType"; "required": true; "isSignal": true; }; "content": { "alias": "content"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "agent": { "alias": "agent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
/**
 * Ready-to-register render config for `mcp-apps` activity messages. Pass it
 * to `provideCopilotKit({ renderActivityMessages: [...] })`.
 */
declare const mcpAppsActivityRendererConfig: RenderActivityMessageConfig<MCPAppsSnapshotContent>;

interface MCPAppsHostInfo {
    name: string;
    version: string;
}
interface MCPAppsConfig {
    /** Maximum time to wait for a busy agent before a queued request fails. */
    idleTimeoutMs?: number;
    /** Maximum time to wait for the sandbox proxy initialization handshake. */
    initializationTimeoutMs?: number;
    /** Host identity announced during the MCP Apps initialization handshake. */
    hostInfo?: MCPAppsHostInfo;
    /** Additional protocol capabilities announced to embedded MCP Apps. */
    hostCapabilities?: Record<string, unknown>;
    /** Additional non-secret UI context announced to embedded MCP Apps. */
    hostContext?: Record<string, unknown>;
}
declare const DEFAULT_MCP_APPS_CONFIG: Readonly<Required<MCPAppsConfig>>;
/** Holds renderer behavior configuration registered via `provideMCPApps`. */
declare const MCP_APPS_CONFIG: InjectionToken<Required<MCPAppsConfig>>;

/**
 * Configures and registers the built-in MCP Apps renderer.
 *
 * MCP resource and tool requests always travel through the selected AG-UI
 * agent. Server URLs deliberately are not accepted by this browser provider.
 * Application renderers retain precedence over this built-in registration.
 */
declare function provideMCPApps(config?: MCPAppsConfig): EnvironmentProviders;

export { CopilotMCPAppsActivityRenderer, CopilotMCPAppsWidget, DEFAULT_MCP_APPS_CONFIG, MCP_APPS_CONFIG, mcpAppsActivityRendererConfig, mcpAppsSnapshotContentSchema, provideMCPApps };
export type { MCPAppsConfig, MCPAppsHostInfo, MCPAppsSnapshotContent };