import * as _angular_core from '@angular/core';
import { Type, Signal, InjectionToken, Provider, Injector, DestroyRef, WritableSignal, OnDestroy, NgZone, ElementRef, TemplateRef, ViewContainerRef, ComponentRef, EmbeddedViewRef, OnInit, OnChanges, ChangeDetectorRef, SimpleChanges, AfterViewInit, EventEmitter } from '@angular/core';
import * as _ag_ui_client from '@ag-ui/client';
import { AbstractAgent, ActivityMessage, ToolCall, Message, Interrupt, ResumeEntry, RunAgentResult, Context, AssistantMessage } from '@ag-ui/client';
export { AssistantMessage, Message } from '@ag-ui/client';
import { FrontendTool, FrontendToolHandlerContext, SuggestionsConfig, CopilotKitCoreRuntimeConnectionStatus, CopilotRuntimeTransport, ThreadEndpointRuntimeInfo, IntelligenceRuntimeInfo, RuntimeLicenseStatus, CopilotKitCoreGetSuggestionsResult, CopilotKitCore, Suggestion, Memory, MemoryRealtimeStatus, NewMemory, MemoryChanges } from '@copilotkit/core';
export { DynamicSuggestionsConfig, Memory, MemoryChanges, MemoryKind, MemoryScope, NewMemory, StaticSuggestionsConfig, Suggestion, SuggestionsConfig } from '@copilotkit/core';
import { StandardSchemaV1, Attachment, TranscriptionErrorCode, AttachmentsConfig, AttachmentModality, InputContent, ImageInputPart, AudioInputPart, VideoInputPart, DocumentInputPart } from '@copilotkit/shared';
export { Attachment, AttachmentModality, AttachmentUploadError, AttachmentUploadResult, AttachmentsConfig, TranscriptionErrorCode } from '@copilotkit/shared';
import { z } from 'zod';
import { Theme, Catalog, LitComponentImplementation, LitRenderable } from '@copilotkit/a2ui-renderer/web-components';
import { ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';
import { Observable } from 'rxjs';
import { ClassValue } from 'clsx';
import * as _copilotkit_angular from '@copilotkit/angular';
import { UserMessage, Message as Message$1, ReasoningMessage, ActivityMessage as ActivityMessage$1 } from '@ag-ui/core';
import { DrawerThread } from '@copilotkit/web-components/threads-drawer';
import Websandbox from '@jetbrains/websandbox';

type AngularToolCall<Args extends Record<string, unknown> = Record<string, unknown>> = {
    name?: string;
    args: Partial<Args>;
    status: "in-progress";
    result: undefined;
} | {
    name?: string;
    args: Args;
    status: "executing";
    result: undefined;
} | {
    name?: string;
    args: Args;
    status: "complete";
    result: string;
};
type HumanInTheLoopToolCall<Args extends Record<string, unknown> = Record<string, unknown>> = {
    name?: string;
    args: Partial<Args>;
    status: "in-progress";
    result: undefined;
    respond: (result: unknown) => void;
} | {
    name?: string;
    args: Args;
    status: "executing";
    result: undefined;
    respond: (result: unknown) => void;
} | {
    name?: string;
    args: Args;
    status: "complete";
    result: string;
    respond: (result: unknown) => void;
};
interface ToolRenderer<Args extends Record<string, unknown> = Record<string, unknown>> {
    toolCall: Signal<AngularToolCall<Args>>;
    agent?: Signal<AbstractAgent | undefined>;
}
interface HumanInTheLoopToolRenderer<Args extends Record<string, unknown> = Record<string, unknown>> {
    toolCall: Signal<HumanInTheLoopToolCall<Args>>;
}
type ClientTool<Args extends Record<string, unknown> = Record<string, unknown>> = Omit<FrontendTool<Args>, "handler"> & {
    renderer?: Type<ToolRenderer<Args>>;
};
interface RenderToolCallConfig<Args extends Record<string, unknown> = Record<string, unknown>> {
    name: string;
    args: StandardSchemaV1<unknown, Args>;
    component: Type<ToolRenderer<Args>>;
    agentId?: string;
    passAgent?: boolean;
}
interface FrontendToolConfig<Args extends Record<string, unknown> = Record<string, unknown>> {
    name: string;
    description: string;
    parameters: StandardSchemaV1<unknown, Args>;
    component?: Type<ToolRenderer<Args>>;
    handler: (args: Args, context: FrontendToolHandlerContext) => Promise<unknown>;
    followUp?: boolean;
    agentId?: string;
}
interface HumanInTheLoopConfig<Args extends Record<string, unknown> = Record<string, unknown>> {
    name: string;
    description: string;
    parameters: StandardSchemaV1<unknown, Args>;
    component: Type<HumanInTheLoopToolRenderer<Args>>;
    agentId?: string;
}
declare function registerRenderToolCall<Args extends Record<string, unknown> = Record<string, unknown>>(renderToolCall: RenderToolCallConfig<Args>): void;
declare function registerFrontendTool<Args extends Record<string, unknown> = Record<string, unknown>>(frontendTool: FrontendToolConfig<Args>): void;
declare function registerHumanInTheLoop<Args extends Record<string, unknown> = Record<string, unknown>>(humanInTheLoop: HumanInTheLoopConfig<Args>): void;

type AngularActivityContentParseResult<T> = {
    success: true;
    data: T;
} | {
    success: false;
    error?: unknown;
};
interface AngularActivityContentSchema<T> {
    safeParse(content: unknown): AngularActivityContentParseResult<T>;
}
interface ActivityRenderer<TActivityContent = unknown> {
    activityType: Signal<string>;
    content: Signal<TActivityContent>;
    message: Signal<ActivityMessage>;
    agent: Signal<AbstractAgent | undefined>;
}
interface RenderActivityMessageConfig<TActivityContent = unknown> {
    activityType: string;
    agentId?: string;
    content: AngularActivityContentSchema<TActivityContent>;
    component: Type<ActivityRenderer<TActivityContent>>;
}
/**
 * Extension point used by optional secondary entry points to contribute
 * lower-precedence built-in activity renderers.
 *
 * @internal
 */
declare const ɵCOPILOTKIT_BUILT_IN_ACTIVITY_RENDERERS: InjectionToken<RenderActivityMessageConfig<unknown>[]>;
declare const anyActivityContentSchema: AngularActivityContentSchema<unknown>;
/** Register an activity renderer for the lifetime of the current injector. */
declare function registerRenderActivityMessage(config: RenderActivityMessageConfig): void;

declare const OPEN_GENERATIVE_UI_ACTIVITY_TYPE = "open-generative-ui";
declare const GENERATE_SANDBOXED_UI_TOOL_NAME = "generateSandboxedUi";
declare const DEFAULT_OPEN_GENERATIVE_UI_DESIGN_SKILL = "When generating UI with generateSandboxedUi, follow these design principles inspired by shadcn/ui:\n\n- Use a minimal, flat aesthetic. Avoid drop shadows and gradients \u2014 rely on subtle borders (1px solid, light gray like #e5e7eb) to define surfaces.\n- Neutral base palette: white backgrounds, zinc/slate gray text (#09090b for headings, #71717a for secondary text). One accent color for interactive elements.\n- Use system font stacks (system-ui, -apple-system, sans-serif) at readable sizes (14px body, 600 weight for headings). Tight line-heights.\n- Small, consistent border-radius (6\u20138px). Cards and containers use border, not shadow, for separation.\n- Buttons: solid fill for primary (dark bg, white text), outline for secondary (border + transparent bg). Subtle hover state (slight opacity or background shift).\n- Use CSS Grid or Flexbox for layout. Ensure the UI looks good at any width.\n- Minimal transitions (150ms) for hover/focus states only. No decorative animations.\n- Keep the UI focused and dense \u2014 avoid excessive padding. Use compact spacing (8\u201312px gaps, 10\u201314px padding in controls).";
declare const GENERATE_SANDBOXED_UI_DESCRIPTION: string;
declare const OpenGenerativeUIContentSchema: z.ZodObject<{
    initialHeight: z.ZodOptional<z.ZodNumber>;
    generating: z.ZodOptional<z.ZodBoolean>;
    css: z.ZodOptional<z.ZodString>;
    cssComplete: z.ZodOptional<z.ZodBoolean>;
    html: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    htmlComplete: z.ZodOptional<z.ZodBoolean>;
    jsFunctions: z.ZodOptional<z.ZodString>;
    jsFunctionsComplete: z.ZodOptional<z.ZodBoolean>;
    jsExpressions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    jsExpressionsComplete: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    html?: string[];
    initialHeight?: number;
    generating?: boolean;
    css?: string;
    cssComplete?: boolean;
    htmlComplete?: boolean;
    jsFunctions?: string;
    jsFunctionsComplete?: boolean;
    jsExpressions?: string[];
    jsExpressionsComplete?: boolean;
}, {
    html?: string[];
    initialHeight?: number;
    generating?: boolean;
    css?: string;
    cssComplete?: boolean;
    htmlComplete?: boolean;
    jsFunctions?: string;
    jsFunctionsComplete?: boolean;
    jsExpressions?: string[];
    jsExpressionsComplete?: boolean;
}>;
type OpenGenerativeUIContent = z.infer<typeof OpenGenerativeUIContentSchema>;
declare const GenerateSandboxedUiArgsSchema: z.ZodObject<{
    initialHeight: z.ZodOptional<z.ZodNumber>;
    placeholderMessages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    css: z.ZodOptional<z.ZodString>;
    html: z.ZodOptional<z.ZodString>;
    jsFunctions: z.ZodOptional<z.ZodString>;
    jsExpressions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    html?: string;
    initialHeight?: number;
    css?: string;
    jsFunctions?: string;
    jsExpressions?: string[];
    placeholderMessages?: string[];
}, {
    html?: string;
    initialHeight?: number;
    css?: string;
    jsFunctions?: string;
    jsExpressions?: string[];
    placeholderMessages?: string[];
}>;
type GenerateSandboxedUiArgs = z.infer<typeof GenerateSandboxedUiArgsSchema>;
type SandboxFunction<Args extends Record<string, unknown> = Record<string, unknown>> = {
    name: string;
    description: string;
    parameters: StandardSchemaV1<unknown, Args>;
    handler: (args: Args, context?: FrontendToolHandlerContext) => Promise<unknown> | unknown;
};
interface OpenGenerativeUIConfig {
    sandboxFunctions?: SandboxFunction[];
    designSkill?: string;
}

interface A2UIConfig {
    theme?: Theme;
    catalog?: Catalog<LitComponentImplementation>;
    loadingComponent?: () => LitRenderable;
    includeSchema?: boolean;
    recovery?: A2UIRecoveryOptions;
}
interface A2UIRecoveryOptions {
    /** Delay before revealing a transient retry. Defaults to 2000ms. */
    showAfterMs?: number;
    /** Attempt number that reveals retry state immediately. Defaults to 2. */
    showAfterAttempts?: number;
    /** Client diagnostic visibility, overridden by server lifecycle content. */
    debugExposure?: "hidden" | "collapsed" | "verbose";
}
interface CopilotKitConfig {
    runtimeUrl?: string;
    headers?: Record<string, string>;
    licenseKey?: string;
    properties?: Record<string, unknown>;
    agents?: Record<string, AbstractAgent>;
    selfManagedAgents?: Record<string, AbstractAgent>;
    tools?: ClientTool[];
    renderToolCalls?: RenderToolCallConfig[];
    renderActivityMessages?: RenderActivityMessageConfig[];
    suggestionsConfig?: SuggestionsConfig[];
    frontendTools?: FrontendToolConfig[];
    humanInTheLoop?: HumanInTheLoopConfig[];
    /** Opt in to a text-only renderer for otherwise unknown tool calls. */
    defaultToolRendering?: boolean;
    a2ui?: A2UIConfig;
    openGenerativeUI?: OpenGenerativeUIConfig;
}
declare const COPILOT_KIT_CONFIG: InjectionToken<CopilotKitConfig>;
declare function injectCopilotKitConfig(): CopilotKitConfig;
declare function provideCopilotKit(config: CopilotKitConfig): Provider;

declare class CopilotKit {
    #private;
    /** Whether unknown tools may use the built-in text-only fallback renderer. */
    readonly defaultToolRenderingEnabled: boolean;
    readonly agents: Signal<Record<string, AbstractAgent>>;
    readonly runtimeConnectionStatus: Signal<CopilotKitCoreRuntimeConnectionStatus>;
    readonly runtimeUrl: Signal<string>;
    readonly runtimeTransport: Signal<CopilotRuntimeTransport>;
    readonly headers: Signal<Record<string, string>>;
    /**
     * Thread-endpoint capability advertised by the connected runtime's `/info`
     * response, or `undefined` before the runtime reports `Connected`. Exposed
     * as a signal (rather than a plain `core.threadEndpoints` read) so reactive
     * consumers re-run when `/info` lands.
     */
    readonly threadEndpoints: Signal<ThreadEndpointRuntimeInfo>;
    /**
     * Intelligence runtime info advertised by the connected runtime's `/info`
     * response, or `undefined` before the runtime reports `Connected`. Carries
     * the realtime `wsUrl`. Exposed as a signal so reactive consumers re-run
     * when `/info` populates it — even if the connection status does not
     * transition in the same turn.
     */
    readonly intelligence: Signal<IntelligenceRuntimeInfo>;
    /**
     * Server-reported license status from the connected runtime's `/info`
     * response, or `undefined` before the runtime reports it. Exposed as a signal
     * (rather than a plain `core.licenseStatus` read) so reactive consumers — e.g.
     * the threads drawer's license gate — re-run once the status resolves.
     */
    readonly licenseStatus: Signal<RuntimeLicenseStatus>;
    readonly suggestionsByAgent: Signal<Record<string, CopilotKitCoreGetSuggestionsResult>>;
    readonly core: CopilotKitCore;
    readonly toolCallRenderConfigs: Signal<RenderToolCallConfig[]>;
    readonly clientToolCallRenderConfigs: Signal<FrontendToolConfig[]>;
    readonly humanInTheLoopToolRenderConfigs: Signal<HumanInTheLoopConfig[]>;
    readonly activityMessageRenderConfigs: Signal<RenderActivityMessageConfig[]>;
    constructor();
    addFrontendTool(clientToolWithInjector: FrontendToolConfig & {
        injector: Injector;
    }): void;
    addRenderToolCall(renderConfig: RenderToolCallConfig): void;
    addRenderActivityMessage(renderConfig: RenderActivityMessageConfig): void;
    /** Remove one dynamically registered activity renderer by identity. */
    removeRenderActivityMessage(renderConfig: RenderActivityMessageConfig): void;
    addHumanInTheLoop(humanInTheLoopTool: HumanInTheLoopConfig): void;
    addSuggestionsConfig(config: SuggestionsConfig): string;
    removeSuggestionsConfig(id: string): void;
    reloadSuggestions(agentId: string): void;
    clearSuggestions(agentId: string): void;
    getSuggestions(agentId: string): CopilotKitCoreGetSuggestionsResult;
    removeTool(toolName: string, agentId?: string): void;
    getAgent(agentId: string): AbstractAgent | undefined;
    updateRuntime(options: {
        runtimeUrl?: string;
        runtimeTransport?: CopilotRuntimeTransport;
        headers?: Record<string, string>;
        properties?: Record<string, unknown>;
        agents?: Record<string, AbstractAgent>;
        selfManagedAgents?: Record<string, AbstractAgent>;
    }): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotKit, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CopilotKit>;
}

/** Serialize untrusted tool values defensively for text-only display. */
declare function safeToolValue(value: unknown): string;
/** Opt-in text-only fallback for tool calls without an application renderer. */
declare class CopilotDefaultToolRenderer implements ToolRenderer {
    readonly toolCall: _angular_core.InputSignal<AngularToolCall>;
    protected readonly expanded: _angular_core.WritableSignal<boolean>;
    protected readonly argumentsText: _angular_core.Signal<string>;
    protected readonly resultText: _angular_core.Signal<string>;
    protected readonly statusValue: _angular_core.Signal<string>;
    protected readonly statusLabel: _angular_core.Signal<"Preparing" | "Running" | "Complete" | "Unknown status">;
    protected toggleExpanded(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotDefaultToolRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotDefaultToolRenderer, "copilot-default-tool-renderer", never, { "toolCall": { "alias": "toolCall"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

type RendererToolCallHandler = {
    type: "renderer";
    config: RenderToolCallConfig;
};
type ClientToolCallHandler = {
    type: "clientTool";
    config: FrontendToolConfig;
};
type HumanInTheLoopToolCallHandler = {
    type: "humanInTheLoopTool";
    config: HumanInTheLoopConfig;
};
type BuiltInToolCallHandler = {
    type: "builtIn";
    config: {
        component: typeof CopilotDefaultToolRenderer;
    };
};
type ToolCallHandler = RendererToolCallHandler | ClientToolCallHandler | HumanInTheLoopToolCallHandler | BuiltInToolCallHandler;
/** Parse tool-call arguments without allowing malformed payloads to escape. */
declare function parseToolCallArguments(rawArguments: string, allowPartial?: boolean): Record<string, unknown>;
interface PickToolCallHandlerOptions {
    name: string;
    agentId?: string;
    application: readonly RenderToolCallConfig[];
    frontend: readonly FrontendToolConfig[];
    humanInTheLoop: readonly HumanInTheLoopConfig[];
    builtInFallback: boolean;
}
/** Resolve the documented application/frontend/wildcard/fallback precedence. */
declare function pickToolCallHandler(options: PickToolCallHandlerOptions): ToolCallHandler | undefined;
declare class RenderToolCalls {
    #private;
    readonly message: _angular_core.InputSignal<{
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    }>;
    readonly messages: _angular_core.InputSignal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    readonly isLoading: _angular_core.InputSignal<boolean>;
    readonly agentId: _angular_core.InputSignal<string>;
    protected pickRenderer(name: string): ToolCallHandler | undefined;
    protected buildToolCall<Args extends Record<string, unknown>>(toolCall: ToolCall): AngularToolCall<Args>;
    protected buildRendererInputs<Args extends Record<string, unknown>>(toolCall: ToolCall, handler: RendererToolCallHandler | ClientToolCallHandler | BuiltInToolCallHandler): {
        toolCall: AngularToolCall<Args>;
        agent?: AbstractAgent;
    };
    protected buildHumanInTheLoopToolCall<Args extends Record<string, unknown>>(toolCall: ToolCall): HumanInTheLoopToolCall<Args>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RenderToolCalls, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RenderToolCalls, "copilot-render-tool-calls", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Function signature for subscribing to an agent — derived from
 *  CopilotKitCore so the types stay in sync automatically. Injected
 *  by the factory so that AgentStore stays decoupled from the concrete class. */
type SubscribeToAgentFn = CopilotKitCore["subscribeToAgentWithOptions"];
declare class AgentStore {
    #private;
    readonly agent: AbstractAgent;
    readonly isRunning: Signal<boolean>;
    readonly messages: Signal<Message[]>;
    readonly state: Signal<unknown>;
    constructor(abstractAgent: AbstractAgent, destroyRef: DestroyRef, subscribeToAgent: SubscribeToAgentFn);
    teardown(): void;
}
declare class CopilotkitAgentFactory {
    #private;
    createAgentStoreSignal(agentId: Signal<string | undefined>, destroyRef: DestroyRef): Signal<AgentStore>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotkitAgentFactory, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CopilotkitAgentFactory>;
}
declare function injectAgentStore(agentId: string | Signal<string | undefined>): Signal<AgentStore>;

/** Legacy custom-event interrupt payload. */
interface InterruptEvent<TValue = unknown> {
    name: string;
    value: TValue;
}
/** Options forwarded when resuming an interrupted agent. */
interface InterruptRunOptions {
    resume?: ResumeEntry[];
    forwardedProps?: Record<string, unknown>;
}
/** Injectable interrupt filtering and preprocessing options. */
interface InjectInterruptOptions<TValue = unknown, TResult = never> {
    /** Agent id or signal. Defaults to the ambient chat agent. */
    agentId?: string | Signal<string | undefined>;
    /** Return false to leave this interrupt for a different controller. */
    enabled?: (event: InterruptEvent<TValue>) => boolean | PromiseLike<boolean>;
    /** Optionally prepare data for the interrupt UI. */
    handler?: (props: InterruptHandlerProps<TValue>) => TResult | PromiseLike<TResult>;
}
/** Actions and normalized protocol data passed to interrupt handlers. */
interface InterruptHandlerProps<TValue = unknown> {
    event: InterruptEvent<TValue>;
    interrupt: Interrupt | null;
    interrupts: readonly Interrupt[];
    resolve: InterruptController<TValue>["resolve"];
    cancel: InterruptController<TValue>["cancel"];
}
/** Reactive data suitable for binding to an application interrupt component. */
interface InterruptView<TValue = unknown, TResult = unknown> extends InterruptHandlerProps<TValue> {
    result: TResult | null;
}
type InterruptRunner = (agent: AbstractAgent, options: InterruptRunOptions) => Promise<RunAgentResult>;
/** Error surfaced when an application attempts to resume an expired interrupt. */
declare class InterruptExpiredError extends Error {
    readonly interrupt: Interrupt;
    constructor(interrupt: Interrupt);
}
/**
 * Signal-based state machine for standard AG-UI and legacy interrupts.
 *
 * Prefer {@link injectInterrupt} in application components. The public class is
 * useful for framework adapters and deterministic lifecycle tests.
 */
declare class InterruptController<TValue = unknown, TResult = never> {
    #private;
    readonly event: Signal<InterruptEvent<TValue>>;
    readonly interrupt: Signal<{
        id: string;
        reason: string;
        message?: string | undefined;
        toolCallId?: string | undefined;
        metadata?: Record<string, any> | undefined;
        responseSchema?: Record<string, any> | undefined;
        expiresAt?: string | undefined;
    }>;
    readonly interrupts: Signal<readonly {
        id: string;
        reason: string;
        message?: string | undefined;
        toolCallId?: string | undefined;
        metadata?: Record<string, any> | undefined;
        responseSchema?: Record<string, any> | undefined;
        expiresAt?: string | undefined;
    }[]>;
    readonly result: Signal<TResult>;
    readonly error: Signal<unknown>;
    readonly hasInterrupt: Signal<boolean>;
    readonly view: Signal<InterruptView<TValue, TResult>>;
    constructor(runner: InterruptRunner, options?: InjectInterruptOptions<TValue, TResult>);
    /** Subscribe to an agent, replacing any previous lifecycle subscription. */
    connect(agent: AbstractAgent): void;
    /** Clear pending decisions when the host changes threads. */
    setThreadId(threadId: string): void;
    /** Resolve one interrupt, resuming only after the complete set is addressed. */
    readonly resolve: (payload?: unknown, interruptId?: string) => Promise<RunAgentResult | void>;
    /** Cancel one standard interrupt; legacy interrupts are dismissed locally. */
    readonly cancel: (interruptId?: string) => Promise<RunAgentResult | void>;
    /** Alias retained for parity with other CopilotKit framework adapters. */
    readonly resolveInterrupt: (payload?: unknown, interruptId?: string) => Promise<RunAgentResult | void>;
    /** Alias retained for parity with other CopilotKit framework adapters. */
    readonly cancelInterrupt: (interruptId?: string) => Promise<RunAgentResult | void>;
    /** Release the agent subscription and clear sensitive pending state. */
    destroy(): void;
}
/**
 * Create an interrupt controller in the current Angular injection context.
 *
 * The controller follows the ambient chat agent and thread unless an explicit
 * agent is supplied. Bind its signals in a template and call `resolve` or
 * `cancel` from user-driven event handlers.
 */
declare function injectInterrupt<TValue = unknown, TResult = never>(options?: InjectInterruptOptions<TValue, TResult>): InterruptController<TValue, TResult>;

/**
 * A conversation thread managed by the Intelligence platform.
 *
 * Each thread has a unique `id`, an optional human-readable `name`, and
 * timestamp fields tracking creation and update times. This mirrors the
 * `Thread` projection exposed by react-core's `useThreads` so framework
 * wrappers share an identical shape.
 */
interface Thread {
    /** Stable, server-assigned thread identifier. */
    id: string;
    /** The agent this thread belongs to. */
    agentId: string;
    /** Human-readable name, or `null` when the thread is unnamed. */
    name: string | null;
    /** `true` when the thread has been archived. */
    archived: boolean;
    /** ISO-8601 creation timestamp. */
    createdAt: string;
    /** ISO-8601 timestamp of the most recent metadata update. */
    updatedAt: string;
    /**
     * ISO-8601 timestamp of the most recent agent run on this thread. Absent
     * when the thread has never been run. Prefer this over `updatedAt` for
     * user-facing "last activity" displays — it is not bumped by metadata-only
     * actions like rename or archive.
     */
    lastRunAt?: string;
}
/**
 * Configuration for {@link injectThreads}.
 *
 * Thread operations are scoped to the runtime-authenticated user and the
 * provided agent on the Intelligence platform. Each field may be supplied as
 * a plain value or a {@link Signal}; when a signal is used the underlying
 * runtime context is re-synced whenever its value changes.
 */
interface InjectThreadsInput {
    /** The ID of the agent whose threads to list and manage. */
    agentId: string | Signal<string>;
    /** When `true`, archived threads are included in the list. Defaults to `false`. */
    includeArchived?: boolean | Signal<boolean | undefined>;
    /** Maximum number of threads to fetch per page. When set, enables cursor-based pagination. */
    limit?: number | Signal<number | undefined>;
    /**
     * When `false`, the store stays inert: no runtime context is dispatched, so
     * NO thread-list fetch or realtime subscription is issued, and the
     * synthesized pre-connect loading state is suppressed. Used by gated
     * surfaces (e.g. an unlicensed `<copilotkit-threads-drawer>`) that must not touch
     * the network until the gate opens. Defaults to `true`. Mirrors react-core's
     * `UseThreadsInput.enabled`.
     */
    enabled?: boolean | Signal<boolean | undefined>;
}
/**
 * Signal-based threads-list API returned by {@link injectThreads}.
 *
 * The `threads` signal is kept in sync with the platform via a realtime
 * WebSocket subscription (when available) and is sorted most-recently-active
 * first. Mutation methods reject with an `Error` if the platform request
 * fails; `delete` additionally rolls back its optimistic removal.
 */
interface InjectThreadsResult {
    /**
     * Threads for the current user/agent pair, sorted most-recently-active
     * first. Updated in realtime when the platform pushes metadata events.
     * Includes archived threads only when `includeArchived` is set.
     */
    threads: Signal<Thread[]>;
    /**
     * `true` while the initial thread list is being fetched from the platform.
     * Subsequent realtime updates do not re-enter the loading state.
     */
    isLoading: Signal<boolean>;
    /**
     * The most recent error from fetching threads or executing a mutation, or
     * `null` when there is no error. Reset to `null` on the next successful
     * fetch.
     */
    error: Signal<Error | null>;
    /**
     * List/mutation errors only — excludes developer/config errors (missing
     * runtime URL, runtime without thread endpoints) so consumer UIs do not
     * surface dev strings to end users. Prefer this over `error` for
     * user-facing error display.
     */
    listError: Signal<Error | null>;
    /**
     * Error from the most recent FAILED next-page (fetch-more) load, or `null`.
     * Tracked separately from {@link InjectThreadsResult.listError} so a
     * paginated-load failure surfaces an inline "couldn't load more" affordance
     * while the loaded list stays visible. Cleared when a fetch-more is retried
     * or succeeds.
     */
    fetchMoreError: Signal<Error | null>;
    /**
     * `true` when there are more threads available to fetch via
     * {@link InjectThreadsResult.fetchMoreThreads}. Only meaningful when `limit`
     * is set.
     */
    hasMoreThreads: Signal<boolean>;
    /** `true` while a subsequent page of threads is being fetched. */
    isFetchingMoreThreads: Signal<boolean>;
    /**
     * `true` while at least one thread mutation (rename, archive, unarchive,
     * delete) is awaiting a server response. Mutations apply optimistically, so
     * this is primarily useful for disabling controls or showing a subtle
     * in-flight indicator.
     */
    isMutating: Signal<boolean>;
    /**
     * Fetch the next page of threads. No-op when
     * {@link InjectThreadsResult.hasMoreThreads} is `false` or a fetch is
     * already in progress.
     */
    fetchMoreThreads: () => void;
    /**
     * Re-fetch the thread list from the platform without clearing the current
     * list. Backs the drawer's error-state Retry and the Active/All filter
     * refetch. No-op until the runtime is connected.
     */
    refetchThreads: () => void;
    /**
     * Reset to a fresh, non-explicit client-side thread so the welcome screen
     * shows. Lazy creation: no row appears in {@link InjectThreadsResult.threads}
     * until the new thread's first run persists server-side.
     */
    startNewThread: () => void;
    /**
     * Rename a thread on the platform. Resolves when the server confirms the
     * update; rejects on failure.
     */
    renameThread: (threadId: string, name: string) => Promise<void>;
    /**
     * Archive a thread on the platform. Archived threads are excluded from
     * subsequent list results. Resolves when the server confirms the update;
     * rejects on failure.
     */
    archiveThread: (threadId: string) => Promise<void>;
    /**
     * Restore a previously archived thread on the platform. The thread
     * re-appears in default (non-archived) list results. Resolves when the
     * server confirms the update; rejects on failure.
     */
    unarchiveThread: (threadId: string) => Promise<void>;
    /**
     * Permanently delete a thread from the platform. This is irreversible.
     * Resolves when the server confirms deletion; rejects on failure (the
     * optimistic removal is rolled back).
     */
    deleteThread: (threadId: string) => Promise<void>;
}
/**
 * Owns a single core thread store, bridges its selector observables onto
 * Angular writable signals, keeps the store's runtime context in sync with the
 * ambient {@link CopilotKit} configuration, and registers/unregisters the
 * store with core for the active agent.
 *
 * One instance backs each {@link injectThreads} call. Tear-down (selector
 * unsubscribe, store stop, core unregister) runs on the host's
 * {@link DestroyRef}.
 */
declare class ThreadsStore implements InjectThreadsResult {
    #private;
    readonly threads: Signal<Thread[]>;
    readonly error: Signal<Error | null>;
    readonly listError: Signal<Error | null>;
    readonly fetchMoreError: Signal<Error>;
    readonly isLoading: Signal<boolean>;
    readonly hasMoreThreads: Signal<boolean>;
    readonly isFetchingMoreThreads: Signal<boolean>;
    readonly isMutating: Signal<boolean>;
    constructor(input: InjectThreadsInput, destroyRef: DestroyRef);
    readonly renameThread: (threadId: string, name: string) => Promise<void>;
    readonly archiveThread: (threadId: string) => Promise<void>;
    readonly unarchiveThread: (threadId: string) => Promise<void>;
    readonly deleteThread: (threadId: string) => Promise<void>;
    readonly fetchMoreThreads: () => void;
    readonly refetchThreads: () => void;
    readonly startNewThread: () => void;
    /** Unsubscribes all selector bridges and stops the underlying core store. */
    teardown(): void;
}
/**
 * Factory for {@link ThreadsStore} instances. Provided at the root so the
 * ambient {@link CopilotKit} configuration is resolved from the application's
 * injector.
 */
declare class CopilotkitThreadsFactory {
    /**
     * Creates a {@link ThreadsStore} bound to the given input and host
     * `DestroyRef`.
     *
     * @param input - Agent identifier and optional list controls.
     * @param destroyRef - Host lifetime; tears the store down on destroy.
     */
    create(input: InjectThreadsInput, destroyRef: DestroyRef): ThreadsStore;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotkitThreadsFactory, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CopilotkitThreadsFactory>;
}
/**
 * Angular threads-list API over the platform-agnostic core thread store —
 * the signal-based counterpart to react-core's `useThreads`.
 *
 * On creation the store fetches the thread list for the runtime-authenticated
 * user and the given `agentId`. When the Intelligence platform exposes a
 * WebSocket URL it also opens a realtime subscription so the `threads` signal
 * stays current without polling. Mutation methods return promises that resolve
 * once the platform confirms the operation and reject with an `Error` on
 * failure.
 *
 * Must be called within an injection context (component/directive constructor
 * or field initializer). The underlying store is torn down on the host's
 * `DestroyRef`.
 *
 * @param input - Agent identifier and optional list controls. Each field
 *   accepts a plain value or a `Signal`.
 * @returns Thread list state as signals plus stable mutation callbacks.
 *
 * @example
 * ```ts
 * @Component({ ... })
 * class ThreadList {
 *   readonly threads = injectThreads({ agentId: "agent-1" });
 * }
 * ```
 */
declare function injectThreads(input: InjectThreadsInput): InjectThreadsResult;

interface CopilotChatLabels {
    chatInputPlaceholder: string;
    chatInputToolbarStartTranscribeButtonLabel: string;
    chatInputToolbarCancelTranscribeButtonLabel: string;
    chatInputToolbarFinishTranscribeButtonLabel: string;
    chatInputToolbarAddButtonLabel: string;
    chatInputToolbarToolsButtonLabel: string;
    assistantMessageToolbarCopyCodeLabel: string;
    assistantMessageToolbarCopyCodeCopiedLabel: string;
    assistantMessageToolbarCopyMessageLabel: string;
    assistantMessageToolbarThumbsUpLabel: string;
    assistantMessageToolbarThumbsDownLabel: string;
    assistantMessageToolbarReadAloudLabel: string;
    assistantMessageToolbarRegenerateLabel: string;
    userMessageToolbarCopyMessageLabel: string;
    userMessageToolbarEditMessageLabel: string;
    chatDisclaimerText: string;
    welcomeMessageText: string;
}
declare const COPILOT_CHAT_DEFAULT_LABELS: CopilotChatLabels;
declare const COPILOT_CHAT_LABELS: InjectionToken<CopilotChatLabels>;
declare function injectChatLabels(): CopilotChatLabels;
declare function provideCopilotChatLabels(config: Partial<CopilotChatLabels>): Provider;

/**
 * Options for configuring the CopilotChat session.
 * Mirrors the React CopilotChatConfigurationProvider props so behaviour
 * is consistent across frameworks.
 */
interface CopilotChatConfigurationOptions {
    /**
     * The agent id to connect to.
     * When omitted the runtime's default agent is used.
     */
    agentId?: string;
    /**
     * An explicit thread id to resume.
     * When provided the session joins the existing thread instead of starting a
     * new one.
     */
    threadId?: string;
    /**
     * Whether the thread id was supplied explicitly by the host application.
     * Defaults to `false`, which seeds a non-explicit thread id that the runtime
     * may override.
     */
    hasExplicitThreadId?: boolean;
}
/**
 * Angular service that holds the runtime chat configuration state.
 *
 * Active-thread resolution mirrors the React
 * `CopilotChatConfigurationProvider` precedence (prop → override → minted)
 * without parent-provider branches (PR1 has no nested providers).
 */
declare class CopilotChatConfiguration {
    #private;
    /**
     * The resolved agent id for this chat session.
     * Falls back to {@link DEFAULT_AGENT_ID} when no agent id is provided.
     */
    readonly agentId: Signal<string>;
    /**
     * The resolved thread id for this chat session.
     *
     * Precedence (highest → lowest):
     * 1. Prop-driven `threadId` when `#propIsAuthoritative` is true.
     * 2. Imperative `#override` set by internal helpers.
     * 3. Non-authoritative seed `threadId` from options.
     * 4. Auto-minted UUID fallback.
     */
    readonly threadId: Signal<string>;
    /**
     * Whether the current thread id was supplied explicitly by the host
     * application (as opposed to being auto-minted or seeded without intent).
     */
    readonly hasExplicitThreadId: Signal<boolean>;
    /** Returns `true` when the host application controls the thread id via props. */
    protected get isControlled(): boolean;
    /**
     * Sets an imperative thread override.  No-ops when the session is
     * controlled by the host application via props.
     *
     * @param threadId - The thread id to activate.
     * @param explicit - Whether the override represents a deliberate user choice.
     */
    protected _setOverride(threadId: string, explicit: boolean): void;
    /**
     * Switches the active thread to the given id.
     *
     * By default the switch is treated as an explicit user-driven choice
     * (`explicit` defaults to `true`).  Pass `{ explicit: false }` to mark it as
     * a non-explicit seed that the runtime may replace.
     *
     * No-ops when the threadId is controlled by the host application via props.
     *
     * @param threadId - The thread id to activate.
     * @param options - Optional overrides; `explicit` defaults to `true`.
     */
    setActiveThreadId(threadId: string, options?: {
        explicit?: boolean;
    }): void;
    /**
     * Abandons the current thread and starts a fresh one by minting a new UUID.
     *
     * The new thread is marked as non-explicit so the runtime may assign a
     * server-side thread id once the first message is sent.
     *
     * No-ops when the threadId is controlled by the host application via props.
     */
    startNewThread(): void;
    /**
     * Read-only signal reflecting the current drawer open-state.
     *
     * @remarks
     * Consumed by {@link CopilotThreadsDrawer} to drive the element's controlled
     * `open` property; a future popup or sidebar component may also toggle it to
     * implement mobile mutual-exclusion between the drawer and other overlays.
     */
    readonly drawerOpen: Signal<boolean>;
    /**
     * Sets the drawer open-state imperatively.
     *
     * @remarks
     * Called by {@link CopilotThreadsDrawer} in response to the element's
     * `open-change` event to keep the shared open-state coordinated.
     *
     * @param open - `true` to mark the drawer as open, `false` to close it.
     */
    setDrawerOpen(open: boolean): void;
    /**
     * Computed signal that is `true` when at least one drawer instance has
     * registered itself via {@link registerDrawer}.
     */
    readonly drawerRegistered: Signal<boolean>;
    /**
     * Registers a drawer instance and returns an idempotent unregister function.
     *
     * Increments the internal drawer count so that {@link drawerRegistered}
     * becomes `true`. The returned function decrements the count when called;
     * calling it more than once is safe — subsequent calls are no-ops (guarded
     * by an `active` flag, floor at 0).
     *
     * @remarks
     * Called by {@link CopilotThreadsDrawer} on construction with cleanup on
     * destroy. Intended for future popup/sidebar coordination as well.
     *
     * @returns An idempotent cleanup function that unregisters this drawer.
     */
    registerDrawer(): () => void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatConfiguration, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CopilotChatConfiguration>;
}
/**
 * Injection token for the {@link CopilotChatConfiguration} service instance.
 * Use {@link injectChatConfiguration} to retrieve it from the injector.
 */
declare const COPILOT_CHAT_CONFIGURATION: InjectionToken<CopilotChatConfiguration>;
/**
 * Injection token for the raw {@link CopilotChatConfigurationOptions} value
 * supplied to {@link provideCopilotChatConfiguration}.
 */
declare const COPILOT_CHAT_CONFIGURATION_OPTIONS: InjectionToken<CopilotChatConfigurationOptions>;
/**
 * Registers the {@link CopilotChatConfiguration} service and its options into
 * the current injector.
 *
 * `CopilotChatConfiguration` is registered as the canonical class provider.
 * `COPILOT_CHAT_CONFIGURATION` is aliased to the same instance via
 * `useExisting`, so both `inject(COPILOT_CHAT_CONFIGURATION)` (via
 * {@link injectChatConfiguration}) and a direct `inject(CopilotChatConfiguration)`
 * resolve to the **same object** with shared signal state.
 *
 * @param options - Optional chat configuration overrides.
 * @returns An array of Angular providers to pass to `providers` or
 *   `TestBed.configureTestingModule`.
 */
declare function provideCopilotChatConfiguration(options?: CopilotChatConfigurationOptions): Provider[];
/**
 * Retrieves the {@link CopilotChatConfiguration} service from the current
 * injection context.
 *
 * Must be called inside an injection context (component constructor, factory
 * function, or `TestBed.runInInjectionContext`).
 */
declare function injectChatConfiguration(): CopilotChatConfiguration;

declare abstract class ChatState {
    abstract readonly inputValue: WritableSignal<string>;
    readonly attachments: WritableSignal<Attachment[]>;
    readonly attachmentsEnabled: Signal<boolean>;
    readonly attachmentsUploading: Signal<boolean>;
    readonly dragOver: WritableSignal<boolean>;
    readonly suggestions: WritableSignal<Suggestion[]>;
    readonly suggestionsLoading: WritableSignal<boolean>;
    readonly isTranscribing: WritableSignal<boolean>;
    abstract submitInput(value: string): void;
    abstract changeInput(value: string): void;
    selectSuggestion(_suggestion: Suggestion, _index: number): void;
    finishTranscription(_audioBlob: Blob): void | Promise<void>;
    addFile(): void;
    removeAttachment(_id: string): void;
    handleDragOver(_event: DragEvent): void;
    handleDragLeave(_event: DragEvent): void;
    handleDrop(_event: DragEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChatState, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChatState>;
}
declare function injectChatState(): ChatState;

interface TranscriptionResult {
    text: string;
    size: number;
    type: string;
}
interface TranscriptionErrorInfo {
    code: TranscriptionErrorCode;
    message: string;
    retryable: boolean;
}
declare class TranscriptionError extends Error {
    readonly info: TranscriptionErrorInfo;
    constructor(info: TranscriptionErrorInfo);
}
/**
 * Transcribe an audio blob via the CopilotKit runtime. Uses single-endpoint
 * (base64 JSON) or REST (multipart `/transcribe`) mode to match the transport
 * configured on the core.
 *
 * @throws {TranscriptionError} with typed error info on any failure.
 */
declare function transcribeAudio(core: CopilotKitCore, audioBlob: Blob, filename?: string): Promise<TranscriptionResult>;

interface ScrollState {
    isAtBottom: boolean;
    scrollTop: number;
    scrollHeight: number;
    clientHeight: number;
}
declare class ScrollPosition implements OnDestroy {
    private scrollDispatcher;
    private viewportRuler;
    private ngZone;
    private destroy$;
    private scrollStateSubject;
    scrollState$: Observable<ScrollState>;
    constructor(scrollDispatcher: ScrollDispatcher, viewportRuler: ViewportRuler, ngZone: NgZone);
    /**
     * Monitor scroll position of an element
     * @param element The element to monitor
     * @param threshold Pixels from bottom to consider "at bottom" (default 10)
     */
    monitorScrollPosition(element: ElementRef<HTMLElement> | HTMLElement, threshold?: number): Observable<ScrollState>;
    /**
     * Scroll element to bottom with smooth animation
     * @param element The element to scroll
     * @param smooth Whether to use smooth scrolling
     */
    scrollToBottom(element: ElementRef<HTMLElement> | HTMLElement, smooth?: boolean): void;
    /**
     * Check if element is at bottom
     * @param element The element to check
     * @param threshold Pixels from bottom to consider "at bottom"
     */
    isAtBottom(element: ElementRef<HTMLElement> | HTMLElement, threshold?: number): boolean;
    /**
     * Get current scroll state of element
     */
    getScrollState(element: HTMLElement, threshold: number): ScrollState;
    /**
     * Create a ResizeObserver for element size changes
     * @param element The element to observe
     * @param debounceMs Debounce time in milliseconds
     */
    observeResize(element: ElementRef<HTMLElement> | HTMLElement, debounceMs?: number): Observable<ResizeObserverEntry>;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScrollPosition, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScrollPosition>;
}

interface ResizeState {
    width: number;
    height: number;
    isResizing: boolean;
}
declare class ResizeObserverService implements OnDestroy {
    private ngZone;
    private destroy$;
    private observers;
    private resizeStates;
    private resizeTimeouts;
    constructor(ngZone: NgZone);
    /**
     * Observe element resize with debouncing and resizing state
     * @param element Element to observe
     * @param debounceMs Debounce time (default 250ms)
     * @param resizingDurationMs How long to show "isResizing" state (default 250ms)
     */
    observeElement(element: ElementRef<HTMLElement> | HTMLElement, debounceMs?: number, resizingDurationMs?: number): Observable<ResizeState>;
    /**
     * Stop observing an element
     * @param element Element to stop observing
     */
    unobserve(element: ElementRef<HTMLElement> | HTMLElement): void;
    /**
     * Get current size of element
     * @param element Element to measure
     */
    getCurrentSize(element: ElementRef<HTMLElement> | HTMLElement): {
        width: number;
        height: number;
    };
    /**
     * Get current resize state of element
     * @param element Element to check
     */
    getCurrentState(element: ElementRef<HTMLElement> | HTMLElement): ResizeState | null;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResizeObserverService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ResizeObserverService>;
}

/**
 * Utility function to merge Tailwind CSS classes
 * Combines clsx for conditional classes and tailwind-merge for proper Tailwind class merging
 */
declare function cn(...inputs: ClassValue[]): string;

interface ConnectAgentContextConfig {
    injector?: Injector;
}
/**
 * Connects context to the agent.
 *
 * @param context - The context (or reactive zero-argument accessor) to connect.
 * @param config - Optional configuration for connecting the context.
 */
declare function connectAgentContext(context: Context | (() => Context), config?: ConnectAgentContextConfig): void;

/**
 * Return value of {@link injectMemories}.
 *
 * The `memories` signal is the server-authoritative list for the current
 * runtime-authenticated user. It is hydrated from a REST snapshot and kept
 * current by realtime `memory_metadata` deltas pushed over the memory store's
 * own channel. Mutations resolve once the platform confirms the operation and
 * reject with an `Error` on failure.
 */
interface MemoriesController {
    /**
     * Memories for the current user, newest first. Updated in realtime when the
     * platform pushes `memory_metadata` events over the memory store's channel.
     */
    memories: Signal<Memory[]>;
    /**
     * `true` while the initial memory snapshot is being fetched. Subsequent
     * realtime updates do not re-enter the loading state.
     */
    isLoading: Signal<boolean>;
    /**
     * The most recent error from fetching memories or a mutation, or `null`
     * when there is no error. Cleared on the next fetch attempt, on a
     * successful fetch, when the runtime context changes, and on a successful
     * mutation (a failed mutation replaces it with that mutation's error).
     */
    error: Signal<Error | null>;
    /**
     * `true` when the platform memory routes are available. Set to `false`
     * after a 404 or 501, indicating memory is not supported by the current
     * runtime configuration.
     */
    isAvailable: Signal<boolean>;
    /**
     * Health of the realtime connection that streams live `memory_metadata`
     * deltas. Distinct from `isAvailable`/`error` (which describe the REST list
     * route): `"connecting"` while the socket opens/joins, `"connected"` once
     * live deltas are flowing, and `"unavailable"` once the socket permanently
     * gives up — at which point the list is a frozen snapshot. Lets a template
     * drop a "live" indicator instead of showing it over stale data.
     */
    realtimeStatus: Signal<MemoryRealtimeStatus>;
    /**
     * Re-fetch the memory snapshot from the platform. Resolves when the re-pull
     * succeeds; rejects if it fails or the store is torn down mid-flight.
     */
    refresh: () => Promise<void>;
    /**
     * Create a memory. Resolves to the stored memory (server-authoritative);
     * rejects on failure.
     */
    addMemory: (input: NewMemory) => Promise<Memory>;
    /**
     * Supersede a memory: the old memory is retired and a new one is created.
     * Resolves to the new memory (its `id` differs from the supplied `id`);
     * rejects on failure.
     *
     * Supersede is a FULL replacement, not a partial patch: `changes` is the
     * complete definition of the new memory. You must re-supply `content` and
     * `kind`, and an omitted `sourceThreadIds` resets the new memory's source
     * threads to empty — it does not preserve the prior memory's value.
     */
    updateMemory: (id: string, changes: MemoryChanges) => Promise<Memory>;
    /**
     * Retire a memory (non-lossy delete). Resolves when the server confirms;
     * rejects on failure.
     */
    removeMemory: (id: string) => Promise<void>;
}
/**
 * Angular injection function for listing and managing platform memories — the
 * signal-based counterpart to react-core's `useMemories`.
 *
 * Reads the user-scoped memory store owned and wired by `CopilotKitCore`. The
 * binding does not create, register, start, or stop the store: core owns its
 * lifecycle and opens its own `user_meta:memories:<joinCode>` channel, applying
 * `memory_metadata` deltas to the list. The binding only bridges the store's
 * selectors onto Angular signals and forwards the stable mutation callbacks.
 *
 * Mutations are server-authoritative: each resolves once the platform confirms
 * the operation and rejects with an `Error` on failure. You can still call
 * `refresh()` to re-pull the REST snapshot on demand.
 *
 * Must be called inside an injection context (component constructor, field
 * initializer, `inject` callback, or `TestBed.runInInjectionContext`) so the
 * selector→signal bridges (`toSignal`) tear down with the host.
 *
 * @returns Signals for memory state and stable mutation callbacks.
 *
 * @example
 * ```ts
 * import { injectMemories } from "@copilotkit/angular";
 *
 * @Component({ ... })
 * class MemoryList {
 *   readonly #m = injectMemories();
 *   memories = this.#m.memories;
 *   isLoading = this.#m.isLoading;
 *   isAvailable = this.#m.isAvailable;
 *
 *   remove(id: string) { this.#m.removeMemory(id); }
 * }
 * ```
 */
declare function injectMemories(): MemoriesController;

/**
 * Represents a value that can be used as a slot override.
 * Can be a component type or template reference only.
 * @internal - This type is for internal use only
 */
type SlotValue<T = any> = Type<T> | TemplateRef<T>;
/**
 * Configuration for a slot
 * @internal - This interface is for internal use only
 */
interface SlotConfig<T = any> {
    value?: SlotValue<T>;
    default?: Type<T>;
}
/**
 * Context passed to slot templates
 */
interface SlotContext<T = any> {
    $implicit: T;
    props?: Partial<T>;
    [key: string]: any;
}
/**
 * Slot registry entry
 * @internal - This interface is for internal use only
 */
interface SlotRegistryEntry<T = any> {
    component?: Type<T>;
    template?: TemplateRef<T>;
}
/**
 * Options for rendering a slot
 */
interface RenderSlotOptions<T = any> {
    slot?: SlotValue<T>;
    defaultComponent: Type<T>;
    props?: Partial<T>;
    injector?: any;
    outputs?: Record<string, (event: any) => void>;
}
/**
 * Injection token for slot configuration
 */
declare const SLOT_CONFIG: InjectionToken<ReadonlyMap<string, SlotRegistryEntry<any>>>;
/**
 * Type for components with slots
 */
type WithSlots<S extends Record<string, Type<any>>, Rest = object> = {
    [K in keyof S as `${string & K}Component`]?: Type<any>;
} & {
    [K in keyof S as `${string & K}Template`]?: TemplateRef<any>;
} & {
    [K in keyof S as `${string & K}Class`]?: string;
} & Rest;

/**
 * Renders a slot value into a ViewContainerRef.
 * This is the core utility for slot rendering.
 *
 * @param viewContainer - The ViewContainerRef to render into
 * @param options - Options for rendering the slot
 * @returns The created component or embedded view reference
 *
 * @example
 * ```typescript
 * export class MyComponent {
 *   @ViewChild('container', { read: ViewContainerRef }) container!: ViewContainerRef;
 *
 *   renderButton() {
 *     renderSlot(this.container, {
 *       slot: this.buttonOverride,
 *       defaultComponent: DefaultButton,
 *       props: { text: 'Click me' },
 *       outputs: { click: (event) => this.handleClick(event) }
 *     });
 *   }
 * }
 * ```
 */
declare function renderSlot<T = any>(viewContainer: ViewContainerRef, options: RenderSlotOptions<T>): ComponentRef<T> | EmbeddedViewRef<T> | null;
/**
 * Checks if a value is a component type.
 * Simplified check - rely on try/catch for actual validation.
 */
declare function isComponentType(value: any): boolean;
/**
 * Checks if a value is a valid slot value.
 */
declare function isSlotValue(value: any): value is SlotValue;
/**
 * Normalizes a slot value to a consistent format.
 */
declare function normalizeSlotValue<T = any>(value: SlotValue<T> | undefined, defaultComponent: Type<T> | undefined): SlotRegistryEntry<T>;
/**
 * Creates a slot configuration map for a component.
 *
 * @example
 * ```typescript
 * const slots = createSlotConfig({
    standalone: true,
*   sendButton: CustomSendButton,
 *   toolbar: 'custom-toolbar-class',
 *   footer: footerTemplate
 * }, {
 *   sendButton: DefaultSendButton,
 *   toolbar: DefaultToolbar,
 *   footer: DefaultFooter
 * });
 * ```
 */
declare function createSlotConfig<T extends Record<string, Type<any>>>(overrides: Partial<Record<keyof T, SlotValue>>, defaults: T): Map<keyof T, SlotRegistryEntry>;
/**
 * Provides slot configuration to child components via DI.
 *
 * @example
 * ```typescript
 * @Component({
  standalone: true,
*   providers: [
 *     provideSlots({
 *       sendButton: CustomSendButton,
 *       toolbar: CustomToolbar
 *     })
 *   ]
 * })
 * ```
 */
declare function provideSlots(slots: Record<string, Type<any>>): {
    provide: _angular_core.InjectionToken<ReadonlyMap<string, SlotRegistryEntry<any>>>;
    useValue: Map<string, SlotRegistryEntry<any>>;
};
/**
 * Gets slot configuration from DI.
 * Must be called within an injection context.
 *
 * @example
 * ```typescript
 * export class MyComponent {
 *   slots = getSlotConfig();
 *
 *   ngOnInit() {
 *     const sendButton = this.slots?.get('sendButton');
 *   }
 * }
 * ```
 */
declare function getSlotConfig(): ReadonlyMap<string, SlotRegistryEntry> | null;
/**
 * Creates a render function for a specific slot.
 * Useful for creating reusable slot renderers.
 *
 * @example
 * ```typescript
 * const renderSendButton = createSlotRenderer(
 *   DefaultSendButton,
 *   'sendButton'
 * );
 *
 * // Later in template
 * renderSendButton(this.viewContainer, this.sendButtonOverride);
 * ```
 */
declare function createSlotRenderer<T>(defaultComponent: Type<T>, slotName?: string): (viewContainer: ViewContainerRef, slot?: SlotValue<T>, props?: Partial<T>, outputs?: Record<string, (event: any) => void>) => ComponentRef<T> | EmbeddedViewRef<T>;

/**
 * @internal - This component is for internal use only.
 * Simple slot component for rendering custom content or defaults.
 * Supports templates and components only.
 *
 * @example
 * ```html
 * <!-- With template -->
 * <copilot-slot [slot]="sendButtonTemplate" [context]="buttonContext">
 *   <button class="default-btn">Default</button>
 * </copilot-slot>
 * ```
 */
declare class CopilotSlot implements OnInit, OnChanges {
    private viewContainer;
    private cdr;
    slot: _angular_core.InputSignal<Type<any> | TemplateRef<any>>;
    context: _angular_core.InputSignal<any>;
    defaultComponent: _angular_core.InputSignal<Type<any>>;
    outputs: _angular_core.InputSignal<Record<string, (event: any) => void>>;
    private slotContainer;
    private componentRef?;
    constructor(viewContainer: ViewContainerRef, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    isTemplate(value: any): value is TemplateRef<any>;
    private renderSlot;
    private updateComponentProps;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotSlot, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotSlot, "copilot-slot", never, { "slot": { "alias": "slot"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "defaultComponent": { "alias": "defaultComponent"; "required": false; "isSignal": true; }; "outputs": { "alias": "outputs"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * Directive to manage agent context in CopilotKit.
 * Automatically adds context on init, updates on changes, and removes on destroy.
 *
 * @example
 * ```html
 * <!-- With separate inputs -->
 * <div copilotkitAgentContext
 *      [description]="'User preferences'"
 *      [value]="userSettings">
 * </div>
 *
 * <!-- With context object -->
 * <div [copilotkitAgentContext]="contextObject">
 * </div>
 *
 * <!-- With dynamic values -->
 * <div copilotkitAgentContext
 *      description="Form state"
 *      [value]="formData$ | async">
 * </div>
 * ```
 */
declare class CopilotKitAgentContext implements OnInit, OnChanges, OnDestroy {
    private readonly copilotkit;
    private contextId?;
    constructor(copilotkit: CopilotKit);
    /**
     * Context object containing both description and value.
     * If provided, this takes precedence over individual inputs.
     */
    context?: Context;
    /**
     * Description of the context.
     * Used when context object is not provided.
     */
    description?: string;
    /**
     * Value of the context.
     * Used when context object is not provided.
     */
    value?: any;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /**
     * Adds the context to CopilotKit
     */
    private addContext;
    /**
     * Updates the context by removing the old one and adding a new one
     */
    private updateContext;
    /**
     * Removes the current context from CopilotKit
     */
    private removeContext;
    /**
     * Gets the context object from inputs
     */
    private getContext;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotKitAgentContext, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CopilotKitAgentContext, "[copilotkitAgentContext]", never, { "context": { "alias": "copilotkitAgentContext"; "required": false; }; "description": { "alias": "description"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
}

type ScrollBehavior = "smooth" | "instant" | "auto";
/**
 * Directive for implementing stick-to-bottom scroll behavior
 * Similar to the React use-stick-to-bottom library
 *
 * @example
 * ```html
 * <div copilotStickToBottom
 *      [enabled]="true"
 *      [threshold]="10"
 *      [initialBehavior]="'smooth'"
 *      [resizeBehavior]="'smooth'"
 *      (isAtBottomChange)="onBottomChange($event)">
 *   <!-- Content -->
 * </div>
 * ```
 */
declare class StickToBottom implements AfterViewInit, OnDestroy {
    enabled: _angular_core.InputSignal<boolean>;
    threshold: _angular_core.InputSignal<number>;
    initialBehavior: _angular_core.InputSignal<ScrollBehavior>;
    resizeBehavior: _angular_core.InputSignal<ScrollBehavior>;
    debounceMs: _angular_core.InputSignal<number>;
    isAtBottomChange: _angular_core.OutputEmitterRef<boolean>;
    scrollToBottomRequested: _angular_core.OutputEmitterRef<void>;
    private elementRef;
    private scrollService;
    private resizeService;
    private platformId;
    private destroy$;
    private contentElement?;
    private wasAtBottom;
    private hasInitialized;
    private userHasScrolled;
    private destroyed;
    constructor();
    ngAfterViewInit(): void;
    private setupScrollMonitoring;
    private setupResizeMonitoring;
    private setupContentMutationObserver;
    /**
     * Public method to scroll to bottom
     * Can be called from parent component
     */
    scrollToBottom(behavior?: ScrollBehavior): void;
    /**
     * Check if currently at bottom
     */
    isAtBottom(): boolean;
    /**
     * Get current scroll state
     */
    getScrollState(): {
        scrollTop: any;
        scrollHeight: any;
        clientHeight: any;
        isAtBottom: boolean;
    };
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StickToBottom, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<StickToBottom, "[copilotStickToBottom]", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "initialBehavior": { "alias": "initialBehavior"; "required": false; "isSignal": true; }; "resizeBehavior": { "alias": "resizeBehavior"; "required": false; "isSignal": true; }; "debounceMs": { "alias": "debounceMs"; "required": false; "isSignal": true; }; }, { "isAtBottomChange": "isAtBottomChange"; "scrollToBottomRequested": "scrollToBottomRequested"; }, never, never, true, never>;
}

declare class TooltipContent {
    private cdr;
    text: string;
    private _position;
    get position(): "above" | "below" | "left" | "right";
    set position(value: "above" | "below" | "left" | "right");
    constructor(cdr: ChangeDetectorRef);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipContent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipContent, "copilot-tooltip-content", never, {}, {}, never, never, true, never>;
}
declare class CopilotTooltip implements OnDestroy {
    tooltipText: string;
    tooltipPosition: "above" | "below" | "left" | "right";
    tooltipDelay: number;
    private overlay;
    private overlayPositionBuilder;
    private elementRef;
    private viewContainerRef;
    private overlayRef?;
    private tooltipTimeout?;
    private originalTitle?;
    onMouseEnter(): void;
    onMouseLeave(): void;
    private show;
    private hide;
    private getPositions;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotTooltip, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CopilotTooltip, "[copilotTooltip]", never, { "tooltipText": { "alias": "copilotTooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipDelay": { "alias": "tooltipDelay"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * CopilotChat component - Angular equivalent of React's <CopilotChat>
 * Provides a complete chat interface that wires an agent to the chat view
 *
 * @example
 * ```html
 * <copilot-chat [agentId]="'default'" [threadId]="'abc123'"></copilot-chat>
 * ```
 */
declare class CopilotChat extends ChatState {
    private readonly attachmentsDirective;
    readonly inputValue: _angular_core.WritableSignal<string>;
    readonly agentId: _angular_core.InputSignal<string>;
    readonly threadId: _angular_core.InputSignal<string>;
    readonly inputComponent: _angular_core.InputSignal<Type<any>>;
    /** Component used to render each assistant message in the prebuilt chat. */
    readonly assistantMessageComponent: _angular_core.InputSignal<Type<any>>;
    /** Template used to render each assistant message in the prebuilt chat. */
    readonly assistantMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Class forwarded to the default or custom assistant-message renderer. */
    readonly assistantMessageClass: _angular_core.InputSignal<string>;
    /** Component used to render each reasoning message in the prebuilt chat. */
    readonly reasoningMessageComponent: _angular_core.InputSignal<Type<any>>;
    /** Template used to render each reasoning message in the prebuilt chat. */
    readonly reasoningMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Class forwarded to the default or custom reasoning-message renderer. */
    readonly reasoningMessageClass: _angular_core.InputSignal<string>;
    /** Component rendered after the transcript messages and before the cursor. */
    readonly messageViewChildrenComponent: _angular_core.InputSignal<Type<any>>;
    /** Template rendered after the transcript messages and before the cursor. */
    readonly messageViewChildrenTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    /** Class forwarded to custom transcript-children renderers. */
    readonly messageViewChildrenClass: _angular_core.InputSignal<string>;
    readonly attachmentsConfig: _angular_core.InputSignal<AttachmentsConfig>;
    /**
     * Ambient chat configuration, when a {@link provideCopilotChatConfiguration}
     * provider is in scope. Absent (`null`) for standalone
     * `<copilot-chat [threadId]>` usage, which has no provider — resolved via the
     * optional inject so the component does not throw without one.
     */
    private readonly config;
    protected readonly resolvedAgentId: _angular_core.Signal<string>;
    readonly agentStore: _angular_core.Signal<_copilotkit_angular.AgentStore>;
    private readonly copilotKit;
    readonly cdr: ChangeDetectorRef;
    readonly injector: Injector;
    private readonly destroyRef;
    protected messages: _angular_core.Signal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    protected agentState: _angular_core.Signal<unknown>;
    protected isRunning: _angular_core.Signal<boolean>;
    protected readonly hasExplicitThreadId: _angular_core.Signal<boolean>;
    protected readonly agentRef: _angular_core.Signal<AbstractAgent>;
    protected readonly resolvedThreadId: _angular_core.Signal<string>;
    readonly attachmentsEnabled: _angular_core.Signal<boolean>;
    readonly attachmentsUploading: _angular_core.Signal<boolean>;
    protected showCursor: _angular_core.WritableSignal<boolean>;
    private generatedThreadId;
    constructor();
    private connectToAgent;
    submitInput(value: string): Promise<void>;
    selectSuggestion(suggestion: Suggestion, _index: number): Promise<void>;
    changeInput(value: string): void;
    finishTranscription(audioBlob: Blob): Promise<void>;
    private syncSuggestionsFromCore;
    addFile(): void;
    removeAttachment(id: string): void;
    handleDragOver(event: DragEvent): void;
    handleDragLeave(event: DragEvent): void;
    handleDrop(event: DragEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChat, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChat, "copilot-chat", never, { "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "threadId": { "alias": "threadId"; "required": false; "isSignal": true; }; "inputComponent": { "alias": "inputComponent"; "required": false; "isSignal": true; }; "assistantMessageComponent": { "alias": "assistantMessageComponent"; "required": false; "isSignal": true; }; "assistantMessageTemplate": { "alias": "assistantMessageTemplate"; "required": false; "isSignal": true; }; "assistantMessageClass": { "alias": "assistantMessageClass"; "required": false; "isSignal": true; }; "reasoningMessageComponent": { "alias": "reasoningMessageComponent"; "required": false; "isSignal": true; }; "reasoningMessageTemplate": { "alias": "reasoningMessageTemplate"; "required": false; "isSignal": true; }; "reasoningMessageClass": { "alias": "reasoningMessageClass"; "required": false; "isSignal": true; }; "messageViewChildrenComponent": { "alias": "messageViewChildrenComponent"; "required": false; "isSignal": true; }; "messageViewChildrenTemplate": { "alias": "messageViewChildrenTemplate"; "required": false; "isSignal": true; }; "messageViewChildrenClass": { "alias": "messageViewChildrenClass"; "required": false; "isSignal": true; }; "attachmentsConfig": { "alias": "attachments"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CopilotChatToolCallsView {
    readonly message: _angular_core.InputSignal<{
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    }>;
    readonly messages: _angular_core.InputSignal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    readonly agentId: _angular_core.InputSignal<string>;
    readonly isLoading: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatToolCallsView, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatToolCallsView, "copilot-chat-tool-calls-view", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface AssistantMessageMarkdownRendererContext {
    content: string;
}
interface AssistantMessageToolbarContext {
    children?: any;
}
interface AssistantMessageCopyButtonContext {
    content?: string;
}
interface ThumbsUpButtonContext {
}
interface ThumbsDownButtonContext {
}
interface ReadAloudButtonContext {
}
interface RegenerateButtonContext {
}
interface CopilotChatAssistantMessageOnThumbsUpProps {
    message: AssistantMessage;
}
interface CopilotChatAssistantMessageOnThumbsDownProps {
    message: AssistantMessage;
}
interface CopilotChatAssistantMessageOnReadAloudProps {
    message: AssistantMessage;
}
interface CopilotChatAssistantMessageOnRegenerateProps {
    message: AssistantMessage;
}

declare class CopilotChatAssistantMessageRenderer implements AfterViewInit {
    readonly content: _angular_core.InputSignal<string>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    markdownContainer?: ElementRef<HTMLDivElement>;
    private elementRef;
    private copyStates;
    readonly renderedHtml: _angular_core.Signal<string>;
    constructor();
    ngAfterViewInit(): void;
    private updateContent;
    private codeBlocksMap;
    private markedInstance;
    private initializeMarked;
    private renderMarkdown;
    private renderMathEquations;
    handleClick(event: MouseEvent): void;
    private copyCodeBlock;
    private generateBlockId;
    private escapeHtml;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessageRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAssistantMessageRenderer, "copilot-chat-assistant-message-renderer", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface CopilotIconNode {
    readonly tag: "path" | "rect";
    readonly attributes: Readonly<Record<string, string>>;
}
type CopilotIconData = readonly CopilotIconNode[];

declare class CopilotChatAssistantMessageToolbarButton {
    title: _angular_core.InputSignal<string>;
    disabled: _angular_core.InputSignal<boolean>;
    inputClass: _angular_core.InputSignal<string>;
    computedClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessageToolbarButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAssistantMessageToolbarButton, "button[copilotChatAssistantMessageToolbarButton]", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof CopilotTooltip; inputs: { "copilotTooltip": "title"; "tooltipPosition": "tooltipPosition"; "tooltipDelay": "tooltipDelay"; }; outputs: {}; }]>;
}
declare class CopilotChatAssistantMessageCopyButton {
    readonly title: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly content: _angular_core.InputSignal<string>;
    readonly clicked: _angular_core.OutputEmitterRef<void>;
    readonly CopyIcon: CopilotIconData;
    readonly CheckIcon: CopilotIconData;
    readonly copied: _angular_core.WritableSignal<boolean>;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    handleCopy(event?: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessageCopyButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAssistantMessageCopyButton, "copilot-chat-assistant-message-copy-button", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatAssistantMessageThumbsUpButton {
    readonly title: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly clicked: _angular_core.OutputEmitterRef<void>;
    readonly ThumbsUpIcon: CopilotIconData;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    handleClick(event?: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessageThumbsUpButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAssistantMessageThumbsUpButton, "copilot-chat-assistant-message-thumbs-up-button", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatAssistantMessageThumbsDownButton {
    readonly title: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly clicked: _angular_core.OutputEmitterRef<void>;
    readonly ThumbsDownIcon: CopilotIconData;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    handleClick(event?: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessageThumbsDownButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAssistantMessageThumbsDownButton, "copilot-chat-assistant-message-thumbs-down-button", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatAssistantMessageReadAloudButton {
    readonly title: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly clicked: _angular_core.OutputEmitterRef<void>;
    readonly Volume2Icon: CopilotIconData;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    handleClick(event?: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessageReadAloudButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAssistantMessageReadAloudButton, "copilot-chat-assistant-message-read-aloud-button", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatAssistantMessageRegenerateButton {
    readonly title: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly clicked: _angular_core.OutputEmitterRef<void>;
    readonly RefreshCwIcon: CopilotIconData;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    handleClick(event?: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessageRegenerateButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAssistantMessageRegenerateButton, "copilot-chat-assistant-message-regenerate-button", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

declare class CopilotChatAssistantMessageToolbar {
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly computedClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessageToolbar, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CopilotChatAssistantMessageToolbar, "[copilotChatAssistantMessageToolbar]", never, { "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CopilotChatViewHandlers {
    hasAssistantThumbsUpHandler: _angular_core.WritableSignal<boolean>;
    hasAssistantThumbsDownHandler: _angular_core.WritableSignal<boolean>;
    hasAssistantReadAloudHandler: _angular_core.WritableSignal<boolean>;
    hasAssistantRegenerateHandler: _angular_core.WritableSignal<boolean>;
    hasUserCopyHandler: _angular_core.WritableSignal<boolean>;
    hasUserEditHandler: _angular_core.WritableSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatViewHandlers, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CopilotChatViewHandlers>;
}

declare class CopilotChatAssistantMessage {
    markdownRendererTemplate?: TemplateRef<AssistantMessageMarkdownRendererContext>;
    toolbarTemplate?: TemplateRef<AssistantMessageToolbarContext>;
    copyButtonTemplate?: TemplateRef<AssistantMessageCopyButtonContext>;
    thumbsUpButtonTemplate?: TemplateRef<ThumbsUpButtonContext>;
    thumbsDownButtonTemplate?: TemplateRef<ThumbsDownButtonContext>;
    readAloudButtonTemplate?: TemplateRef<ReadAloudButtonContext>;
    regenerateButtonTemplate?: TemplateRef<RegenerateButtonContext>;
    toolCallsViewTemplate?: TemplateRef<any>;
    readonly markdownRendererClass: _angular_core.InputSignal<string>;
    readonly toolbarClass: _angular_core.InputSignal<string>;
    readonly copyButtonClass: _angular_core.InputSignal<string>;
    readonly thumbsUpButtonClass: _angular_core.InputSignal<string>;
    readonly thumbsDownButtonClass: _angular_core.InputSignal<string>;
    readonly readAloudButtonClass: _angular_core.InputSignal<string>;
    readonly regenerateButtonClass: _angular_core.InputSignal<string>;
    readonly toolCallsViewClass: _angular_core.InputSignal<string>;
    readonly markdownRendererComponent: _angular_core.InputSignal<Type<any>>;
    readonly toolbarComponent: _angular_core.InputSignal<Type<any>>;
    readonly copyButtonComponent: _angular_core.InputSignal<Type<any>>;
    readonly thumbsUpButtonComponent: _angular_core.InputSignal<Type<any>>;
    readonly thumbsDownButtonComponent: _angular_core.InputSignal<Type<any>>;
    readonly readAloudButtonComponent: _angular_core.InputSignal<Type<any>>;
    readonly regenerateButtonComponent: _angular_core.InputSignal<Type<any>>;
    readonly toolCallsViewComponent: _angular_core.InputSignal<Type<any>>;
    readonly message: _angular_core.InputSignal<{
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    }>;
    readonly messages: _angular_core.InputSignal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    readonly agentId: _angular_core.InputSignal<string>;
    readonly isLoading: _angular_core.InputSignal<boolean>;
    readonly additionalToolbarItems: _angular_core.InputSignal<TemplateRef<any>>;
    readonly toolbarVisible: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    handlers: CopilotChatViewHandlers;
    constructor(handlers?: CopilotChatViewHandlers | null);
    thumbsUp: _angular_core.OutputEmitterRef<CopilotChatAssistantMessageOnThumbsUpProps>;
    thumbsDown: _angular_core.OutputEmitterRef<CopilotChatAssistantMessageOnThumbsDownProps>;
    readAloud: _angular_core.OutputEmitterRef<CopilotChatAssistantMessageOnReadAloudProps>;
    regenerate: _angular_core.OutputEmitterRef<CopilotChatAssistantMessageOnRegenerateProps>;
    customClass: _angular_core.WritableSignal<string>;
    computedClass: _angular_core.Signal<string>;
    protected readonly defaultThumbsUpButtonComponent: typeof CopilotChatAssistantMessageThumbsUpButton;
    protected readonly defaultThumbsDownButtonComponent: typeof CopilotChatAssistantMessageThumbsDownButton;
    protected readonly CopilotChatAssistantMessageRenderer: typeof CopilotChatAssistantMessageRenderer;
    protected readonly CopilotChatAssistantMessageToolbar: typeof CopilotChatAssistantMessageToolbar;
    protected readonly CopilotChatAssistantMessageCopyButton: typeof CopilotChatAssistantMessageCopyButton;
    protected readonly CopilotChatToolCallsView: typeof CopilotChatToolCallsView;
    markdownRendererContext: _angular_core.Signal<AssistantMessageMarkdownRendererContext>;
    copyButtonOutputs: {
        clicked: () => void;
    };
    thumbsUpButtonOutputs: {
        clicked: () => void;
    };
    thumbsDownButtonOutputs: {
        clicked: () => void;
    };
    readAloudButtonOutputs: {
        clicked: () => void;
    };
    regenerateButtonOutputs: {
        clicked: () => void;
    };
    toolbarContext: _angular_core.Signal<AssistantMessageToolbarContext>;
    hasMessageContent(): boolean;
    toolCallsViewContext: _angular_core.Signal<{
        message: {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        };
        messages: ({
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        })[];
        isLoading: boolean;
    }>;
    handleCopy(): void;
    handleThumbsUp(): void;
    handleThumbsDown(): void;
    handleReadAloud(): void;
    handleRegenerate(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAssistantMessage, [{ optional: true; }]>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAssistantMessage, "copilot-chat-assistant-message", never, { "markdownRendererClass": { "alias": "markdownRendererClass"; "required": false; "isSignal": true; }; "toolbarClass": { "alias": "toolbarClass"; "required": false; "isSignal": true; }; "copyButtonClass": { "alias": "copyButtonClass"; "required": false; "isSignal": true; }; "thumbsUpButtonClass": { "alias": "thumbsUpButtonClass"; "required": false; "isSignal": true; }; "thumbsDownButtonClass": { "alias": "thumbsDownButtonClass"; "required": false; "isSignal": true; }; "readAloudButtonClass": { "alias": "readAloudButtonClass"; "required": false; "isSignal": true; }; "regenerateButtonClass": { "alias": "regenerateButtonClass"; "required": false; "isSignal": true; }; "toolCallsViewClass": { "alias": "toolCallsViewClass"; "required": false; "isSignal": true; }; "markdownRendererComponent": { "alias": "markdownRendererComponent"; "required": false; "isSignal": true; }; "toolbarComponent": { "alias": "toolbarComponent"; "required": false; "isSignal": true; }; "copyButtonComponent": { "alias": "copyButtonComponent"; "required": false; "isSignal": true; }; "thumbsUpButtonComponent": { "alias": "thumbsUpButtonComponent"; "required": false; "isSignal": true; }; "thumbsDownButtonComponent": { "alias": "thumbsDownButtonComponent"; "required": false; "isSignal": true; }; "readAloudButtonComponent": { "alias": "readAloudButtonComponent"; "required": false; "isSignal": true; }; "regenerateButtonComponent": { "alias": "regenerateButtonComponent"; "required": false; "isSignal": true; }; "toolCallsViewComponent": { "alias": "toolCallsViewComponent"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "additionalToolbarItems": { "alias": "additionalToolbarItems"; "required": false; "isSignal": true; }; "toolbarVisible": { "alias": "toolbarVisible"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "thumbsUp": "thumbsUp"; "thumbsDown": "thumbsDown"; "readAloud": "readAloud"; "regenerate": "regenerate"; }, ["markdownRendererTemplate", "toolbarTemplate", "copyButtonTemplate", "thumbsUpButtonTemplate", "thumbsDownButtonTemplate", "readAloudButtonTemplate", "regenerateButtonTemplate", "toolCallsViewTemplate"], never, true, never>;
}

declare class CopilotChatAttachmentQueue {
    readonly attachments: _angular_core.InputSignal<Attachment[]>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly removeAttachment: _angular_core.OutputEmitterRef<string>;
    readonly computedClass: _angular_core.Signal<string>;
    itemClass(attachment: Attachment): string;
    sourceUrl(attachment: Attachment): string;
    documentIcon(attachment: Attachment): string;
    fileSize(attachment: Attachment): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAttachmentQueue, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAttachmentQueue, "copilot-chat-attachment-queue", never, { "attachments": { "alias": "attachments"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "removeAttachment": "removeAttachment"; }, never, never, true, never>;
}

declare class CopilotChatAttachmentRenderer {
    readonly type: _angular_core.InputSignal<AttachmentModality>;
    readonly source: _angular_core.InputSignal<{
        type: "data";
        value: string;
        mimeType: string;
    } | {
        type: "url";
        value: string;
        mimeType?: string | undefined;
    }>;
    readonly filename: _angular_core.InputSignal<string>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly imageFailed: _angular_core.WritableSignal<boolean>;
    readonly sourceUrl: _angular_core.Signal<string>;
    readonly documentIcon: _angular_core.Signal<string>;
    readonly imageWrapperClass: _angular_core.Signal<string>;
    readonly failedImageClass: _angular_core.Signal<string>;
    readonly audioClass: _angular_core.Signal<string>;
    readonly videoClass: _angular_core.Signal<string>;
    readonly documentClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAttachmentRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAttachmentRenderer, "copilot-chat-attachment-renderer", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "source": { "alias": "source"; "required": true; "isSignal": true; }; "filename": { "alias": "filename"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CopilotChatAttachmentsDirective {
    readonly config: _angular_core.InputSignal<AttachmentsConfig>;
    private readonly chat;
    private readonly host;
    private readonly renderer;
    private readonly destroyRef;
    private fileInput?;
    private get enabled();
    onDragOver(event: DragEvent): void;
    onDragLeave(event: DragEvent): void;
    onDrop(event: DragEvent): Promise<void>;
    onPaste(event: ClipboardEvent): Promise<void>;
    openFilePicker(): void;
    removeAttachment(id: string): void;
    consume(): Attachment[];
    buildContent(value: string, attachments: Attachment[]): InputContent[];
    private ensureFileInput;
    private handleFileInputChange;
    private processFiles;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAttachmentsDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CopilotChatAttachmentsDirective, "[copilotChatAttachments]", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Mode of the chat input component
 */
type CopilotChatInputMode = "input" | "transcribe" | "processing";
/**
 * Represents a menu item in the tools menu
 */
type ToolsMenuItem = {
    label: string;
} & ({
    action: () => void;
    items?: never;
} | {
    action?: never;
    items: (ToolsMenuItem | "-")[];
});
/**
 * Audio recorder state
 */
type AudioRecorderState = "idle" | "recording" | "processing";
/**
 * Error class for audio recorder failures
 */
declare class AudioRecorderError extends Error {
    constructor(message: string);
}
/**
 * Props for textarea component
 */
interface CopilotChatTextareaProps {
    value?: string;
    placeholder?: string;
    maxRows?: number;
    autoFocus?: boolean;
    disabled?: boolean;
    onChange?: (value: string) => void;
    onKeyDown?: (event: KeyboardEvent) => void;
    inputClass?: string;
    style?: any;
    rows?: number;
    cols?: number;
    readonly?: boolean;
    spellcheck?: boolean;
    wrap?: "hard" | "soft" | "off";
}
/**
 * Props for button components
 */
interface CopilotChatButtonProps {
    disabled?: boolean;
    onClick?: () => void;
    inputClass?: string;
    style?: any;
    type?: "button" | "submit" | "reset";
    ariaLabel?: string;
    ariaPressed?: boolean;
    ariaExpanded?: boolean;
    title?: string;
}
/**
 * Props for toolbar button with tooltip
 */
interface CopilotChatToolbarButtonProps extends CopilotChatButtonProps {
    icon?: TemplateRef<any>;
    tooltip?: string;
    variant?: "primary" | "secondary";
}
/**
 * Props for tools menu button
 */
interface CopilotChatToolsButtonProps extends CopilotChatButtonProps {
    toolsMenu?: (ToolsMenuItem | "-")[];
}
/**
 * Props for audio recorder
 */
interface CopilotChatAudioRecorderProps {
    inputClass?: string;
    style?: any;
    onStateChange?: (state: AudioRecorderState) => void;
    showControls?: boolean;
    maxDuration?: number;
}
/**
 * Props for toolbar
 */
interface CopilotChatToolbarProps {
    inputClass?: string;
    style?: any;
    position?: "top" | "bottom";
    alignment?: "left" | "center" | "right" | "space-between";
}
/**
 * Slot configuration for chat input
 */
interface CopilotChatInputSlots {
    textArea?: Type<any> | TemplateRef<any>;
    sendButton?: Type<any> | TemplateRef<any>;
    startTranscribeButton?: Type<any> | TemplateRef<any>;
    cancelTranscribeButton?: Type<any> | TemplateRef<any>;
    finishTranscribeButton?: Type<any> | TemplateRef<any>;
    addFileButton?: Type<any> | TemplateRef<any>;
    toolsButton?: Type<any> | TemplateRef<any>;
    toolbar?: Type<any> | TemplateRef<any>;
    audioRecorder?: Type<any> | TemplateRef<any>;
}
/**
 * Input configuration for the chat input component
 */
interface CopilotChatInputConfig {
    mode?: CopilotChatInputMode;
    toolsMenu?: (ToolsMenuItem | "-")[];
    autoFocus?: boolean;
    additionalToolbarItems?: TemplateRef<any>;
    value?: string;
    class?: string;
}
/**
 * Output events for the chat input component
 */
interface CopilotChatInputOutputs {
    submitMessage: (value: string) => void;
    startTranscribe: () => void;
    cancelTranscribe: () => void;
    finishTranscribe: () => void;
    addFile: () => void;
    changeValue: (value: string) => void;
}

declare class CopilotChatAudioRecorder implements AfterViewInit {
    private readonly canvasRef;
    inputClass: _angular_core.InputSignal<string>;
    inputShowControls: _angular_core.InputSignal<boolean>;
    stateChange: _angular_core.OutputEmitterRef<AudioRecorderState>;
    error: _angular_core.OutputEmitterRef<AudioRecorderError>;
    readonly state: _angular_core.WritableSignal<AudioRecorderState>;
    readonly computedClass: _angular_core.Signal<string>;
    private mediaRecorder?;
    private stream?;
    private audioContext?;
    private analyser?;
    private audioChunks;
    private starting;
    private animationFrameId?;
    private amplitudeHistory;
    private scrollOffset;
    private smoothedAmplitude;
    private fadeOpacity;
    constructor();
    ngAfterViewInit(): void;
    /**
     * Request microphone access and start recording.
     */
    start(): Promise<void>;
    /**
     * Stop recording and resolve with the captured audio.
     */
    stop(): Promise<Blob>;
    getState(): AudioRecorderState;
    /**
     * Release every capture/animation resource. Safe to call repeatedly.
     */
    dispose(): void;
    private setState;
    private toRecorderError;
    private cleanup;
    /** RMS amplitude from time-domain samples (128 is silence). */
    private calculateAmplitude;
    private startAnimation;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAudioRecorder, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAudioRecorder, "copilot-chat-audio-recorder", never, { "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "inputShowControls": { "alias": "inputShowControls"; "required": false; "isSignal": true; }; }, { "stateChange": "stateChange"; "error": "error"; }, never, never, true, never>;
}

declare class CopilotChatSendButton {
    disabled: _angular_core.InputSignal<boolean>;
    clicked: _angular_core.OutputEmitterRef<void>;
    readonly ArrowUpIcon: CopilotIconData;
    buttonClass: string;
    onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatSendButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatSendButton, "copilot-chat-send-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatStartTranscribeButton {
    disabled: _angular_core.InputSignal<boolean>;
    clicked: _angular_core.OutputEmitterRef<void>;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    readonly MicIcon: CopilotIconData;
    buttonClass: string;
    get label(): string;
    onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatStartTranscribeButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatStartTranscribeButton, "copilot-chat-start-transcribe-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatCancelTranscribeButton {
    disabled: _angular_core.InputSignal<boolean>;
    clicked: _angular_core.OutputEmitterRef<void>;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    readonly XIcon: CopilotIconData;
    buttonClass: string;
    get label(): string;
    onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatCancelTranscribeButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatCancelTranscribeButton, "copilot-chat-cancel-transcribe-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatFinishTranscribeButton {
    disabled: _angular_core.InputSignal<boolean>;
    clicked: _angular_core.OutputEmitterRef<void>;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    readonly CheckIcon: CopilotIconData;
    buttonClass: string;
    get label(): string;
    onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatFinishTranscribeButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatFinishTranscribeButton, "copilot-chat-finish-transcribe-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatAddFileButton {
    disabled: _angular_core.InputSignal<boolean>;
    clicked: _angular_core.OutputEmitterRef<void>;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    readonly PlusIcon: CopilotIconData;
    buttonClass: string;
    get label(): string;
    onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatAddFileButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatAddFileButton, "copilot-chat-add-file-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatToolbarButton {
    disabled: _angular_core.InputSignal<boolean>;
    variant: _angular_core.InputSignal<"primary" | "secondary">;
    customClass: _angular_core.InputSignal<string>;
    title: _angular_core.InputSignal<string>;
    clicked: _angular_core.OutputEmitterRef<void>;
    computedClass: _angular_core.Signal<string>;
    onClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatToolbarButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatToolbarButton, "copilot-chat-toolbar-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "customClass": { "alias": "customClass"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
}

declare class CopilotChatTextarea implements AfterViewInit {
    private elementRef;
    private platformId;
    get textareaRef(): ElementRef<any>;
    inputValue: _angular_core.InputSignal<string>;
    inputPlaceholder: _angular_core.InputSignal<string>;
    inputMaxRows: _angular_core.InputSignal<number>;
    inputAutoFocus: _angular_core.InputSignal<boolean>;
    inputDisabled: _angular_core.InputSignal<boolean>;
    inputClass: _angular_core.InputSignal<string>;
    valueChange: _angular_core.OutputEmitterRef<string>;
    keyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
    readonly chatLabels: _copilotkit_angular.CopilotChatLabels;
    readonly chatState: _copilotkit_angular.ChatState;
    maxHeight: _angular_core.WritableSignal<number>;
    computedValue: _angular_core.Signal<string>;
    placeholder: _angular_core.Signal<string>;
    disabled: _angular_core.Signal<boolean>;
    computedClass: _angular_core.Signal<string>;
    constructor();
    ngAfterViewInit(): void;
    onInput(event: Event): void;
    onKeyDown(event: KeyboardEvent): void;
    private calculateMaxHeight;
    private adjustHeight;
    /**
     * Public method to focus the textarea
     */
    focus(): void;
    /**
     * Public method to get current value
     */
    getValue(): string;
    /**
     * Public method to set value programmatically
     */
    setValue(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatTextarea, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatTextarea, "textarea[copilotChatTextarea]", never, { "inputValue": { "alias": "inputValue"; "required": false; "isSignal": true; }; "inputPlaceholder": { "alias": "inputPlaceholder"; "required": false; "isSignal": true; }; "inputMaxRows": { "alias": "inputMaxRows"; "required": false; "isSignal": true; }; "inputAutoFocus": { "alias": "inputAutoFocus"; "required": false; "isSignal": true; }; "inputDisabled": { "alias": "inputDisabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "keyDown": "keyDown"; }, never, never, true, never>;
}

declare class CopilotChatToolbar {
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly computedClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatToolbar, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatToolbar, "div[copilotChatToolbar]", never, { "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class CopilotChatToolsMenu {
    readonly PlusIcon: CopilotIconData;
    readonly ChevronRightIcon: CopilotIconData;
    inputToolsMenu: _angular_core.InputSignal<(ToolsMenuItem | "-")[]>;
    inputDisabled: _angular_core.InputSignal<boolean>;
    inputClass: _angular_core.InputSignal<string>;
    inputAddFile: _angular_core.InputSignal<() => void>;
    private labels;
    toolsMenu: _angular_core.Signal<(ToolsMenuItem | "-")[]>;
    disabled: _angular_core.Signal<boolean>;
    customClass: _angular_core.Signal<string>;
    addFile: _angular_core.Signal<() => void>;
    menuItems: _angular_core.Signal<(ToolsMenuItem | "-")[]>;
    hasItems: _angular_core.Signal<boolean>;
    triggerDisabled: _angular_core.Signal<boolean>;
    readonly label: string;
    tooltipLabel: _angular_core.Signal<string>;
    buttonClass: _angular_core.Signal<string>;
    isMenuItem(item: any): item is ToolsMenuItem;
    handleItemClick(item: ToolsMenuItem): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatToolsMenu, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatToolsMenu, "copilot-chat-tools-menu", never, { "inputToolsMenu": { "alias": "inputToolsMenu"; "required": false; "isSignal": true; }; "inputDisabled": { "alias": "inputDisabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "inputAddFile": { "alias": "inputAddFile"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Context provided to slot templates
 */
interface SendButtonContext {
    send: () => void;
    disabled: boolean;
    value: string;
}
interface ToolbarContext {
    mode: CopilotChatInputMode;
    value: string;
}
declare class CopilotChatInput implements OnDestroy {
    readonly textAreaRef: _angular_core.Signal<CopilotChatTextarea>;
    readonly audioRecorderRef: _angular_core.Signal<CopilotChatAudioRecorder>;
    readonly sendButtonTemplate: _angular_core.Signal<TemplateRef<SendButtonContext>>;
    readonly toolbarTemplate: _angular_core.Signal<TemplateRef<ToolbarContext>>;
    readonly textAreaTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly audioRecorderTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly startTranscribeButtonTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly cancelTranscribeButtonTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly finishTranscribeButtonTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly addFileButtonTemplate: _angular_core.Signal<TemplateRef<any>>;
    readonly toolsButtonTemplate: _angular_core.Signal<TemplateRef<any>>;
    sendButtonClass: _angular_core.InputSignal<string>;
    toolbarClass: _angular_core.InputSignal<string>;
    textAreaClass: _angular_core.InputSignal<string>;
    textAreaMaxRows: _angular_core.InputSignal<number>;
    textAreaPlaceholder: _angular_core.InputSignal<string>;
    audioRecorderClass: _angular_core.InputSignal<string>;
    startTranscribeButtonClass: _angular_core.InputSignal<string>;
    cancelTranscribeButtonClass: _angular_core.InputSignal<string>;
    finishTranscribeButtonClass: _angular_core.InputSignal<string>;
    addFileButtonClass: _angular_core.InputSignal<string>;
    toolsButtonClass: _angular_core.InputSignal<string>;
    sendButtonComponent: _angular_core.InputSignal<Type<any>>;
    toolbarComponent: _angular_core.InputSignal<Type<any>>;
    textAreaComponent: _angular_core.InputSignal<Type<any>>;
    audioRecorderComponent: _angular_core.InputSignal<Type<any>>;
    startTranscribeButtonComponent: _angular_core.InputSignal<Type<any>>;
    cancelTranscribeButtonComponent: _angular_core.InputSignal<Type<any>>;
    finishTranscribeButtonComponent: _angular_core.InputSignal<Type<any>>;
    addFileButtonComponent: _angular_core.InputSignal<Type<any>>;
    toolsButtonComponent: _angular_core.InputSignal<Type<any>>;
    mode: _angular_core.InputSignal<CopilotChatInputMode>;
    toolsMenu: _angular_core.InputSignal<(ToolsMenuItem | "-")[]>;
    autoFocus: _angular_core.InputSignal<boolean>;
    value: _angular_core.InputSignal<string>;
    inputClass: _angular_core.InputSignal<string>;
    additionalToolbarItems: _angular_core.InputSignal<TemplateRef<any>>;
    submitMessage: _angular_core.OutputEmitterRef<string>;
    startTranscribe: _angular_core.OutputEmitterRef<void>;
    cancelTranscribe: _angular_core.OutputEmitterRef<void>;
    finishTranscribe: _angular_core.OutputEmitterRef<void>;
    finishTranscribeWithAudio: _angular_core.OutputEmitterRef<Blob>;
    addFile: _angular_core.OutputEmitterRef<void>;
    valueChange: _angular_core.OutputEmitterRef<string>;
    readonly ArrowUpIcon: CopilotIconData;
    readonly defaultButtonClass: string;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    readonly chatState: _copilotkit_angular.ChatState;
    modeSignal: _angular_core.WritableSignal<CopilotChatInputMode>;
    toolsMenuSignal: _angular_core.WritableSignal<(ToolsMenuItem | "-")[]>;
    autoFocusSignal: _angular_core.WritableSignal<boolean>;
    customClass: _angular_core.WritableSignal<string>;
    defaultAudioRecorder: typeof CopilotChatAudioRecorder;
    defaultSendButton: any;
    CopilotChatToolbar: typeof CopilotChatToolbar;
    CopilotChatAddFileButton: typeof CopilotChatAddFileButton;
    CopilotChatToolsMenu: typeof CopilotChatToolsMenu;
    CopilotChatCancelTranscribeButton: typeof CopilotChatCancelTranscribeButton;
    CopilotChatFinishTranscribeButton: typeof CopilotChatFinishTranscribeButton;
    CopilotChatStartTranscribeButton: typeof CopilotChatStartTranscribeButton;
    computedMode: _angular_core.Signal<CopilotChatInputMode>;
    computedToolsMenu: _angular_core.Signal<(ToolsMenuItem | "-")[]>;
    computedAutoFocus: _angular_core.Signal<boolean>;
    computedValue: _angular_core.Signal<string>;
    addFileButtonDisabled: _angular_core.Signal<boolean>;
    addFileMenuAction: _angular_core.Signal<() => void>;
    sendButtonDisabled: _angular_core.Signal<boolean>;
    computedClass: _angular_core.Signal<string>;
    defaultTextAreaClass: _angular_core.Signal<string>;
    sendButtonContext: _angular_core.Signal<SendButtonContext>;
    toolbarContext: _angular_core.Signal<ToolbarContext>;
    textAreaContext: _angular_core.Signal<{
        value: string;
        autoFocus: boolean;
        disabled: boolean;
        maxRows: number;
        placeholder: string;
        inputClass: string;
        onKeyDown: (event: KeyboardEvent) => void;
        onChange: (value: string) => void;
    }>;
    audioRecorderContext: _angular_core.Signal<{
        inputShowControls: boolean;
    }>;
    toolsContext: _angular_core.Signal<{
        inputToolsMenu: (ToolsMenuItem | "-")[];
        inputDisabled: boolean;
    }>;
    constructor();
    addFileButtonOutputs: {
        clicked: () => void;
    };
    cancelTranscribeButtonOutputs: {
        clicked: () => void;
    };
    finishTranscribeButtonOutputs: {
        clicked: () => Promise<void>;
    };
    startTranscribeButtonOutputs: {
        clicked: () => void;
    };
    sendButtonOutputs: {
        clicked: () => void;
        click: () => void;
    };
    ngOnDestroy(): void;
    handleKeyDown(event: KeyboardEvent): void;
    handleValueChange(value: string): void;
    send(): void;
    handleStartTranscribe(): void;
    handleCancelTranscribe(): void;
    handleFinishTranscribe(): Promise<void>;
    handleAddFile(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatInput, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatInput, "copilot-chat-input", never, { "sendButtonClass": { "alias": "sendButtonClass"; "required": false; "isSignal": true; }; "toolbarClass": { "alias": "toolbarClass"; "required": false; "isSignal": true; }; "textAreaClass": { "alias": "textAreaClass"; "required": false; "isSignal": true; }; "textAreaMaxRows": { "alias": "textAreaMaxRows"; "required": false; "isSignal": true; }; "textAreaPlaceholder": { "alias": "textAreaPlaceholder"; "required": false; "isSignal": true; }; "audioRecorderClass": { "alias": "audioRecorderClass"; "required": false; "isSignal": true; }; "startTranscribeButtonClass": { "alias": "startTranscribeButtonClass"; "required": false; "isSignal": true; }; "cancelTranscribeButtonClass": { "alias": "cancelTranscribeButtonClass"; "required": false; "isSignal": true; }; "finishTranscribeButtonClass": { "alias": "finishTranscribeButtonClass"; "required": false; "isSignal": true; }; "addFileButtonClass": { "alias": "addFileButtonClass"; "required": false; "isSignal": true; }; "toolsButtonClass": { "alias": "toolsButtonClass"; "required": false; "isSignal": true; }; "sendButtonComponent": { "alias": "sendButtonComponent"; "required": false; "isSignal": true; }; "toolbarComponent": { "alias": "toolbarComponent"; "required": false; "isSignal": true; }; "textAreaComponent": { "alias": "textAreaComponent"; "required": false; "isSignal": true; }; "audioRecorderComponent": { "alias": "audioRecorderComponent"; "required": false; "isSignal": true; }; "startTranscribeButtonComponent": { "alias": "startTranscribeButtonComponent"; "required": false; "isSignal": true; }; "cancelTranscribeButtonComponent": { "alias": "cancelTranscribeButtonComponent"; "required": false; "isSignal": true; }; "finishTranscribeButtonComponent": { "alias": "finishTranscribeButtonComponent"; "required": false; "isSignal": true; }; "addFileButtonComponent": { "alias": "addFileButtonComponent"; "required": false; "isSignal": true; }; "toolsButtonComponent": { "alias": "toolsButtonComponent"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "toolsMenu": { "alias": "toolsMenu"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "additionalToolbarItems": { "alias": "additionalToolbarItems"; "required": false; "isSignal": true; }; }, { "submitMessage": "submitMessage"; "startTranscribe": "startTranscribe"; "cancelTranscribe": "cancelTranscribe"; "finishTranscribe": "finishTranscribe"; "finishTranscribeWithAudio": "finishTranscribeWithAudio"; "addFile": "addFile"; "valueChange": "valueChange"; }, ["sendButtonTemplate", "toolbarTemplate", "textAreaTemplate", "audioRecorderTemplate", "startTranscribeButtonTemplate", "cancelTranscribeButtonTemplate", "finishTranscribeButtonTemplate", "addFileButtonTemplate", "toolsButtonTemplate"], never, true, never>;
}

/**
 * Default components used by CopilotChatInput.
 * These can be imported and reused when creating custom slot implementations.
 *
 * @example
 * ```typescript
 * import { CopilotChatInputDefaults } from '@copilotkit/angular';
 *
 * @Component({
 *   template: `
 *     <copilot-chat-input [sendButtonSlot]="CustomSendButton">
 *     </copilot-chat-input>
 *   `
 * })
 * export class MyComponent {
 *   CustomSendButton = class extends CopilotChatInputDefaults.SendButton {
 *     // Custom implementation
 *   };
 * }
 * ```
 */
declare class CopilotChatInputDefaults {
    static readonly TextArea: typeof CopilotChatTextarea;
    static readonly AudioRecorder: typeof CopilotChatAudioRecorder;
    static readonly SendButton: typeof CopilotChatSendButton;
    static readonly StartTranscribeButton: typeof CopilotChatStartTranscribeButton;
    static readonly CancelTranscribeButton: typeof CopilotChatCancelTranscribeButton;
    static readonly FinishTranscribeButton: typeof CopilotChatFinishTranscribeButton;
    static readonly AddFileButton: typeof CopilotChatAddFileButton;
    static readonly Toolbar: typeof CopilotChatToolbar;
    static readonly ToolsMenu: typeof CopilotChatToolsMenu;
}

interface CopilotChatUserMessageOnEditMessageProps {
    message: UserMessage;
}
interface CopilotChatUserMessageOnSwitchToBranchProps {
    message: UserMessage;
    branchIndex: number;
    numberOfBranches: number;
}
interface MessageRendererContext {
    content: string;
}
interface CopyButtonContext {
    content?: string;
    copied?: boolean;
}
interface EditButtonContext {
}
interface BranchNavigationContext {
    currentBranch: number;
    numberOfBranches: number;
    onSwitchToBranch?: (props: CopilotChatUserMessageOnSwitchToBranchProps) => void;
    message: UserMessage;
}
interface UserMessageToolbarContext {
    children?: any;
}

declare class CopilotChatUserMessageRenderer {
    readonly content: _angular_core.InputSignal<string>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly computedClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatUserMessageRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatUserMessageRenderer, "copilot-chat-user-message-renderer", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CopilotChatUserMessageToolbarButton {
    title: _angular_core.InputSignal<string>;
    disabled: _angular_core.InputSignal<boolean>;
    inputClass: _angular_core.InputSignal<string>;
    computedClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatUserMessageToolbarButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatUserMessageToolbarButton, "button[copilotChatUserMessageToolbarButton]", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof CopilotTooltip; inputs: { "copilotTooltip": "title"; "tooltipPosition": "tooltipPosition"; "tooltipDelay": "tooltipDelay"; }; outputs: {}; }]>;
}
declare class CopilotChatUserMessageCopyButton {
    readonly title: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly content: _angular_core.InputSignal<string>;
    readonly clicked: _angular_core.OutputEmitterRef<void>;
    readonly CopyIcon: CopilotIconData;
    readonly CheckIcon: CopilotIconData;
    readonly copied: _angular_core.WritableSignal<boolean>;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    handleCopy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatUserMessageCopyButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatUserMessageCopyButton, "copilot-chat-user-message-copy-button", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}
declare class CopilotChatUserMessageEditButton {
    title: _angular_core.InputSignal<string>;
    disabled: _angular_core.InputSignal<boolean>;
    inputClass: _angular_core.InputSignal<string>;
    clicked: _angular_core.OutputEmitterRef<void>;
    readonly EditIcon: CopilotIconData;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    handleEdit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatUserMessageEditButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatUserMessageEditButton, "copilot-chat-user-message-edit-button", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

declare class CopilotChatUserMessageToolbar {
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly computedClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatUserMessageToolbar, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatUserMessageToolbar, "div[copilotChatUserMessageToolbar]", never, { "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class CopilotChatUserMessageBranchNavigation {
    currentBranch: _angular_core.InputSignal<number>;
    numberOfBranches: _angular_core.InputSignal<number>;
    message: _angular_core.InputSignal<{
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    }>;
    inputClass: _angular_core.InputSignal<string>;
    switchToBranch: _angular_core.OutputEmitterRef<CopilotChatUserMessageOnSwitchToBranchProps>;
    readonly ChevronLeftIcon: CopilotIconData;
    readonly ChevronRightIcon: CopilotIconData;
    readonly buttonClass: string;
    showNavigation: _angular_core.Signal<boolean>;
    canGoPrev: _angular_core.Signal<boolean>;
    canGoNext: _angular_core.Signal<boolean>;
    computedClass: _angular_core.Signal<string>;
    handlePrevious(): void;
    handleNext(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatUserMessageBranchNavigation, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatUserMessageBranchNavigation, "copilot-chat-user-message-branch-navigation", never, { "currentBranch": { "alias": "currentBranch"; "required": false; "isSignal": true; }; "numberOfBranches": { "alias": "numberOfBranches"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "switchToBranch": "switchToBranch"; }, never, never, true, never>;
}

type UserMessageMediaPart = ImageInputPart | AudioInputPart | VideoInputPart | DocumentInputPart;

declare class CopilotChatUserMessage {
    messageRendererTemplate?: TemplateRef<MessageRendererContext>;
    toolbarTemplate?: TemplateRef<UserMessageToolbarContext>;
    copyButtonTemplate?: TemplateRef<CopyButtonContext>;
    editButtonTemplate?: TemplateRef<EditButtonContext>;
    branchNavigationTemplate?: TemplateRef<BranchNavigationContext>;
    messageRendererClass: _angular_core.InputSignal<string>;
    toolbarClass: _angular_core.InputSignal<string>;
    copyButtonClass: _angular_core.InputSignal<string>;
    editButtonClass: _angular_core.InputSignal<string>;
    branchNavigationClass: _angular_core.InputSignal<string>;
    messageRendererComponent: _angular_core.InputSignal<Type<any>>;
    toolbarComponent: _angular_core.InputSignal<Type<any>>;
    copyButtonComponent: _angular_core.InputSignal<Type<any>>;
    editButtonComponent: _angular_core.InputSignal<Type<any>>;
    branchNavigationComponent: _angular_core.InputSignal<Type<any>>;
    message: _angular_core.InputSignal<{
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    }>;
    branchIndex: _angular_core.InputSignal<number>;
    numberOfBranches: _angular_core.InputSignal<number>;
    additionalToolbarItems: _angular_core.InputSignal<TemplateRef<any>>;
    inputClass: _angular_core.InputSignal<string>;
    editMessage: _angular_core.OutputEmitterRef<CopilotChatUserMessageOnEditMessageProps>;
    switchToBranch: _angular_core.OutputEmitterRef<CopilotChatUserMessageOnSwitchToBranchProps>;
    branchIndexValue: _angular_core.Signal<number>;
    numberOfBranchesValue: _angular_core.Signal<number>;
    CopilotChatUserMessageRenderer: typeof CopilotChatUserMessageRenderer;
    CopilotChatUserMessageToolbar: typeof CopilotChatUserMessageToolbar;
    CopilotChatUserMessageCopyButton: typeof CopilotChatUserMessageCopyButton;
    CopilotChatUserMessageEditButton: typeof CopilotChatUserMessageEditButton;
    CopilotChatUserMessageBranchNavigation: typeof CopilotChatUserMessageBranchNavigation;
    showBranchNavigation: _angular_core.Signal<boolean>;
    computedClass: _angular_core.Signal<string>;
    flattenedContent: _angular_core.Signal<string>;
    mediaParts: _angular_core.Signal<UserMessageMediaPart[]>;
    messageRendererContext: _angular_core.Signal<MessageRendererContext>;
    copyButtonOutputs: {
        clicked: () => void;
    };
    editButtonOutputs: {
        clicked: () => void;
    };
    branchNavigationContext: _angular_core.Signal<BranchNavigationContext>;
    toolbarContext: _angular_core.Signal<UserMessageToolbarContext>;
    handleCopy(): void;
    handleEdit(): void;
    handleSwitchToBranch(props: CopilotChatUserMessageOnSwitchToBranchProps): void;
    filenameFor(part: UserMessageMediaPart): string | undefined;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatUserMessage, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatUserMessage, "copilot-chat-user-message", never, { "messageRendererClass": { "alias": "messageRendererClass"; "required": false; "isSignal": true; }; "toolbarClass": { "alias": "toolbarClass"; "required": false; "isSignal": true; }; "copyButtonClass": { "alias": "copyButtonClass"; "required": false; "isSignal": true; }; "editButtonClass": { "alias": "editButtonClass"; "required": false; "isSignal": true; }; "branchNavigationClass": { "alias": "branchNavigationClass"; "required": false; "isSignal": true; }; "messageRendererComponent": { "alias": "messageRendererComponent"; "required": false; "isSignal": true; }; "toolbarComponent": { "alias": "toolbarComponent"; "required": false; "isSignal": true; }; "copyButtonComponent": { "alias": "copyButtonComponent"; "required": false; "isSignal": true; }; "editButtonComponent": { "alias": "editButtonComponent"; "required": false; "isSignal": true; }; "branchNavigationComponent": { "alias": "branchNavigationComponent"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "branchIndex": { "alias": "branchIndex"; "required": false; "isSignal": true; }; "numberOfBranches": { "alias": "numberOfBranches"; "required": false; "isSignal": true; }; "additionalToolbarItems": { "alias": "additionalToolbarItems"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "editMessage": "editMessage"; "switchToBranch": "switchToBranch"; }, ["messageRendererTemplate", "toolbarTemplate", "copyButtonTemplate", "editButtonTemplate", "branchNavigationTemplate"], never, true, never>;
}

/**
 * Cursor component that matches the React implementation exactly.
 * Shows a pulsing dot animation to indicate activity.
 */
declare class CopilotChatMessageViewCursor {
    inputClass: _angular_core.InputSignal<string>;
    computedClass: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatMessageViewCursor, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatMessageViewCursor, "copilot-chat-message-view-cursor", never, { "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class CopilotChatReasoningMessage {
    readonly message: _angular_core.InputSignal<{
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    }>;
    readonly messages: _angular_core.InputSignal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    readonly isRunning: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    private readonly userToggled;
    protected readonly isLatest: _angular_core.Signal<boolean>;
    protected readonly isStreaming: _angular_core.Signal<boolean>;
    private readonly startTime;
    protected readonly open: _angular_core.WritableSignal<boolean>;
    protected readonly hasContent: _angular_core.Signal<boolean>;
    protected readonly reasoningContent: _angular_core.Signal<string>;
    protected readonly label: _angular_core.Signal<string>;
    protected readonly computedClass: _angular_core.Signal<string>;
    protected readonly headerClass: _angular_core.Signal<string>;
    protected readonly chevronClass: _angular_core.Signal<string>;
    protected toggle(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatReasoningMessage, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatReasoningMessage, "copilot-chat-reasoning-message", never, { "message": { "alias": "message"; "required": true; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "isRunning": { "alias": "isRunning"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * CopilotChatMessageView component - Angular port of the React component.
 * Renders a list of chat messages with support for custom slots and layouts.
 * DOM structure and Tailwind classes match the React implementation exactly.
 */
declare class CopilotChatMessageView {
    messages: _angular_core.InputSignal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    /** Current agent state exposed to transcript-children slots. */
    state: _angular_core.InputSignal<unknown>;
    showCursor: _angular_core.InputSignal<boolean>;
    isLoading: _angular_core.InputSignal<boolean>;
    inputClass: _angular_core.InputSignal<string>;
    agentId: _angular_core.InputSignal<string>;
    assistantMessageComponent: _angular_core.InputSignal<Type<any>>;
    assistantMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    assistantMessageClass: _angular_core.InputSignal<string>;
    reasoningMessageComponent: _angular_core.InputSignal<Type<any>>;
    reasoningMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    reasoningMessageClass: _angular_core.InputSignal<string>;
    childrenComponent: _angular_core.InputSignal<Type<any>>;
    childrenTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    childrenClass: _angular_core.InputSignal<string>;
    userMessageComponent: _angular_core.InputSignal<Type<any>>;
    userMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    userMessageClass: _angular_core.InputSignal<string>;
    cursorComponent: _angular_core.InputSignal<Type<any>>;
    cursorTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    cursorClass: _angular_core.InputSignal<string>;
    customLayoutTemplate?: TemplateRef<any>;
    assistantMessageThumbsUp: _angular_core.OutputEmitterRef<{
        message: Message$1;
    }>;
    assistantMessageThumbsDown: _angular_core.OutputEmitterRef<{
        message: Message$1;
    }>;
    assistantMessageReadAloud: _angular_core.OutputEmitterRef<{
        message: Message$1;
    }>;
    assistantMessageRegenerate: _angular_core.OutputEmitterRef<{
        message: Message$1;
    }>;
    userMessageCopy: _angular_core.OutputEmitterRef<{
        message: Message$1;
    }>;
    userMessageEdit: _angular_core.OutputEmitterRef<{
        message: Message$1;
    }>;
    protected readonly defaultAssistantComponent: typeof CopilotChatAssistantMessage;
    protected readonly defaultUserComponent: typeof CopilotChatUserMessage;
    protected readonly defaultReasoningComponent: typeof CopilotChatReasoningMessage;
    protected readonly defaultCursorComponent: typeof CopilotChatMessageViewCursor;
    protected readonly copilotKit: CopilotKit;
    protected messagesValue: _angular_core.Signal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    protected showCursorValue: _angular_core.Signal<boolean>;
    protected isLoadingValue: _angular_core.Signal<boolean>;
    protected lastMessage: _angular_core.Signal<{
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    }>;
    computedClass: _angular_core.Signal<string>;
    layoutContext: _angular_core.Signal<{
        isLoading: boolean;
        messages: ({
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        })[];
        showCursor: boolean;
        messageElements: ({
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        })[];
    }>;
    assistantMessageSlot: _angular_core.Signal<string | Type<any>>;
    userMessageSlot: _angular_core.Signal<string | Type<any>>;
    cursorSlot: _angular_core.Signal<string | Type<any>>;
    mergeAssistantProps(message: Message$1): {
        message: {
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        };
        messages: ({
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        })[];
        isLoading: boolean;
        inputClass: string;
    };
    mergeReasoningProps(message: ReasoningMessage): {
        message: {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        };
        messages: ({
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        })[];
        isRunning: boolean;
        inputClass: string;
    };
    childrenContext(): {
        messages: ({
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        })[];
        state: unknown;
        agentId: string;
        isRunning: boolean;
        inputClass: string;
    };
    mergeUserProps(message: Message$1): {
        message: {
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        };
        inputClass: string;
    };
    asReasoningMessage(message: Message$1): ReasoningMessage;
    trackByMessageId(index: number, message: Message$1): string;
    private pickActivityRenderer;
    protected resolveActivityRender(message: ActivityMessage$1): {
        component: Type<_copilotkit_angular.ActivityRenderer<unknown>>;
        inputs: {
            activityType: string;
            content: unknown;
            message: {
                role: "activity";
                content: Record<string, any>;
                id: string;
                activityType: string;
            };
            agent: _ag_ui_client.AbstractAgent;
        };
    };
    handleAssistantThumbsUp(event: {
        message: Message$1;
    }): void;
    handleAssistantThumbsDown(event: {
        message: Message$1;
    }): void;
    handleAssistantReadAloud(event: {
        message: Message$1;
    }): void;
    handleAssistantRegenerate(event: {
        message: Message$1;
    }): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatMessageView, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatMessageView, "copilot-chat-message-view", never, { "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "showCursor": { "alias": "showCursor"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "assistantMessageComponent": { "alias": "assistantMessageComponent"; "required": false; "isSignal": true; }; "assistantMessageTemplate": { "alias": "assistantMessageTemplate"; "required": false; "isSignal": true; }; "assistantMessageClass": { "alias": "assistantMessageClass"; "required": false; "isSignal": true; }; "reasoningMessageComponent": { "alias": "reasoningMessageComponent"; "required": false; "isSignal": true; }; "reasoningMessageTemplate": { "alias": "reasoningMessageTemplate"; "required": false; "isSignal": true; }; "reasoningMessageClass": { "alias": "reasoningMessageClass"; "required": false; "isSignal": true; }; "childrenComponent": { "alias": "childrenComponent"; "required": false; "isSignal": true; }; "childrenTemplate": { "alias": "childrenTemplate"; "required": false; "isSignal": true; }; "childrenClass": { "alias": "childrenClass"; "required": false; "isSignal": true; }; "userMessageComponent": { "alias": "userMessageComponent"; "required": false; "isSignal": true; }; "userMessageTemplate": { "alias": "userMessageTemplate"; "required": false; "isSignal": true; }; "userMessageClass": { "alias": "userMessageClass"; "required": false; "isSignal": true; }; "cursorComponent": { "alias": "cursorComponent"; "required": false; "isSignal": true; }; "cursorTemplate": { "alias": "cursorTemplate"; "required": false; "isSignal": true; }; "cursorClass": { "alias": "cursorClass"; "required": false; "isSignal": true; }; }, { "assistantMessageThumbsUp": "assistantMessageThumbsUp"; "assistantMessageThumbsDown": "assistantMessageThumbsDown"; "assistantMessageReadAloud": "assistantMessageReadAloud"; "assistantMessageRegenerate": "assistantMessageRegenerate"; "userMessageCopy": "userMessageCopy"; "userMessageEdit": "userMessageEdit"; }, ["customLayoutTemplate"], never, true, never>;
}

interface MessageViewContext {
    showCursor: boolean;
    messages: Message[];
    state: unknown;
    messageElements: any[];
}
interface CursorContext {
}
interface CopilotChatMessageViewProps {
    messages?: Message[];
    state?: unknown;
    showCursor?: boolean;
    inputClass?: string;
    assistantMessageComponent?: Type<any>;
    assistantMessageTemplate?: TemplateRef<any>;
    assistantMessageClass?: string;
    childrenComponent?: Type<any>;
    childrenTemplate?: TemplateRef<any>;
    childrenClass?: string;
    userMessageComponent?: Type<any>;
    userMessageTemplate?: TemplateRef<any>;
    userMessageClass?: string;
    cursorComponent?: Type<any>;
    cursorTemplate?: TemplateRef<any>;
    cursorClass?: string;
}

declare class CopilotChatSuggestionPill {
    readonly title: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly isLoading: _angular_core.InputSignal<boolean>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly clicked: _angular_core.OutputEmitterRef<void>;
    protected readonly computedClass: _angular_core.Signal<string>;
    handleClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatSuggestionPill, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatSuggestionPill, "copilot-chat-suggestion-pill", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "isLoading": { "alias": "isLoading"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

declare class CopilotChatSuggestionView {
    readonly suggestions: _angular_core.InputSignal<Suggestion[]>;
    readonly inputClass: _angular_core.InputSignal<string>;
    readonly selectSuggestion: _angular_core.OutputEmitterRef<{
        suggestion: Suggestion;
        index: number;
    }>;
    protected readonly computedClass: _angular_core.Signal<string>;
    handleSelect(suggestion: Suggestion, index: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatSuggestionView, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatSuggestionView, "copilot-chat-suggestion-view", never, { "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; }, { "selectSuggestion": "selectSuggestion"; }, never, never, true, never>;
}

/**
 * ScrollToBottomButton component for CopilotChatView
 * Matches React implementation exactly with same Tailwind classes
 */
declare class CopilotChatViewScrollToBottomButton {
    inputClass: _angular_core.InputSignal<string>;
    disabled: _angular_core.InputSignal<boolean>;
    onClick: _angular_core.InputSignal<() => void>;
    clicked: _angular_core.OutputEmitterRef<void>;
    protected readonly ChevronDown: CopilotIconData;
    get computedClass(): string;
    handleClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatViewScrollToBottomButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatViewScrollToBottomButton, "copilot-chat-view-scroll-to-bottom-button", never, { "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "onClick": { "alias": "onClick"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

/**
 * ScrollView component for CopilotChatView
 * Handles auto-scrolling and scroll position management
 */
declare class CopilotChatViewScrollView implements AfterViewInit, OnDestroy {
    private cdr;
    protected readonly chatState: ChatState;
    autoScroll: _angular_core.InputSignal<boolean>;
    inputContainerHeight: _angular_core.InputSignal<number>;
    isResizing: _angular_core.InputSignal<boolean>;
    inputClass: _angular_core.InputSignal<string>;
    messages: _angular_core.InputSignal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    /** Current agent state forwarded to message-view extension slots. */
    state: _angular_core.InputSignal<unknown>;
    agentId: _angular_core.InputSignal<string>;
    messageView: _angular_core.InputSignal<any>;
    messageViewClass: _angular_core.InputSignal<string>;
    assistantMessageComponent: _angular_core.InputSignal<Type<any>>;
    assistantMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    assistantMessageClass: _angular_core.InputSignal<string>;
    reasoningMessageComponent: _angular_core.InputSignal<Type<any>>;
    reasoningMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    reasoningMessageClass: _angular_core.InputSignal<string>;
    messageViewChildrenComponent: _angular_core.InputSignal<Type<any>>;
    messageViewChildrenTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    messageViewChildrenClass: _angular_core.InputSignal<string>;
    showCursor: _angular_core.InputSignal<boolean>;
    scrollToBottomButton: _angular_core.InputSignal<any>;
    scrollToBottomButtonClass: _angular_core.InputSignal<string>;
    assistantMessageThumbsUp: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    assistantMessageThumbsDown: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    assistantMessageReadAloud: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    assistantMessageRegenerate: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    userMessageCopy: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    userMessageEdit: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    scrollContainer?: ElementRef<HTMLElement>;
    contentContainer?: ElementRef<HTMLElement>;
    stickToBottomDirective?: StickToBottom;
    protected readonly defaultMessageViewComponent: typeof CopilotChatMessageView;
    protected readonly defaultScrollToBottomButtonComponent: typeof CopilotChatViewScrollToBottomButton;
    protected hasMounted: _angular_core.WritableSignal<boolean>;
    protected showScrollButton: _angular_core.WritableSignal<boolean>;
    protected isAtBottom: _angular_core.WritableSignal<boolean>;
    protected hasSuggestions: _angular_core.Signal<boolean>;
    protected paddingBottom: _angular_core.Signal<number>;
    protected computedClass: _angular_core.Signal<string>;
    private destroy$;
    private scrollPositionService;
    constructor();
    ngAfterViewInit(): void;
    /**
     * Handle isAtBottom change from StickToBottom directive
     */
    onIsAtBottomChange(isAtBottom: boolean): void;
    /**
     * Scroll to bottom for manual mode
     */
    scrollToBottom(): void;
    /**
     * Scroll to bottom for stick-to-bottom mode
     */
    scrollToBottomFromStick(): void;
    ngOnDestroy(): void;
    scrollToBottomOutputs: {
        clicked: () => void;
    };
    scrollToBottomFromStickOutputs: {
        clicked: () => void;
    };
    messageViewContext(): any;
    scrollToBottomContext(): any;
    scrollToBottomFromStickContext(): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatViewScrollView, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatViewScrollView, "copilot-chat-view-scroll-view", never, { "autoScroll": { "alias": "autoScroll"; "required": false; "isSignal": true; }; "inputContainerHeight": { "alias": "inputContainerHeight"; "required": false; "isSignal": true; }; "isResizing": { "alias": "isResizing"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "messageView": { "alias": "messageView"; "required": false; "isSignal": true; }; "messageViewClass": { "alias": "messageViewClass"; "required": false; "isSignal": true; }; "assistantMessageComponent": { "alias": "assistantMessageComponent"; "required": false; "isSignal": true; }; "assistantMessageTemplate": { "alias": "assistantMessageTemplate"; "required": false; "isSignal": true; }; "assistantMessageClass": { "alias": "assistantMessageClass"; "required": false; "isSignal": true; }; "reasoningMessageComponent": { "alias": "reasoningMessageComponent"; "required": false; "isSignal": true; }; "reasoningMessageTemplate": { "alias": "reasoningMessageTemplate"; "required": false; "isSignal": true; }; "reasoningMessageClass": { "alias": "reasoningMessageClass"; "required": false; "isSignal": true; }; "messageViewChildrenComponent": { "alias": "messageViewChildrenComponent"; "required": false; "isSignal": true; }; "messageViewChildrenTemplate": { "alias": "messageViewChildrenTemplate"; "required": false; "isSignal": true; }; "messageViewChildrenClass": { "alias": "messageViewChildrenClass"; "required": false; "isSignal": true; }; "showCursor": { "alias": "showCursor"; "required": false; "isSignal": true; }; "scrollToBottomButton": { "alias": "scrollToBottomButton"; "required": false; "isSignal": true; }; "scrollToBottomButtonClass": { "alias": "scrollToBottomButtonClass"; "required": false; "isSignal": true; }; }, { "assistantMessageThumbsUp": "assistantMessageThumbsUp"; "assistantMessageThumbsDown": "assistantMessageThumbsDown"; "assistantMessageReadAloud": "assistantMessageReadAloud"; "assistantMessageRegenerate": "assistantMessageRegenerate"; "userMessageCopy": "userMessageCopy"; "userMessageEdit": "userMessageEdit"; }, never, ["*"], true, never>;
}

/**
 * Feather component for CopilotChatView
 * Creates a gradient overlay effect between messages and input
 * Matches React implementation exactly with same Tailwind classes
 */
declare class CopilotChatViewFeather {
    inputClass: _angular_core.InputSignal<string>;
    style: _angular_core.InputSignal<{
        [key: string]: any;
    }>;
    get computedClass(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatViewFeather, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatViewFeather, "copilot-chat-view-feather", never, { "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Disclaimer component for CopilotChatView
 * Shows configurable disclaimer text below the input
 * Integrates with CopilotChatConfigurationService for labels
 */
declare class CopilotChatViewDisclaimer {
    inputClass: _angular_core.InputSignal<string>;
    text: _angular_core.InputSignal<string>;
    readonly labels: _copilotkit_angular.CopilotChatLabels;
    get disclaimerText(): string;
    get computedClass(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatViewDisclaimer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatViewDisclaimer, "copilot-chat-view-disclaimer", never, { "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * InputContainer component for CopilotChatView
 * Container for input and disclaimer components
 * Uses ForwardRef for DOM access
 */
declare class CopilotChatViewInputContainer extends ElementRef {
    readonly chatState: ChatState;
    inputContainerClass: _angular_core.InputSignal<string>;
    input: _angular_core.InputSignal<any>;
    inputClass: _angular_core.InputSignal<string>;
    disclaimer: _angular_core.InputSignal<any>;
    disclaimerText: _angular_core.InputSignal<string>;
    disclaimerClass: _angular_core.InputSignal<string>;
    protected readonly defaultInputComponent: typeof CopilotChatInput;
    protected readonly defaultDisclaimerComponent: typeof CopilotChatViewDisclaimer;
    constructor(elementRef: ElementRef);
    get computedClass(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatViewInputContainer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatViewInputContainer, "copilot-chat-view-input-container", never, { "inputContainerClass": { "alias": "inputContainerClass"; "required": false; "isSignal": true; }; "input": { "alias": "input"; "required": false; "isSignal": true; }; "inputClass": { "alias": "inputClass"; "required": false; "isSignal": true; }; "disclaimer": { "alias": "disclaimer"; "required": false; "isSignal": true; }; "disclaimerText": { "alias": "disclaimerText"; "required": false; "isSignal": true; }; "disclaimerClass": { "alias": "disclaimerClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * CopilotChatView component - Angular port of the React component.
 * A complete chat interface with message feed and input components.
 *
 * @example
 * ```html
 * <copilot-chat-view
 *   [messages]="messages"
 *   [autoScroll]="true"
 *   [messageViewProps]="{ assistantMessage: { onThumbsUp: handleThumbsUp } }">
 * </copilot-chat-view>
 * ```
 */
declare class CopilotChatView implements OnInit, OnChanges, AfterViewInit, OnDestroy {
    private resizeObserverService;
    private cdr;
    private handlers;
    protected readonly chatState: ChatState;
    protected readonly UploadIcon: CopilotIconData;
    messages: _angular_core.InputSignal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    /** Current agent state forwarded to message-view extension slots. */
    state: _angular_core.InputSignal<unknown>;
    agentId: _angular_core.InputSignal<string>;
    autoScroll: _angular_core.InputSignal<boolean>;
    showCursor: _angular_core.InputSignal<boolean>;
    hasExplicitThreadId: _angular_core.InputSignal<boolean>;
    messageViewComponent: _angular_core.InputSignal<Type<any>>;
    messageViewTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    messageViewClass: _angular_core.InputSignal<string>;
    assistantMessageComponent: _angular_core.InputSignal<Type<any>>;
    assistantMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    assistantMessageClass: _angular_core.InputSignal<string>;
    reasoningMessageComponent: _angular_core.InputSignal<Type<any>>;
    reasoningMessageTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    reasoningMessageClass: _angular_core.InputSignal<string>;
    messageViewChildrenComponent: _angular_core.InputSignal<Type<any>>;
    messageViewChildrenTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    messageViewChildrenClass: _angular_core.InputSignal<string>;
    scrollViewComponent: _angular_core.InputSignal<Type<any>>;
    scrollViewTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    scrollViewClass: _angular_core.InputSignal<string>;
    scrollToBottomButtonComponent: _angular_core.InputSignal<Type<any>>;
    scrollToBottomButtonTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    scrollToBottomButtonClass: _angular_core.InputSignal<string>;
    inputComponent: _angular_core.InputSignal<Type<any>>;
    inputTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    inputContainerComponent: _angular_core.InputSignal<Type<any>>;
    inputContainerTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    inputContainerClass: _angular_core.InputSignal<string>;
    featherComponent: _angular_core.InputSignal<Type<any>>;
    featherTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    featherClass: _angular_core.InputSignal<string>;
    disclaimerComponent: _angular_core.InputSignal<Type<any>>;
    disclaimerTemplate: _angular_core.InputSignal<TemplateRef<any>>;
    disclaimerClass: _angular_core.InputSignal<string>;
    disclaimerText: _angular_core.InputSignal<string>;
    customLayoutTemplate?: TemplateRef<any>;
    sendButtonTemplate?: TemplateRef<any>;
    toolbarTemplate?: TemplateRef<any>;
    textAreaTemplate?: TemplateRef<any>;
    audioRecorderTemplate?: TemplateRef<any>;
    assistantMessageMarkdownRendererTemplate?: TemplateRef<any>;
    thumbsUpButtonTemplate?: TemplateRef<any>;
    thumbsDownButtonTemplate?: TemplateRef<any>;
    readAloudButtonTemplate?: TemplateRef<any>;
    regenerateButtonTemplate?: TemplateRef<any>;
    assistantMessageThumbsUp: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    assistantMessageThumbsDown: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    assistantMessageReadAloud: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    assistantMessageRegenerate: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    userMessageCopy: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    userMessageEdit: _angular_core.OutputEmitterRef<{
        message: Message;
    }>;
    inputContainerSlotRef?: ElementRef;
    protected readonly defaultScrollViewComponent: typeof CopilotChatViewScrollView;
    protected readonly defaultScrollToBottomButtonComponent: typeof CopilotChatViewScrollToBottomButton;
    protected readonly defaultInputContainerComponent: typeof CopilotChatViewInputContainer;
    protected readonly defaultInputComponent: typeof CopilotChatInput;
    protected readonly defaultFeatherComponent: typeof CopilotChatViewFeather;
    protected readonly defaultDisclaimerComponent: typeof CopilotChatViewDisclaimer;
    protected readonly labels: _copilotkit_angular.CopilotChatLabels;
    protected messagesValue: _angular_core.Signal<({
        role: "developer";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "system";
        content: string;
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "assistant";
        id: string;
        name?: string | undefined;
        content?: string | undefined;
        encryptedValue?: string | undefined;
        toolCalls?: {
            function: {
                name: string;
                arguments: string;
            };
            type: "function";
            id: string;
            encryptedValue?: string | undefined;
        }[] | undefined;
    } | {
        role: "user";
        content: string | ({
            type: "text";
            text: string;
        } | {
            type: "image";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "audio";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "video";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "document";
            source: {
                type: "data";
                value: string;
                mimeType: string;
            } | {
                type: "url";
                value: string;
                mimeType?: string | undefined;
            };
            metadata?: unknown;
        } | {
            type: "binary";
            mimeType: string;
            id?: string | undefined;
            data?: string | undefined;
            url?: string | undefined;
            filename?: string | undefined;
        })[];
        id: string;
        name?: string | undefined;
        encryptedValue?: string | undefined;
    } | {
        role: "tool";
        toolCallId: string;
        content: string;
        id: string;
        encryptedValue?: string | undefined;
        error?: string | undefined;
    } | {
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    } | {
        role: "reasoning";
        content: string;
        id: string;
        encryptedValue?: string | undefined;
    })[]>;
    protected autoScrollSignal: _angular_core.Signal<boolean>;
    protected showCursorSignal: _angular_core.Signal<boolean>;
    protected disclaimerTextSignal: _angular_core.Signal<string>;
    protected disclaimerClassSignal: _angular_core.Signal<string>;
    protected inputContainerHeight: _angular_core.WritableSignal<number>;
    protected isResizing: _angular_core.WritableSignal<boolean>;
    protected shouldShowWelcomeScreen: _angular_core.Signal<boolean>;
    protected computedClass: _angular_core.Signal<string>;
    protected dropOverlayClass: _angular_core.Signal<string>;
    protected messageViewSlot: _angular_core.Signal<Type<any> | TemplateRef<any>>;
    protected scrollViewSlot: _angular_core.Signal<Type<any> | TemplateRef<any>>;
    protected scrollToBottomButtonSlot: _angular_core.Signal<Type<any> | TemplateRef<any>>;
    protected inputSlot: _angular_core.Signal<Type<any> | TemplateRef<any>>;
    protected inputContainerSlot: _angular_core.Signal<Type<any> | TemplateRef<any>>;
    protected featherSlot: _angular_core.Signal<Type<any> | TemplateRef<any>>;
    protected disclaimerSlot: _angular_core.Signal<Type<any> | TemplateRef<any>>;
    protected scrollViewContext: _angular_core.Signal<{
        autoScroll: boolean;
        scrollToBottomButton: Type<any> | TemplateRef<any>;
        scrollToBottomButtonClass: string;
        inputContainerHeight: number;
        isResizing: boolean;
        messages: ({
            role: "developer";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "system";
            content: string;
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "assistant";
            id: string;
            name?: string | undefined;
            content?: string | undefined;
            encryptedValue?: string | undefined;
            toolCalls?: {
                function: {
                    name: string;
                    arguments: string;
                };
                type: "function";
                id: string;
                encryptedValue?: string | undefined;
            }[] | undefined;
        } | {
            role: "user";
            content: string | ({
                type: "text";
                text: string;
            } | {
                type: "image";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "audio";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "video";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "document";
                source: {
                    type: "data";
                    value: string;
                    mimeType: string;
                } | {
                    type: "url";
                    value: string;
                    mimeType?: string | undefined;
                };
                metadata?: unknown;
            } | {
                type: "binary";
                mimeType: string;
                id?: string | undefined;
                data?: string | undefined;
                url?: string | undefined;
                filename?: string | undefined;
            })[];
            id: string;
            name?: string | undefined;
            encryptedValue?: string | undefined;
        } | {
            role: "tool";
            toolCallId: string;
            content: string;
            id: string;
            encryptedValue?: string | undefined;
            error?: string | undefined;
        } | {
            role: "activity";
            content: Record<string, any>;
            id: string;
            activityType: string;
        } | {
            role: "reasoning";
            content: string;
            id: string;
            encryptedValue?: string | undefined;
        })[];
        state: unknown;
        agentId: string;
        messageView: Type<any> | TemplateRef<any>;
        messageViewClass: string;
        assistantMessageComponent: Type<any>;
        assistantMessageTemplate: TemplateRef<any>;
        assistantMessageClass: string;
        reasoningMessageComponent: Type<any>;
        reasoningMessageTemplate: TemplateRef<any>;
        reasoningMessageClass: string;
        messageViewChildrenComponent: Type<any>;
        messageViewChildrenTemplate: TemplateRef<any>;
        messageViewChildrenClass: string;
    }>;
    protected inputContainerContext: _angular_core.Signal<{
        input: Type<any> | TemplateRef<any>;
        disclaimer: Type<any> | TemplateRef<any>;
        disclaimerText: string;
        disclaimerClass: string;
        inputContainerClass: string;
    }>;
    protected layoutContext: _angular_core.Signal<{
        messageView: Type<any> | TemplateRef<any>;
        input: Type<any> | TemplateRef<any>;
        scrollView: Type<any> | TemplateRef<any>;
        scrollToBottomButton: Type<any> | TemplateRef<any>;
        feather: Type<any> | TemplateRef<any>;
        inputContainer: Type<any> | TemplateRef<any>;
        disclaimer: Type<any> | TemplateRef<any>;
    }>;
    private destroy$;
    private resizeTimeoutRef?;
    private measurementRetryTimeoutRef?;
    private readonly ngZone;
    private destroyed;
    constructor(resizeObserverService: ResizeObserverService, cdr: ChangeDetectorRef, handlers: CopilotChatViewHandlers);
    ngOnInit(): void;
    ngOnChanges(): void;
    ngAfterViewInit(): void;
    /** Schedules a cancellable layout retry without triggering zone-wide ticks. */
    private scheduleMeasurementRetry;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotChatView, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotChatView, "copilot-chat-view", never, { "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "autoScroll": { "alias": "autoScroll"; "required": false; "isSignal": true; }; "showCursor": { "alias": "showCursor"; "required": false; "isSignal": true; }; "hasExplicitThreadId": { "alias": "hasExplicitThreadId"; "required": false; "isSignal": true; }; "messageViewComponent": { "alias": "messageViewComponent"; "required": false; "isSignal": true; }; "messageViewTemplate": { "alias": "messageViewTemplate"; "required": false; "isSignal": true; }; "messageViewClass": { "alias": "messageViewClass"; "required": false; "isSignal": true; }; "assistantMessageComponent": { "alias": "assistantMessageComponent"; "required": false; "isSignal": true; }; "assistantMessageTemplate": { "alias": "assistantMessageTemplate"; "required": false; "isSignal": true; }; "assistantMessageClass": { "alias": "assistantMessageClass"; "required": false; "isSignal": true; }; "reasoningMessageComponent": { "alias": "reasoningMessageComponent"; "required": false; "isSignal": true; }; "reasoningMessageTemplate": { "alias": "reasoningMessageTemplate"; "required": false; "isSignal": true; }; "reasoningMessageClass": { "alias": "reasoningMessageClass"; "required": false; "isSignal": true; }; "messageViewChildrenComponent": { "alias": "messageViewChildrenComponent"; "required": false; "isSignal": true; }; "messageViewChildrenTemplate": { "alias": "messageViewChildrenTemplate"; "required": false; "isSignal": true; }; "messageViewChildrenClass": { "alias": "messageViewChildrenClass"; "required": false; "isSignal": true; }; "scrollViewComponent": { "alias": "scrollViewComponent"; "required": false; "isSignal": true; }; "scrollViewTemplate": { "alias": "scrollViewTemplate"; "required": false; "isSignal": true; }; "scrollViewClass": { "alias": "scrollViewClass"; "required": false; "isSignal": true; }; "scrollToBottomButtonComponent": { "alias": "scrollToBottomButtonComponent"; "required": false; "isSignal": true; }; "scrollToBottomButtonTemplate": { "alias": "scrollToBottomButtonTemplate"; "required": false; "isSignal": true; }; "scrollToBottomButtonClass": { "alias": "scrollToBottomButtonClass"; "required": false; "isSignal": true; }; "inputComponent": { "alias": "inputComponent"; "required": false; "isSignal": true; }; "inputTemplate": { "alias": "inputTemplate"; "required": false; "isSignal": true; }; "inputContainerComponent": { "alias": "inputContainerComponent"; "required": false; "isSignal": true; }; "inputContainerTemplate": { "alias": "inputContainerTemplate"; "required": false; "isSignal": true; }; "inputContainerClass": { "alias": "inputContainerClass"; "required": false; "isSignal": true; }; "featherComponent": { "alias": "featherComponent"; "required": false; "isSignal": true; }; "featherTemplate": { "alias": "featherTemplate"; "required": false; "isSignal": true; }; "featherClass": { "alias": "featherClass"; "required": false; "isSignal": true; }; "disclaimerComponent": { "alias": "disclaimerComponent"; "required": false; "isSignal": true; }; "disclaimerTemplate": { "alias": "disclaimerTemplate"; "required": false; "isSignal": true; }; "disclaimerClass": { "alias": "disclaimerClass"; "required": false; "isSignal": true; }; "disclaimerText": { "alias": "disclaimerText"; "required": false; "isSignal": true; }; }, { "assistantMessageThumbsUp": "assistantMessageThumbsUp"; "assistantMessageThumbsDown": "assistantMessageThumbsDown"; "assistantMessageReadAloud": "assistantMessageReadAloud"; "assistantMessageRegenerate": "assistantMessageRegenerate"; "userMessageCopy": "userMessageCopy"; "userMessageEdit": "userMessageEdit"; }, ["customLayoutTemplate", "sendButtonTemplate", "toolbarTemplate", "textAreaTemplate", "audioRecorderTemplate", "assistantMessageMarkdownRendererTemplate", "thumbsUpButtonTemplate", "thumbsDownButtonTemplate", "readAloudButtonTemplate", "regenerateButtonTemplate"], never, true, never>;
}

/**
 * Props for CopilotChatView component
 */
interface CopilotChatViewProps {
    messages?: Message[];
    autoScroll?: boolean;
    messageViewComponent?: Type<any>;
    messageViewTemplate?: TemplateRef<any>;
    messageViewClass?: string;
    messageViewChildrenComponent?: Type<any>;
    messageViewChildrenTemplate?: TemplateRef<any>;
    messageViewChildrenClass?: string;
    scrollViewComponent?: Type<any>;
    scrollViewTemplate?: TemplateRef<any>;
    scrollViewClass?: string;
    scrollToBottomButtonComponent?: Type<any>;
    scrollToBottomButtonTemplate?: TemplateRef<any>;
    scrollToBottomButtonClass?: string;
    inputComponent?: Type<any>;
    inputTemplate?: TemplateRef<any>;
    inputContainerComponent?: Type<any>;
    inputContainerTemplate?: TemplateRef<any>;
    inputContainerClass?: string;
    featherComponent?: Type<any>;
    featherTemplate?: TemplateRef<any>;
    featherClass?: string;
    disclaimerComponent?: Type<any>;
    disclaimerTemplate?: TemplateRef<any>;
    disclaimerClass?: string;
    disclaimerText?: string;
}
/**
 * Context for custom layout template
 */
interface CopilotChatViewLayoutContext {
    messageView: any;
    input: any;
    scrollView: any;
    scrollToBottomButton: any;
    feather: any;
    inputContainer: any;
    disclaimer: any;
}

/**
 * Structural directive that captures a per-row template for projection into
 * the `<copilotkit-threads-drawer>` element as light-DOM children with
 * `slot="row:{id}"`.
 *
 * Apply it to an `<ng-template>` that is a direct child of `<copilot-threads-drawer>`.
 * The implicit context variable (`let-t`) receives the full {@link Thread}
 * record for that row.
 *
 * @example
 * ```html
 * <copilot-threads-drawer>
 *   <ng-template copilotThreadsDrawerRow let-t>
 *     <span>{{ t.name }}</span>
 *   </ng-template>
 * </copilot-threads-drawer>
 * ```
 */
declare class CopilotThreadsDrawerRow {
    /** The captured template reference for the per-row content. */
    readonly template: TemplateRef<any>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotThreadsDrawerRow, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CopilotThreadsDrawerRow, "[copilotThreadsDrawerRow]", never, {}, {}, never, never, true, never>;
}
/**
 * Angular wrapper around the `<copilotkit-threads-drawer>` Lit web component.
 *
 * Registers the custom element on construction (idempotent; SSR-guarded
 * internally by {@link defineCopilotKitThreadsDrawer}) and projects it into the DOM
 * via the `CUSTOM_ELEMENTS_SCHEMA`-enabled template.
 *
 * Thread list state is fetched from the Intelligence platform via
 * {@link injectThreads} and pushed onto the element's JS properties via an
 * `effect`, following the imperative property-assignment pattern used elsewhere
 * in this package (see `CopilotA2UIActivityRenderer`).
 *
 * DOM events emitted by the element are routed back to the chat configuration
 * and thread mutation methods via declarative Angular event bindings.
 *
 * @example
 * ```html
 * <copilot-threads-drawer data-testid="my-drawer" />
 * ```
 */
declare class CopilotThreadsDrawer {
    /**
     * Optional agent id whose threads this drawer lists/manages. Scopes the
     * {@link injectThreads} store (via the resolved-agent precedence: this input
     * → ambient config's `agentId` → {@link DEFAULT_AGENT_ID}). NOT forwarded to
     * the element (the element has no `agentId` property).
     */
    readonly agentId: _angular_core.InputSignal<string>;
    /**
     * Value applied as the `data-testid` attribute on the inner
     * `<copilotkit-threads-drawer>` element. Defaults to `"copilot-threads-drawer"`.
     */
    readonly dataTestId: _angular_core.InputSignal<string>;
    /**
     * Optional accessible/region + default-header label forwarded to the element's
     * `label` property; defaults to the element's own `"Threads"` when unset.
     */
    readonly label: _angular_core.InputSignal<string>;
    /**
     * Optional heading for the "Recent Conversations" section, forwarded to the
     * element's `recent-label` attribute; defaults to the element's own
     * `"Recent Conversations"` when unset.
     */
    readonly recentLabel: _angular_core.InputSignal<string>;
    /**
     * Whether the drawer offers a collapse toggle. Pushed onto the element's
     * `collapsible` PROPERTY (a default-true boolean, exactly like `licensed` — a
     * string attribute cannot represent it since any non-empty value is truthy).
     * When `false`, the drawer has no collapse toggle and is always expanded.
     * Defaults to the element's own `true` when unset.
     */
    readonly collapsible: _angular_core.InputSignal<boolean>;
    /**
     * Emits the new collapsed state whenever the drawer's collapsed state changes
     * (mirrors the element's `collapse-change` event).
     */
    readonly collapseChange: EventEmitter<boolean>;
    /**
     * Optional host override for the thread-select action.
     *
     * When provided, this callback is invoked instead of driving
     * `config.setActiveThreadId`. Bound via `[onThreadSelect]="fn"`.
     */
    readonly threadSelectHandler: _angular_core.InputSignal<(threadId: string) => void>;
    /**
     * Optional host override for the new-thread action.
     *
     * When provided, this callback is invoked instead of driving
     * `config.startNewThread`. The core `threads.startNewThread()` reset is
     * always called regardless. Bound via `[onNewThread]="fn"`.
     */
    readonly newThreadHandler: _angular_core.InputSignal<() => void>;
    /**
     * Page size for thread pagination. When set, threads load in pages of this
     * size and the element shows a "Load more" control while more remain. When
     * unset, the full list loads at once and no pagination control shows.
     */
    readonly limit: _angular_core.InputSignal<number>;
    /**
     * Destination the locked view's Upgrade CTA opens in a new tab. Forwarded to
     * the element's `licenseUrl` property; defaults to the element's built-in
     * CopilotKit Intelligence docs URL when unset. Set to an empty string to
     * suppress the default navigation and handle the click via `onLicensed`.
     */
    readonly licenseUrl: _angular_core.InputSignal<string>;
    /**
     * Optional host hook fired when the locked view's Upgrade CTA is clicked. The
     * element still performs its default navigation unless `licenseUrl` is blank;
     * use this for telemetry or to drive your own upgrade flow. Bound via
     * `[onLicensed]="fn"`.
     */
    readonly licensedHandler: _angular_core.InputSignal<() => void>;
    private readonly config;
    private readonly copilotkit;
    private readonly drawerRef;
    /**
     * Optional per-row template directive projected as a direct child of this
     * component. When present, a `<div slot="row:{id}">` is rendered inside the
     * `<copilotkit-threads-drawer>` element for each thread, allowing the host to inject
     * custom light-DOM content into each row slot.
     */
    protected readonly rowDirective: _angular_core.Signal<CopilotThreadsDrawerRow>;
    /**
     * The resolved agent id for the threads store. Precedence:
     * 1. `agentId` input prop.
     * 2. Ambient `CopilotChatConfiguration.agentId`.
     * 3. {@link DEFAULT_AGENT_ID}.
     */
    protected readonly resolvedAgentId: _angular_core.Signal<string>;
    /**
     * Normalized license context derived from the core's runtime-reported status,
     * via the same `@copilotkit/shared` helper the React provider uses.
     */
    private readonly licenseContext;
    /**
     * Two-pronged license gate, mirroring the React wrapper. `checkFeature` fails
     * OPEN (returns true) when no license is configured, so it cannot by itself
     * detect the no-license case; we therefore also require a positive
     * license-present signal. Only a resolved `valid`/`expiring` status counts as
     * present — a resolved `none`/`expired`/`invalid` gates the drawer to the
     * locked view.
     */
    protected readonly licensed: _angular_core.Signal<boolean>;
    /**
     * Whether the runtime has not yet reported a license status. The status is
     * `null` until the first `/info` response lands; treat that window as
     * "not yet unlicensed" — show the loading state, never the locked view — so a
     * licensed drawer never flashes (or strands) the Upgrade CTA mid-resolution.
     */
    protected readonly licensePending: _angular_core.Signal<boolean>;
    /** Live thread list from the Intelligence platform for the resolved agent. */
    protected readonly threads: _copilotkit_angular.InjectThreadsResult;
    /** Thread records mapped to the element's {@link DrawerThread} shape. */
    protected readonly drawerThreads: _angular_core.Signal<DrawerThread[]>;
    /**
     * User-facing error message from the filtered list error signal, or `null`
     * when there is no error. Uses `listError` (not `error`) so developer/config
     * errors (missing runtime URL, runtime without thread endpoints) are excluded
     * and never displayed to end users.
     */
    protected readonly errorMessage: _angular_core.Signal<string>;
    /**
     * The currently-active thread id, sourced from the ambient chat
     * configuration, or `null` when no configuration is present.
     */
    protected readonly activeThreadId: _angular_core.Signal<string>;
    /**
     * User-facing fetch-more error message from the dedicated fetch-more error
     * signal, or `null`. Drives the element's inline "couldn't load more — retry"
     * panel without disturbing the loaded list or the initial-list `error`.
     */
    protected readonly fetchMoreErrorMessage: _angular_core.Signal<string>;
    private readonly destroyRef;
    /**
     * Provider-less fallback open-state. Without a surrounding chat configuration
     * there is no shared open-state to bind to, so the wrapper keeps its own
     * local state. Starts CLOSED — matching the configuration's own default — so
     * the element does not spring open (and scroll-lock the page on mobile) on
     * load, and the element's `open-change` events still toggle it.
     */
    private readonly localDrawerOpen;
    /**
     * The effective drawer open-state: the ambient chat configuration's
     * `drawerOpen` when present, else the provider-less {@link localDrawerOpen}.
     * Pushed onto the element's controlled `open` property in the effect below.
     */
    protected readonly drawerOpen: _angular_core.Signal<boolean>;
    constructor();
    /**
     * Handles the `thread-selected` event from the drawer element.
     *
     * When a `threadSelectHandler` override is provided by the host, it is called
     * exclusively. Otherwise, the ambient chat configuration is driven directly so
     * a bare `<copilot-threads-drawer>` works without any host wiring.
     *
     * @param event - The raw DOM event; cast to `CustomEvent<ThreadSelectedDetail>` to extract `threadId`.
     */
    protected onThreadSelected(event: Event): void;
    /**
     * Handles the `open-change` event from the drawer element.
     *
     * Drives the ambient chat configuration's `setDrawerOpen` when present, else
     * the provider-less {@link localDrawerOpen} fallback — mirroring the React
     * and Vue wrappers so the element's open-state stays coordinated.
     *
     * @param event - The raw DOM event; cast to `CustomEvent<OpenChangeDetail>` to extract `open`.
     */
    protected onOpenChange(event: Event): void;
    /**
     * Handles the `new-thread` event from the drawer element.
     *
     * Always resets the core thread store to a fresh, non-explicit client-side
     * thread first. When a `newThreadHandler` override is provided by the host,
     * it is called exclusively. Otherwise, the ambient chat configuration is
     * driven directly so a bare `<copilot-threads-drawer>` works without any host wiring.
     */
    protected onNewThread(): void;
    /**
     * Handles the `archive` event from the drawer element.
     *
     * Delegates to the threads mutation and logs any failure to the console.
     *
     * @param event - The raw DOM event; cast to `CustomEvent<ArchiveDetail>` to extract `threadId`.
     */
    protected onArchive(event: Event): void;
    /**
     * Handles the `unarchive` event from the drawer element.
     *
     * Delegates to the threads mutation and logs any failure to the console.
     *
     * @param event - The raw DOM event; cast to `CustomEvent<UnarchiveDetail>` to extract `threadId`.
     */
    protected onUnarchive(event: Event): void;
    /**
     * Handles the `delete` event from the drawer element.
     *
     * Deleting the active thread resets to a fresh, non-explicit thread so the
     * user is not stranded on a now-gone conversation. Archiving the active
     * thread keeps the user viewing it.
     *
     * The core `threads.startNewThread()` reset is always called when the deleted
     * thread was active. When a `newThreadHandler` override is provided by the
     * host, it is called exclusively; otherwise the ambient chat configuration is
     * driven directly.
     *
     * @param event - The raw DOM event; cast to `CustomEvent<DeleteDetail>` to extract `threadId`.
     */
    protected onDelete(event: Event): void;
    /**
     * Handles the `filter-change` event from the drawer element.
     *
     * The element owns the Active/All filter; on change we refetch so the list
     * reflects the server.
     */
    protected onFilterChange(): void;
    /**
     * Handles the `collapse-change` event from the drawer element — re-emits the
     * new collapsed state through the component's `collapseChange` output so hosts
     * can observe (or persist) the drawer's collapsed state.
     *
     * @param event - The raw DOM event; cast to `CustomEvent<CollapseChangeDetail>` to extract `collapsed`.
     */
    protected onCollapseChange(event: Event): void;
    /**
     * Handles the `retry` event from the drawer element.
     *
     * `scope` distinguishes an initial fetch retry from a fetch-more retry so
     * the correct pagination operation is invoked.
     *
     * @param event - The raw DOM event; cast to `CustomEvent<RetryDetail>` to extract `scope`.
     */
    protected onRetry(event: Event): void;
    /**
     * Handles the `load-more` event from the drawer element — advances pagination
     * by fetching the next page. No-op when there is no next page (the element
     * only surfaces the "Load more" control while `hasMoreThreads` is true).
     */
    protected onLoadMore(): void;
    /**
     * Handles the `licensed` event from the drawer element (Upgrade CTA click).
     *
     * The element performs its own default navigation to `licenseUrl`; this hook
     * lets the host observe the click (e.g. for telemetry) or drive a custom
     * upgrade flow when provided via `[onLicensed]`.
     */
    protected onLicensed(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotThreadsDrawer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotThreadsDrawer, "copilot-threads-drawer", never, { "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "dataTestId": { "alias": "data-testid"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "recentLabel": { "alias": "recentLabel"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "threadSelectHandler": { "alias": "onThreadSelect"; "required": false; "isSignal": true; }; "newThreadHandler": { "alias": "onNewThread"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "licenseUrl": { "alias": "licenseUrl"; "required": false; "isSignal": true; }; "licensedHandler": { "alias": "onLicensed"; "required": false; "isSignal": true; }; }, { "collapseChange": "collapseChange"; }, ["rowDirective"], ["*"], true, never>;
}

/** Accessible, responsive floating chat surface with an explicit open model. */
declare class CopilotPopup {
    readonly open: _angular_core.ModelSignal<boolean>;
    readonly title: _angular_core.InputSignal<string>;
    readonly width: _angular_core.InputSignal<string | number>;
    readonly height: _angular_core.InputSignal<string | number>;
    readonly clickOutsideToClose: _angular_core.InputSignal<boolean>;
    readonly chatComponent: _angular_core.InputSignal<Type<unknown>>;
    readonly headerComponent: _angular_core.InputSignal<Type<unknown>>;
    protected readonly dialogId: string;
    protected readonly titleId: string;
    protected readonly resolvedWidth: _angular_core.Signal<string>;
    protected readonly resolvedHeight: _angular_core.Signal<string>;
    private readonly launcher;
    private readonly initialFocus;
    constructor();
    protected toggle(): void;
    protected closeFromBackdrop(): void;
    protected close(): void;
    private focusModal;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotPopup, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotPopup, "copilot-popup", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "clickOutsideToClose": { "alias": "clickOutsideToClose"; "required": false; "isSignal": true; }; "chatComponent": { "alias": "chatComponent"; "required": false; "isSignal": true; }; "headerComponent": { "alias": "headerComponent"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
}

type CopilotSidebarMode = "docked" | "overlay";
type CopilotSidebarPosition = "left" | "right";
/** Responsive chat sidebar with independent overlay and single-owner docked modes. */
declare class CopilotSidebar {
    readonly open: _angular_core.ModelSignal<boolean>;
    readonly mode: _angular_core.InputSignal<CopilotSidebarMode>;
    readonly position: _angular_core.InputSignal<CopilotSidebarPosition>;
    readonly width: _angular_core.InputSignal<string | number>;
    readonly title: _angular_core.InputSignal<string>;
    readonly clickOutsideToClose: _angular_core.InputSignal<boolean>;
    readonly chatComponent: _angular_core.InputSignal<Type<unknown>>;
    readonly headerComponent: _angular_core.InputSignal<Type<unknown>>;
    protected readonly sidebarId: string;
    protected readonly titleId: string;
    protected readonly resolvedWidth: _angular_core.Signal<string>;
    protected readonly isCompact: _angular_core.WritableSignal<boolean>;
    protected readonly isModal: _angular_core.Signal<boolean>;
    protected readonly dockAccepted: _angular_core.WritableSignal<boolean>;
    private readonly owner;
    private readonly registry;
    private readonly document;
    private readonly isBrowser;
    private readonly destroyRef;
    private readonly launcher;
    private readonly initialFocus;
    private ownsDock;
    constructor();
    protected toggle(): void;
    protected closeFromBackdrop(): void;
    protected close(): void;
    private releaseDock;
    private focusModal;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotSidebar, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotSidebar, "copilot-sidebar", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "clickOutsideToClose": { "alias": "clickOutsideToClose"; "required": false; "isSignal": true; }; "chatComponent": { "alias": "chatComponent"; "required": false; "isSignal": true; }; "headerComponent": { "alias": "headerComponent"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
}

type A2UIOperation = Record<string, unknown>;

declare class CopilotA2UIActivityRenderer implements ActivityRenderer<unknown> {
    readonly activityType: _angular_core.InputSignal<string>;
    readonly content: _angular_core.InputSignal<unknown>;
    readonly message: _angular_core.InputSignal<{
        role: "activity";
        content: Record<string, any>;
        id: string;
        activityType: string;
    }>;
    readonly agent: _angular_core.InputSignal<AbstractAgent>;
    private readonly surfaceRef;
    private readonly copilotKit;
    protected readonly config: _copilotkit_angular.CopilotKitConfig;
    private readonly platformId;
    private readonly zone;
    protected readonly operations: _angular_core.Signal<A2UIOperation[]>;
    protected readonly hasOperations: _angular_core.Signal<boolean>;
    protected readonly surfaceReady: _angular_core.WritableSignal<boolean>;
    protected readonly loaderContent: _angular_core.WritableSignal<unknown>;
    private readonly markSurfaceReady;
    constructor();
    protected handleAction(event: Event): Promise<void>;
    protected handleError(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotA2UIActivityRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotA2UIActivityRenderer, "copilot-a2ui-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>;
}

/**
 * Presentational loading placeholder shown while an A2UI tool call is still
 * streaming. Renders an animated skeleton card whose rows reveal as the
 * estimated token count climbs through `phase`.
 */
declare class CopilotA2UIProgress {
    readonly phase: _angular_core.InputSignal<number>;
    readonly tokens: _angular_core.InputSignal<number>;
    readonly label: _angular_core.InputSignal<string>;
    protected topbarBarClass(): string;
    protected rowClass(phase: number, delayClass: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotA2UIProgress, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotA2UIProgress, "copilot-a2ui-progress", never, { "phase": { "alias": "phase"; "required": true; "isSignal": true; }; "tokens": { "alias": "tokens"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type A2UIDebugExposure = "hidden" | "collapsed" | "verbose";
type A2UILifecycleStatus = "building" | "retrying" | "failed";
interface A2UILifecycleContent {
    status: A2UILifecycleStatus;
    attempt?: number;
    maxAttempts?: number;
    progressTokens?: number;
    error?: string;
    errors?: unknown[];
    attempts?: unknown[];
    debugExposure?: A2UIDebugExposure;
}
/** Read only the server-owned A2UI lifecycle fields from activity content. */
declare function readA2UILifecycleContent(content: unknown): A2UILifecycleContent;
/** Pre-paint building, retry, and failure UI for a stable A2UI activity. */
declare class CopilotA2UIRecovery {
    #private;
    readonly content: _angular_core.InputSignal<unknown>;
    readonly options: _angular_core.InputSignal<A2UIRecoveryOptions>;
    readonly lifecycle: _angular_core.Signal<A2UILifecycleContent>;
    readonly retryRevealed: _angular_core.WritableSignal<boolean>;
    readonly debugExposure: _angular_core.Signal<A2UIDebugExposure>;
    readonly label: _angular_core.Signal<string>;
    readonly phase: _angular_core.Signal<0 | 1 | 2 | 3>;
    readonly failureDiagnostics: _angular_core.Signal<string>;
    readonly retryDiagnostics: _angular_core.Signal<string>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotA2UIRecovery, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotA2UIRecovery, "copilot-a2ui-recovery", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const RENDER_A2UI_TOOL_NAME = "render_a2ui";
declare const AGUI_SEND_STATE_SNAPSHOT_TOOL_NAME = "AGUISendStateSnapshot";
declare const RenderA2UIArgsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
interface RenderA2UIArgs extends Record<string, unknown> {
    items?: unknown[];
    components?: unknown[];
    snapshot?: unknown;
}

declare class CopilotA2UIToolRenderer implements ToolRenderer<RenderA2UIArgs> {
    readonly toolCall: _angular_core.InputSignal<AngularToolCall<RenderA2UIArgs>>;
    readonly agent: _angular_core.InputSignal<AbstractAgent>;
    private readonly surfaceRef;
    private readonly config;
    private readonly copilotKit;
    protected readonly renderedOperations: _angular_core.Signal<A2UIOperation[]>;
    protected readonly tokens: _angular_core.Signal<number>;
    protected readonly phase: _angular_core.Signal<0 | 1 | 2 | 3>;
    protected readonly isHidden: _angular_core.Signal<boolean>;
    constructor();
    protected handleError(event: Event): void;
    protected handleAction(event: Event): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotA2UIToolRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotA2UIToolRenderer, "copilot-a2ui-tool-renderer", never, { "toolCall": { "alias": "toolCall"; "required": true; "isSignal": true; }; "agent": { "alias": "agent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type WebsandboxConstructor = typeof Websandbox;

declare const OPEN_GENERATIVE_UI_WEBSANDBOX_LOADER: InjectionToken<() => Promise<WebsandboxConstructor>>;
declare class CopilotOpenGenerativeUIRenderer implements OnChanges {
    readonly content: _angular_core.InputSignal<{
        html?: string[];
        initialHeight?: number;
        generating?: boolean;
        css?: string;
        cssComplete?: boolean;
        htmlComplete?: boolean;
        jsFunctions?: string;
        jsFunctionsComplete?: boolean;
        jsExpressions?: string[];
        jsExpressionsComplete?: boolean;
    }>;
    private readonly containerRef;
    private readonly destroyRef;
    private readonly config;
    private readonly loadWebsandboxModule;
    private readonly throttledContent;
    private throttleTimer;
    private latestContent;
    private sandbox;
    private previewSandbox;
    private sandboxReady;
    private previewReady;
    private finalSandboxKey;
    private executedExpressionIndex;
    private pendingQueue;
    private jsFunctionsInjected;
    private heightMeasured;
    private autoHeight;
    private hasReceivedContent;
    protected readonly fullHtml: _angular_core.Signal<string>;
    protected readonly css: _angular_core.Signal<string>;
    protected readonly partialHtml: _angular_core.Signal<string>;
    protected readonly previewBody: _angular_core.Signal<string>;
    protected readonly previewStyles: _angular_core.Signal<string>;
    protected readonly hasPreview: _angular_core.Signal<boolean>;
    protected readonly hasVisibleSandbox: _angular_core.Signal<boolean>;
    protected readonly height: _angular_core.Signal<number>;
    protected readonly isGenerating: _angular_core.Signal<boolean>;
    private readonly renderState;
    constructor();
    /** Applies input updates synchronously before the matching render pass. */
    ngOnChanges(): void;
    /** Commits content and synchronously removes stale sandbox DOM on restart. */
    private commitContent;
    private clearThrottle;
    private loadWebsandbox;
    private createLocalApi;
    private createPreviewSandbox;
    private updatePreviewSandbox;
    private reconcileSandboxState;
    private getFinalSandboxKey;
    private createFinalSandbox;
    private resetFinalRuntimeState;
    private injectJsFunctions;
    private executeNewExpressions;
    private runOrQueue;
    private measureFinalHeight;
    private styleIframe;
    private destroyPreviewSandbox;
    private destroyFinalSandbox;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotOpenGenerativeUIRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotOpenGenerativeUIRenderer, "copilot-open-generative-ui-renderer", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class CopilotOpenGenerativeUIActivityRenderer implements ActivityRenderer<OpenGenerativeUIContent> {
    readonly activityType: _angular_core.InputSignal<string>;
    readonly content: _angular_core.InputSignal<{
        html?: string[];
        initialHeight?: number;
        generating?: boolean;
        css?: string;
        cssComplete?: boolean;
        htmlComplete?: boolean;
        jsFunctions?: string;
        jsFunctionsComplete?: boolean;
        jsExpressions?: string[];
        jsExpressionsComplete?: boolean;
    }>;
    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<CopilotOpenGenerativeUIActivityRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotOpenGenerativeUIActivityRenderer, "copilot-open-generative-ui-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>;
}

declare class CopilotOpenGenerativeUIToolRenderer implements ToolRenderer<GenerateSandboxedUiArgs> {
    readonly toolCall: _angular_core.InputSignal<AngularToolCall<{
        html?: string;
        initialHeight?: number;
        css?: string;
        jsFunctions?: string;
        jsExpressions?: string[];
        placeholderMessages?: string[];
    }>>;
    private readonly visibleMessageIndex;
    private readonly destroyRef;
    private previousMessageCount;
    private interval;
    protected readonly visibleMessage: _angular_core.Signal<string>;
    constructor();
    private clearTimer;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopilotOpenGenerativeUIToolRenderer, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopilotOpenGenerativeUIToolRenderer, "copilot-open-generative-ui-tool-renderer", never, { "toolCall": { "alias": "toolCall"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { AGUI_SEND_STATE_SNAPSHOT_TOOL_NAME, AgentStore, AudioRecorderError, COPILOT_CHAT_CONFIGURATION, COPILOT_CHAT_CONFIGURATION_OPTIONS, COPILOT_CHAT_DEFAULT_LABELS, COPILOT_CHAT_LABELS, COPILOT_KIT_CONFIG, ChatState, CopilotA2UIActivityRenderer, CopilotA2UIProgress, CopilotA2UIRecovery, CopilotA2UIToolRenderer, CopilotChat, CopilotChatAddFileButton, CopilotChatAssistantMessage, CopilotChatAssistantMessageCopyButton, CopilotChatAssistantMessageReadAloudButton, CopilotChatAssistantMessageRegenerateButton, CopilotChatAssistantMessageRenderer, CopilotChatAssistantMessageThumbsDownButton, CopilotChatAssistantMessageThumbsUpButton, CopilotChatAssistantMessageToolbar, CopilotChatAssistantMessageToolbarButton, CopilotChatAttachmentQueue, CopilotChatAttachmentRenderer, CopilotChatAttachmentsDirective, CopilotChatAudioRecorder, CopilotChatCancelTranscribeButton, CopilotChatConfiguration, CopilotChatFinishTranscribeButton, CopilotChatInput, CopilotChatInputDefaults, CopilotChatMessageView, CopilotChatMessageViewCursor, CopilotChatReasoningMessage, CopilotChatSendButton, CopilotChatStartTranscribeButton, CopilotChatSuggestionPill, CopilotChatSuggestionView, CopilotChatTextarea, CopilotChatToolCallsView, CopilotChatToolbar, CopilotChatToolbarButton, CopilotChatToolsMenu, CopilotChatUserMessage, CopilotChatUserMessageBranchNavigation, CopilotChatUserMessageCopyButton, CopilotChatUserMessageEditButton, CopilotChatUserMessageRenderer, CopilotChatUserMessageToolbar, CopilotChatUserMessageToolbarButton, CopilotChatView, CopilotChatViewDisclaimer, CopilotChatViewFeather, CopilotChatViewHandlers, CopilotChatViewInputContainer, CopilotChatViewScrollToBottomButton, CopilotChatViewScrollView, CopilotDefaultToolRenderer, CopilotKit, CopilotKitAgentContext, CopilotOpenGenerativeUIActivityRenderer, CopilotOpenGenerativeUIRenderer, CopilotOpenGenerativeUIToolRenderer, CopilotPopup, CopilotSidebar, CopilotSlot, CopilotThreadsDrawer, CopilotThreadsDrawerRow, CopilotTooltip, CopilotkitAgentFactory, CopilotkitThreadsFactory, DEFAULT_OPEN_GENERATIVE_UI_DESIGN_SKILL, GENERATE_SANDBOXED_UI_DESCRIPTION, GENERATE_SANDBOXED_UI_TOOL_NAME, GenerateSandboxedUiArgsSchema, InterruptController, InterruptExpiredError, OPEN_GENERATIVE_UI_ACTIVITY_TYPE, OPEN_GENERATIVE_UI_WEBSANDBOX_LOADER, OpenGenerativeUIContentSchema, RENDER_A2UI_TOOL_NAME, RenderA2UIArgsSchema, RenderToolCalls, ResizeObserverService, SLOT_CONFIG, ScrollPosition, StickToBottom, ThreadsStore, TooltipContent, TranscriptionError, anyActivityContentSchema, cn, connectAgentContext, createSlotConfig, createSlotRenderer, getSlotConfig, injectAgentStore, injectChatConfiguration, injectChatLabels, injectChatState, injectCopilotKitConfig, injectInterrupt, injectMemories, injectThreads, isComponentType, isSlotValue, normalizeSlotValue, parseToolCallArguments, pickToolCallHandler, provideCopilotChatConfiguration, provideCopilotChatLabels, provideCopilotKit, provideSlots, readA2UILifecycleContent, registerFrontendTool, registerHumanInTheLoop, registerRenderActivityMessage, registerRenderToolCall, renderSlot, safeToolValue, transcribeAudio, ɵCOPILOTKIT_BUILT_IN_ACTIVITY_RENDERERS };
export type { A2UIConfig, A2UIDebugExposure, A2UILifecycleContent, A2UILifecycleStatus, A2UIRecoveryOptions, ActivityRenderer, AngularActivityContentParseResult, AngularActivityContentSchema, AngularToolCall, AssistantMessageCopyButtonContext, AssistantMessageMarkdownRendererContext, AssistantMessageToolbarContext, AudioRecorderState, BranchNavigationContext, ClientTool, ConnectAgentContextConfig, CopilotChatAssistantMessageOnReadAloudProps, CopilotChatAssistantMessageOnRegenerateProps, CopilotChatAssistantMessageOnThumbsDownProps, CopilotChatAssistantMessageOnThumbsUpProps, CopilotChatAudioRecorderProps, CopilotChatButtonProps, CopilotChatConfigurationOptions, CopilotChatInputConfig, CopilotChatInputMode, CopilotChatInputOutputs, CopilotChatInputSlots, CopilotChatLabels, CopilotChatMessageViewProps, CopilotChatTextareaProps, CopilotChatToolbarButtonProps, CopilotChatToolbarProps, CopilotChatToolsButtonProps, CopilotChatUserMessageOnEditMessageProps, CopilotChatUserMessageOnSwitchToBranchProps, CopilotChatViewLayoutContext, CopilotChatViewProps, CopilotKitConfig, CopilotSidebarMode, CopilotSidebarPosition, CopyButtonContext, CursorContext, EditButtonContext, FrontendToolConfig, GenerateSandboxedUiArgs, HumanInTheLoopConfig, HumanInTheLoopToolCall, HumanInTheLoopToolRenderer, InjectInterruptOptions, InjectThreadsInput, InjectThreadsResult, InterruptEvent, InterruptHandlerProps, InterruptRunOptions, InterruptRunner, InterruptView, MemoriesController, MessageRendererContext, MessageViewContext, OpenGenerativeUIConfig, OpenGenerativeUIContent, ReadAloudButtonContext, RegenerateButtonContext, RenderA2UIArgs, RenderActivityMessageConfig, RenderSlotOptions, RenderToolCallConfig, ResizeState, SandboxFunction, ScrollBehavior, ScrollState, SendButtonContext, SlotConfig, SlotContext, SlotRegistryEntry, SlotValue, Thread, ThumbsDownButtonContext, ThumbsUpButtonContext, ToolCallHandler, ToolRenderer, ToolbarContext, ToolsMenuItem, TranscriptionErrorInfo, TranscriptionResult, UserMessageToolbarContext, WithSlots };