/**
 * Planning System - Plans, Steps, and TodoLists
 *
 * Python parity with praisonaiagents/planning module
 */
/**
 * Read-only tools that are allowed in plan mode.
 * These tools only read data and don't modify anything.
 *
 * Python parity: praisonaiagents/planning/__init__.py:38-52
 */
export declare const READ_ONLY_TOOLS: readonly string[];
/**
 * Restricted tools that are blocked in plan mode.
 * These tools can modify files, execute commands, or have side effects.
 *
 * Python parity: praisonaiagents/planning/__init__.py:55-73
 */
export declare const RESTRICTED_TOOLS: readonly string[];
/**
 * Research tools that are safe for planning research.
 *
 * Python parity: praisonaiagents/planning/__init__.py:76-90
 */
export declare const RESEARCH_TOOLS: readonly string[];
/**
 * Configuration for ApprovalCallback.
 *
 * Python parity: praisonaiagents/planning/approval.py:27-58
 */
export interface ApprovalCallbackConfig {
    /** Whether to automatically approve all plans */
    autoApprove?: boolean;
    /** Custom approval function (sync or async) */
    approveFn?: (plan: Plan) => boolean | Promise<boolean>;
    /** Callback when plan is rejected */
    onReject?: (plan: Plan) => void;
}
/**
 * Callback for plan approval flow.
 *
 * Handles the approval process for plans before execution.
 * Can be configured for auto-approval or custom approval logic.
 *
 * Python parity: praisonaiagents/planning/approval.py:27-131
 *
 * @example
 * ```typescript
 * // Auto-approve all plans
 * const callback = new ApprovalCallback({ autoApprove: true });
 *
 * // Custom approval function
 * const callback = new ApprovalCallback({
 *   approveFn: (plan) => plan.steps.length <= 5
 * });
 * ```
 */
export declare class ApprovalCallback {
    private autoApprove;
    private approveFn?;
    private onReject?;
    constructor(config?: ApprovalCallbackConfig);
    /**
     * Synchronously check if plan is approved.
     */
    call(plan: Plan): boolean;
    /**
     * Asynchronously check if plan is approved.
     */
    asyncCall(plan: Plan): Promise<boolean>;
    /**
     * Always approve plans.
     */
    static alwaysApprove(_plan: Plan): boolean;
    /**
     * Always reject plans.
     */
    static alwaysReject(_plan: Plan): boolean;
    /**
     * Approve plans with few steps automatically.
     */
    static approveIfSmall(maxSteps?: number): (plan: Plan) => boolean;
    /**
     * Approve plans that don't use dangerous tools.
     */
    static approveIfNoDangerousTools(plan: Plan): boolean;
}
/**
 * Create an ApprovalCallback.
 */
export declare function createApprovalCallback(config?: ApprovalCallbackConfig): ApprovalCallback;
export type PlanStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
export type TodoStatus = 'pending' | 'in_progress' | 'completed';
export interface PlanConfig {
    name: string;
    description?: string;
    metadata?: Record<string, any>;
}
export interface PlanStepConfig {
    description: string;
    status?: PlanStatus;
    order?: number;
    dependencies?: string[];
    metadata?: Record<string, any>;
}
export interface TodoItemConfig {
    content: string;
    priority?: 'low' | 'medium' | 'high';
    status?: TodoStatus;
    dueDate?: Date;
    metadata?: Record<string, any>;
}
/**
 * PlanStep - A single step in a plan
 */
export declare class PlanStep {
    readonly id: string;
    description: string;
    status: PlanStatus;
    order: number;
    dependencies: string[];
    metadata: Record<string, any>;
    startedAt?: number;
    completedAt?: number;
    constructor(config: PlanStepConfig);
    start(): this;
    complete(): this;
    fail(): this;
    cancel(): this;
}
/**
 * Plan - A collection of steps to accomplish a goal
 */
export declare class Plan {
    readonly id: string;
    name: string;
    description?: string;
    steps: PlanStep[];
    status: PlanStatus;
    metadata: Record<string, any>;
    createdAt: number;
    updatedAt: number;
    constructor(config: PlanConfig);
    addStep(step: PlanStep): this;
    removeStep(stepId: string): boolean;
    getStep(stepId: string): PlanStep | undefined;
    getNextStep(): PlanStep | undefined;
    getProgress(): {
        completed: number;
        total: number;
        percentage: number;
    };
    start(): this;
    complete(): this;
}
/**
 * TodoItem - A single todo item
 */
export declare class TodoItem {
    readonly id: string;
    content: string;
    priority: 'low' | 'medium' | 'high';
    status: TodoStatus;
    dueDate?: Date;
    metadata: Record<string, any>;
    createdAt: number;
    completedAt?: number;
    constructor(config: TodoItemConfig);
    start(): this;
    complete(): this;
    reset(): this;
}
/**
 * TodoList - A collection of todo items
 */
export declare class TodoList {
    readonly id: string;
    name: string;
    items: TodoItem[];
    createdAt: number;
    constructor(name?: string);
    add(item: TodoItem): this;
    remove(itemId: string): boolean;
    get(itemId: string): TodoItem | undefined;
    getPending(): TodoItem[];
    getCompleted(): TodoItem[];
    getByPriority(priority: 'low' | 'medium' | 'high'): TodoItem[];
    getProgress(): {
        completed: number;
        total: number;
        percentage: number;
    };
    clear(): this;
}
/**
 * PlanStorage - Persist plans (in-memory implementation)
 */
export declare class PlanStorage {
    private plans;
    private todoLists;
    savePlan(plan: Plan): void;
    getPlan(planId: string): Plan | undefined;
    deletePlan(planId: string): boolean;
    listPlans(): Plan[];
    saveTodoList(list: TodoList): void;
    getTodoList(listId: string): TodoList | undefined;
    deleteTodoList(listId: string): boolean;
    listTodoLists(): TodoList[];
}
/**
 * Create a Plan
 */
export declare function createPlan(config: PlanConfig): Plan;
/**
 * Create a TodoList
 */
export declare function createTodoList(name?: string): TodoList;
/**
 * Create a PlanStorage
 */
export declare function createPlanStorage(): PlanStorage;
/**
 * PlanningAgent - Agent with built-in planning capabilities
 *
 * @example Simple usage (4 lines)
 * ```typescript
 * import { PlanningAgent } from 'praisonai';
 *
 * const agent = new PlanningAgent({ instructions: 'You break down tasks into steps' });
 * const result = await agent.planAndExecute('Build a web scraper');
 * console.log(result.plan);  // The plan that was created
 * console.log(result.results);  // Results from each step
 * ```
 */
export interface PlanningAgentConfig {
    instructions?: string;
    name?: string;
    llm?: string;
    verbose?: boolean;
    maxSteps?: number;
}
export interface PlanResult {
    plan: Plan;
    results: string[];
    success: boolean;
}
export declare class PlanningAgent {
    private config;
    private agent;
    private currentPlan;
    constructor(config?: PlanningAgentConfig);
    private getAgent;
    /**
     * Create a plan for a task
     */
    createPlan(task: string): Promise<Plan>;
    /**
     * Execute a single step
     */
    executeStep(step: PlanStep): Promise<string>;
    /**
     * Plan and execute a task in one call
     */
    planAndExecute(task: string): Promise<PlanResult>;
    /**
     * Get the current plan
     */
    getPlan(): Plan | null;
    /**
     * Simple chat (without planning)
     */
    chat(message: string): Promise<string>;
}
/**
 * Create a planning agent
 */
export declare function createPlanningAgent(config?: PlanningAgentConfig): PlanningAgent;
/**
 * TaskAgent - Agent with built-in todo list management
 *
 * @example Simple usage (4 lines)
 * ```typescript
 * import { TaskAgent } from 'praisonai';
 *
 * const agent = new TaskAgent();
 * await agent.addTask('Fix critical bug', 'high');
 * await agent.addTask('Write docs', 'medium');
 * console.log(agent.getPendingTasks());
 * ```
 */
export declare class TaskAgent {
    private todos;
    private agent;
    private config;
    constructor(config?: {
        name?: string;
        llm?: string;
        verbose?: boolean;
    });
    private getAgent;
    /**
     * Add a task
     */
    addTask(content: string, priority?: 'low' | 'medium' | 'high'): TodoItem;
    /**
     * Complete a task by content (partial match)
     */
    completeTask(contentMatch: string): boolean;
    /**
     * Get pending tasks
     */
    getPendingTasks(): TodoItem[];
    /**
     * Get all tasks
     */
    getAllTasks(): TodoItem[];
    /**
     * Get progress
     */
    getProgress(): {
        completed: number;
        total: number;
        percentage: number;
    };
    /**
     * Clear all tasks
     */
    clearTasks(): void;
    /**
     * Chat with AI about tasks
     */
    chat(message: string): Promise<string>;
}
/**
 * Create a task agent
 */
export declare function createTaskAgent(config?: {
    name?: string;
    llm?: string;
    verbose?: boolean;
}): TaskAgent;