import { TypedEventEmitter } from '../events/TypedEventEmitter';
import type { CrewxPlugin } from '../plugin';
import type { IFsAdapter } from '../platform/IFsAdapter';
import type { ChannelAdapterRegistration } from '../adapter/types';
import type { CrewxProjectConfig, AgentConfig, CrewxOptions, QueryOptions, QueryResult, ExecuteOptions, ExecuteResult } from '../types';
import type { TemplateContext } from '../template/types';
import type { CustomLayoutDefinition } from '../layout/types';
import type { TemplateMessage } from '../conversation/types';
import type { HandlerOptions, CrewxHandler } from '../server/handler';
import type { RemoteProviderConfig } from '../remote/types.js';
export interface ToolDefinition {
    name: string;
    description: string;
    parameters?: Record<string, unknown>;
    execute?: (args: Record<string, unknown>) => Promise<unknown>;
}
export type LayoutSpec = string | {
    id: string;
    props?: Record<string, any>;
} | {
    template: string;
};
export interface SkillEntry {
    metadata: {
        name: string;
        version: string;
        description: string;
    };
    filePath: string;
}
export interface RenderAgentPromptOptions {
    layout?: LayoutSpec;
    session?: {
        mode?: string;
        platform?: string;
        options?: string[];
    };
    env?: Record<string, string>;
    vars?: Record<string, unknown>;
    skills?: SkillEntry[];
    messages?: TemplateMessage[];
    threadId?: string;
}
export declare class Crewx extends TypedEventEmitter {
    private readonly _agents;
    private readonly _templateEngine;
    private readonly _documentLoader;
    private readonly _layoutLoader;
    private readonly _layoutRenderer;
    private readonly _config?;
    private readonly _projectRoot;
    private readonly _workspaceId;
    private readonly _workspaceName;
    private readonly _plugins;
    private readonly _tools;
    private readonly _activeAdapters;
    private readonly _pendingThreads;
    private readonly _remoteFactory?;
    private readonly _remoteTargets;
    private constructor();
    private resolveFileRemoteTarget;
    private static loadBuiltInConfig;
    private static mergeCrewxConfig;
    static loadYaml(path: string | undefined, options?: CrewxOptions, fsAdapter?: IFsAdapter): Promise<Crewx>;
    static fromConfig(config: CrewxProjectConfig, options?: CrewxOptions, projectRoot?: string, fsAdapter?: IFsAdapter): Promise<Crewx>;
    get agents(): ReadonlyMap<string, AgentConfig>;
    get config(): CrewxProjectConfig | undefined;
    get plugins(): readonly CrewxPlugin[];
    get tools(): ReadonlyMap<string, ToolDefinition>;
    get workspaceId(): string;
    get workspaceName(): string;
    getAgent(agentRef: string): AgentConfig | undefined;
    getRemoteProviderConfig(providerId: string): RemoteProviderConfig | undefined;
    private computeTaskLogPath;
    registerTool(name: string, definition: Omit<ToolDefinition, 'name'>): void;
    use(plugin: CrewxPlugin): Promise<void>;
    handler(options: HandlerOptions): CrewxHandler;
    registerChannelAdapter<TConfig = unknown>(reg: ChannelAdapterRegistration<TConfig>): Promise<void>;
    unregisterChannelAdapter(instanceId: string): Promise<void>;
    stopAllAdapters(opts?: {
        timeoutMs?: number;
    }): Promise<void>;
    close(): Promise<void>;
    filterAgents(filters: {
        role?: string;
        team?: string;
        provider?: string;
    }): AgentConfig[];
    renderAgentPrompt(agentId: string): string;
    renderPrompt(template: string, context?: TemplateContext): Promise<string>;
    registerLayout(name: string, template: string | CustomLayoutDefinition): void;
    renderAgentPromptFull(agentId: string, options?: RenderAgentPromptOptions): Promise<string>;
    private _filterToolsByMode;
    private _resolveLayoutSpec;
    private _extractLayoutId;
    private _extractLayoutProps;
    private _getConversationProvider;
    private _fetchHistoryMessages;
    private _resolveTimeout;
    private _lookupCliAdapter;
    private _resolveEffectiveCwd;
    private _buildFileRemoteOptions;
    private emitToolEvents;
    private emitTaskLogEntries;
    private tryParseJson;
    query(agentRef: string, message: string, options?: QueryOptions): Promise<QueryResult>;
    continueQuery(threadId: string, toolResults: Array<{
        toolCallId: string;
        result: unknown;
    }>): Promise<QueryResult>;
    execute(agentRef: string, message: string, options?: ExecuteOptions): Promise<ExecuteResult>;
}