gthinking 1.2.1 → 2.1.1

package/dist/types/planning.d.ts

@@ -1,78 +1,2230 @@
-import { TaskStatus, Priority } from './core';
-export interface Plan {
-    id: string;
-    goal: string;
-    tasks: Task[];
-    milestones: Milestone[];
-    resources: Resource[];
-    timeline: Timeline;
-    status: TaskStatus;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface Task {
-    id: string;
-    title: string;
-    description: string;
-    priority: Priority;
-    status: TaskStatus;
-    estimatedDuration: number;
+/**
+ * Planning Types for gthinking v2.0.0
+ * Types for planning and task management functionality
+ */
+import { z } from 'zod';
+import { Priority, TaskStatus } from './core';
+/**
+ * Planning Request Schema
+ */
+export declare const PlanningRequestSchema: z.ZodObject<{
+    goal: z.ZodString;
+    constraints: z.ZodDefault<z.ZodObject<{
+        deadline: z.ZodOptional<z.ZodDate>;
+        budget: z.ZodOptional<z.ZodNumber>;
+        resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        mustInclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        mustExclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        dependencies?: string[];
+        deadline?: Date;
+        budget?: number;
+        resources?: string[];
+        mustInclude?: string[];
+        mustExclude?: string[];
+    }, {
+        dependencies?: string[];
+        deadline?: Date;
+        budget?: number;
+        resources?: string[];
+        mustInclude?: string[];
+        mustExclude?: string[];
+    }>>;
+    options: z.ZodDefault<z.ZodObject<{
+        granularity: z.ZodDefault<z.ZodEnum<["coarse", "medium", "fine"]>>;
+        includeRisks: z.ZodDefault<z.ZodBoolean>;
+        includeTimeline: z.ZodDefault<z.ZodBoolean>;
+        maxTasks: z.ZodDefault<z.ZodNumber>;
+        bufferPercentage: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        granularity?: "medium" | "coarse" | "fine";
+        includeRisks?: boolean;
+        includeTimeline?: boolean;
+        maxTasks?: number;
+        bufferPercentage?: number;
+    }, {
+        granularity?: "medium" | "coarse" | "fine";
+        includeRisks?: boolean;
+        includeTimeline?: boolean;
+        maxTasks?: number;
+        bufferPercentage?: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    options?: {
+        granularity?: "medium" | "coarse" | "fine";
+        includeRisks?: boolean;
+        includeTimeline?: boolean;
+        maxTasks?: number;
+        bufferPercentage?: number;
+    };
+    constraints?: {
+        dependencies?: string[];
+        deadline?: Date;
+        budget?: number;
+        resources?: string[];
+        mustInclude?: string[];
+        mustExclude?: string[];
+    };
+    goal?: string;
+}, {
+    options?: {
+        granularity?: "medium" | "coarse" | "fine";
+        includeRisks?: boolean;
+        includeTimeline?: boolean;
+        maxTasks?: number;
+        bufferPercentage?: number;
+    };
+    constraints?: {
+        dependencies?: string[];
+        deadline?: Date;
+        budget?: number;
+        resources?: string[];
+        mustInclude?: string[];
+        mustExclude?: string[];
+    };
+    goal?: string;
+}>;
+/**
+ * Planning Request Type
+ */
+export type PlanningRequest = z.infer<typeof PlanningRequestSchema>;
+/**
+ * Task Schema
+ */
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodDefault<z.ZodNativeEnum<typeof TaskStatus>>;
+    priority: z.ZodDefault<z.ZodNativeEnum<typeof Priority>>;
+    estimatedDuration: z.ZodNumber;
+    actualDuration: z.ZodOptional<z.ZodNumber>;
+    complexity: z.ZodDefault<z.ZodNumber>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    subtasks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    parentId: z.ZodOptional<z.ZodString>;
+    assignedTo: z.ZodOptional<z.ZodString>;
+    resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    startDate: z.ZodOptional<z.ZodDate>;
+    endDate: z.ZodOptional<z.ZodDate>;
+    deadline: z.ZodOptional<z.ZodDate>;
+    progress: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    status?: TaskStatus;
+    name?: string;
+    complexity?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    dependencies?: string[];
+    description?: string;
+    parentId?: string;
+    priority?: Priority;
+    deadline?: Date;
+    resources?: string[];
+    estimatedDuration?: number;
     actualDuration?: number;
-    dependencies: string[];
-    subtasks: string[];
+    subtasks?: string[];
     assignedTo?: string;
-    tags: string[];
-    startTime?: Date;
-    endTime?: Date;
-}
-export interface Milestone {
-    id: string;
-    title: string;
-    description: string;
-    criteria: string[];
+    startDate?: Date;
+    endDate?: Date;
+    progress?: number;
+}, {
+    status?: TaskStatus;
+    name?: string;
+    complexity?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+    dependencies?: string[];
+    description?: string;
+    parentId?: string;
+    priority?: Priority;
     deadline?: Date;
-    completedAt?: Date;
-    status: TaskStatus;
-}
-export interface Resource {
-    id: string;
-    type: 'human' | 'tool' | 'data' | 'time' | 'budget';
-    name: string;
-    availability: number;
-    cost?: number;
+    resources?: string[];
+    estimatedDuration?: number;
+    actualDuration?: number;
+    subtasks?: string[];
+    assignedTo?: string;
+    startDate?: Date;
+    endDate?: Date;
+    progress?: number;
+}>;
+/**
+ * Task Type
+ */
+export type Task = z.infer<typeof TaskSchema>;
+/**
+ * Milestone Schema
+ */
+export declare const MilestoneSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    dueDate: z.ZodDate;
+    tasks: z.ZodArray<z.ZodString, "many">;
+    deliverables: z.ZodArray<z.ZodString, "many">;
+    completed: z.ZodDefault<z.ZodBoolean>;
+    completionDate: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    completed?: boolean;
+    name?: string;
+    id?: string;
+    description?: string;
+    dueDate?: Date;
+    tasks?: string[];
+    deliverables?: string[];
+    completionDate?: Date;
+}, {
+    completed?: boolean;
+    name?: string;
+    id?: string;
+    description?: string;
+    dueDate?: Date;
+    tasks?: string[];
+    deliverables?: string[];
+    completionDate?: Date;
+}>;
+/**
+ * Milestone Type
+ */
+export type Milestone = z.infer<typeof MilestoneSchema>;
+/**
+ * Resource Schema
+ */
+export declare const ResourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<["human", "material", "financial", "time", "tool", "service"]>;
+    capacity: z.ZodNumber;
+    allocated: z.ZodDefault<z.ZodNumber>;
+    costPerUnit: z.ZodDefault<z.ZodNumber>;
+    unit: z.ZodDefault<z.ZodString>;
+    availability: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from: z.ZodDate;
+        to: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        from?: Date;
+        to?: Date;
+    }, {
+        from?: Date;
+        to?: Date;
+    }>, "many">>;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+    name?: string;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    capacity?: number;
+    allocated?: number;
+    costPerUnit?: number;
+    unit?: string;
+    availability?: {
+        from?: Date;
+        to?: Date;
+    }[];
     skills?: string[];
-}
-export interface Timeline {
-    startDate: Date;
+}, {
+    type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+    name?: string;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    capacity?: number;
+    allocated?: number;
+    costPerUnit?: number;
+    unit?: string;
+    availability?: {
+        from?: Date;
+        to?: Date;
+    }[];
+    skills?: string[];
+}>;
+/**
+ * Resource Type
+ */
+export type Resource = z.infer<typeof ResourceSchema>;
+/**
+ * Timeline Schema
+ */
+export declare const TimelineSchema: z.ZodObject<{
+    startDate: z.ZodDate;
+    endDate: z.ZodDate;
+    duration: z.ZodNumber;
+    phases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        startDate: z.ZodDate;
+        endDate: z.ZodDate;
+        tasks: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        startDate?: Date;
+        endDate?: Date;
+        tasks?: string[];
+    }, {
+        name?: string;
+        startDate?: Date;
+        endDate?: Date;
+        tasks?: string[];
+    }>, "many">;
+    criticalPath: z.ZodArray<z.ZodString, "many">;
+    buffer: z.ZodNumber;
+    milestones: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        dueDate: z.ZodDate;
+        tasks: z.ZodArray<z.ZodString, "many">;
+        deliverables: z.ZodArray<z.ZodString, "many">;
+        completed: z.ZodDefault<z.ZodBoolean>;
+        completionDate: z.ZodOptional<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        completed?: boolean;
+        name?: string;
+        id?: string;
+        description?: string;
+        dueDate?: Date;
+        tasks?: string[];
+        deliverables?: string[];
+        completionDate?: Date;
+    }, {
+        completed?: boolean;
+        name?: string;
+        id?: string;
+        description?: string;
+        dueDate?: Date;
+        tasks?: string[];
+        deliverables?: string[];
+        completionDate?: Date;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    duration?: number;
+    startDate?: Date;
     endDate?: Date;
-    phases: Phase[];
-    criticalPath: string[];
-    buffer: number;
-}
-export interface Phase {
-    id: string;
-    name: string;
-    startDate: Date;
-    endDate: Date;
-    tasks: string[];
-    dependencies: string[];
-}
-export interface ProgressReport {
-    planId: string;
-    timestamp: Date;
-    overallProgress: number;
-    completedTasks: number;
-    totalTasks: number;
-    onTrack: boolean;
-    risks: Risk[];
-    nextActions: string[];
-}
-export interface Risk {
-    id: string;
-    description: string;
-    probability: number;
-    impact: number;
-    mitigation: string;
-    status: 'identified' | 'mitigating' | 'resolved' | 'occurred';
+    phases?: {
+        name?: string;
+        startDate?: Date;
+        endDate?: Date;
+        tasks?: string[];
+    }[];
+    criticalPath?: string[];
+    buffer?: number;
+    milestones?: {
+        completed?: boolean;
+        name?: string;
+        id?: string;
+        description?: string;
+        dueDate?: Date;
+        tasks?: string[];
+        deliverables?: string[];
+        completionDate?: Date;
+    }[];
+}, {
+    duration?: number;
+    startDate?: Date;
+    endDate?: Date;
+    phases?: {
+        name?: string;
+        startDate?: Date;
+        endDate?: Date;
+        tasks?: string[];
+    }[];
+    criticalPath?: string[];
+    buffer?: number;
+    milestones?: {
+        completed?: boolean;
+        name?: string;
+        id?: string;
+        description?: string;
+        dueDate?: Date;
+        tasks?: string[];
+        deliverables?: string[];
+        completionDate?: Date;
+    }[];
+}>;
+/**
+ * Timeline Type
+ */
+export type Timeline = z.infer<typeof TimelineSchema>;
+/**
+ * Risk Schema
+ */
+export declare const RiskSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodEnum<["technical", "schedule", "budget", "resource", "external", "operational"]>;
+    probability: z.ZodNumber;
+    impact: z.ZodNumber;
+    riskScore: z.ZodNumber;
+    mitigation: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    contingency: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["identified", "monitoring", "mitigated", "occurred", "resolved"]>>;
+    triggers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+    id?: string;
+    category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+    description?: string;
+    probability?: number;
+    impact?: number;
+    riskScore?: number;
+    mitigation?: string[];
+    contingency?: string;
+    owner?: string;
+    triggers?: string[];
+}, {
+    status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+    id?: string;
+    category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+    description?: string;
+    probability?: number;
+    impact?: number;
+    riskScore?: number;
+    mitigation?: string[];
+    contingency?: string;
+    owner?: string;
+    triggers?: string[];
+}>;
+/**
+ * Risk Type
+ */
+export type Risk = z.infer<typeof RiskSchema>;
+/**
+ * Plan Schema
+ */
+export declare const PlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    goal: z.ZodString;
+    description: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        status: z.ZodDefault<z.ZodNativeEnum<typeof TaskStatus>>;
+        priority: z.ZodDefault<z.ZodNativeEnum<typeof Priority>>;
+        estimatedDuration: z.ZodNumber;
+        actualDuration: z.ZodOptional<z.ZodNumber>;
+        complexity: z.ZodDefault<z.ZodNumber>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        subtasks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        parentId: z.ZodOptional<z.ZodString>;
+        assignedTo: z.ZodOptional<z.ZodString>;
+        resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        startDate: z.ZodOptional<z.ZodDate>;
+        endDate: z.ZodOptional<z.ZodDate>;
+        deadline: z.ZodOptional<z.ZodDate>;
+        progress: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        status?: TaskStatus;
+        name?: string;
+        complexity?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        tags?: string[];
+        dependencies?: string[];
+        description?: string;
+        parentId?: string;
+        priority?: Priority;
+        deadline?: Date;
+        resources?: string[];
+        estimatedDuration?: number;
+        actualDuration?: number;
+        subtasks?: string[];
+        assignedTo?: string;
+        startDate?: Date;
+        endDate?: Date;
+        progress?: number;
+    }, {
+        status?: TaskStatus;
+        name?: string;
+        complexity?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        tags?: string[];
+        dependencies?: string[];
+        description?: string;
+        parentId?: string;
+        priority?: Priority;
+        deadline?: Date;
+        resources?: string[];
+        estimatedDuration?: number;
+        actualDuration?: number;
+        subtasks?: string[];
+        assignedTo?: string;
+        startDate?: Date;
+        endDate?: Date;
+        progress?: number;
+    }>, "many">;
+    timeline: z.ZodObject<{
+        startDate: z.ZodDate;
+        endDate: z.ZodDate;
+        duration: z.ZodNumber;
+        phases: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            startDate: z.ZodDate;
+            endDate: z.ZodDate;
+            tasks: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name?: string;
+            startDate?: Date;
+            endDate?: Date;
+            tasks?: string[];
+        }, {
+            name?: string;
+            startDate?: Date;
+            endDate?: Date;
+            tasks?: string[];
+        }>, "many">;
+        criticalPath: z.ZodArray<z.ZodString, "many">;
+        buffer: z.ZodNumber;
+        milestones: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            dueDate: z.ZodDate;
+            tasks: z.ZodArray<z.ZodString, "many">;
+            deliverables: z.ZodArray<z.ZodString, "many">;
+            completed: z.ZodDefault<z.ZodBoolean>;
+            completionDate: z.ZodOptional<z.ZodDate>;
+        }, "strip", z.ZodTypeAny, {
+            completed?: boolean;
+            name?: string;
+            id?: string;
+            description?: string;
+            dueDate?: Date;
+            tasks?: string[];
+            deliverables?: string[];
+            completionDate?: Date;
+        }, {
+            completed?: boolean;
+            name?: string;
+            id?: string;
+            description?: string;
+            dueDate?: Date;
+            tasks?: string[];
+            deliverables?: string[];
+            completionDate?: Date;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        duration?: number;
+        startDate?: Date;
+        endDate?: Date;
+        phases?: {
+            name?: string;
+            startDate?: Date;
+            endDate?: Date;
+            tasks?: string[];
+        }[];
+        criticalPath?: string[];
+        buffer?: number;
+        milestones?: {
+            completed?: boolean;
+            name?: string;
+            id?: string;
+            description?: string;
+            dueDate?: Date;
+            tasks?: string[];
+            deliverables?: string[];
+            completionDate?: Date;
+        }[];
+    }, {
+        duration?: number;
+        startDate?: Date;
+        endDate?: Date;
+        phases?: {
+            name?: string;
+            startDate?: Date;
+            endDate?: Date;
+            tasks?: string[];
+        }[];
+        criticalPath?: string[];
+        buffer?: number;
+        milestones?: {
+            completed?: boolean;
+            name?: string;
+            id?: string;
+            description?: string;
+            dueDate?: Date;
+            tasks?: string[];
+            deliverables?: string[];
+            completionDate?: Date;
+        }[];
+    }>;
+    resources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<["human", "material", "financial", "time", "tool", "service"]>;
+        capacity: z.ZodNumber;
+        allocated: z.ZodDefault<z.ZodNumber>;
+        costPerUnit: z.ZodDefault<z.ZodNumber>;
+        unit: z.ZodDefault<z.ZodString>;
+        availability: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            from: z.ZodDate;
+            to: z.ZodDate;
+        }, "strip", z.ZodTypeAny, {
+            from?: Date;
+            to?: Date;
+        }, {
+            from?: Date;
+            to?: Date;
+        }>, "many">>;
+        skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+        name?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        capacity?: number;
+        allocated?: number;
+        costPerUnit?: number;
+        unit?: string;
+        availability?: {
+            from?: Date;
+            to?: Date;
+        }[];
+        skills?: string[];
+    }, {
+        type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+        name?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        capacity?: number;
+        allocated?: number;
+        costPerUnit?: number;
+        unit?: string;
+        availability?: {
+            from?: Date;
+            to?: Date;
+        }[];
+        skills?: string[];
+    }>, "many">;
+    risks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        category: z.ZodEnum<["technical", "schedule", "budget", "resource", "external", "operational"]>;
+        probability: z.ZodNumber;
+        impact: z.ZodNumber;
+        riskScore: z.ZodNumber;
+        mitigation: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        contingency: z.ZodOptional<z.ZodString>;
+        owner: z.ZodOptional<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<["identified", "monitoring", "mitigated", "occurred", "resolved"]>>;
+        triggers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+        id?: string;
+        category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+        description?: string;
+        probability?: number;
+        impact?: number;
+        riskScore?: number;
+        mitigation?: string[];
+        contingency?: string;
+        owner?: string;
+        triggers?: string[];
+    }, {
+        status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+        id?: string;
+        category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+        description?: string;
+        probability?: number;
+        impact?: number;
+        riskScore?: number;
+        mitigation?: string[];
+        contingency?: string;
+        owner?: string;
+        triggers?: string[];
+    }>, "many">;
+    assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    successCriteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    kpis: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        metric: z.ZodString;
+        target: z.ZodNumber;
+        current: z.ZodOptional<z.ZodNumber>;
+        unit: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        target?: number;
+        unit?: string;
+        metric?: string;
+        current?: number;
+    }, {
+        target?: number;
+        unit?: string;
+        metric?: string;
+        current?: number;
+    }>, "many">>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    version: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    constraints?: string[];
+    assumptions?: string[];
+    description?: string;
+    goal?: string;
+    resources?: {
+        type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+        name?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        capacity?: number;
+        allocated?: number;
+        costPerUnit?: number;
+        unit?: string;
+        availability?: {
+            from?: Date;
+            to?: Date;
+        }[];
+        skills?: string[];
+    }[];
+    tasks?: {
+        status?: TaskStatus;
+        name?: string;
+        complexity?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        tags?: string[];
+        dependencies?: string[];
+        description?: string;
+        parentId?: string;
+        priority?: Priority;
+        deadline?: Date;
+        resources?: string[];
+        estimatedDuration?: number;
+        actualDuration?: number;
+        subtasks?: string[];
+        assignedTo?: string;
+        startDate?: Date;
+        endDate?: Date;
+        progress?: number;
+    }[];
+    timeline?: {
+        duration?: number;
+        startDate?: Date;
+        endDate?: Date;
+        phases?: {
+            name?: string;
+            startDate?: Date;
+            endDate?: Date;
+            tasks?: string[];
+        }[];
+        criticalPath?: string[];
+        buffer?: number;
+        milestones?: {
+            completed?: boolean;
+            name?: string;
+            id?: string;
+            description?: string;
+            dueDate?: Date;
+            tasks?: string[];
+            deliverables?: string[];
+            completionDate?: Date;
+        }[];
+    };
+    risks?: {
+        status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+        id?: string;
+        category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+        description?: string;
+        probability?: number;
+        impact?: number;
+        riskScore?: number;
+        mitigation?: string[];
+        contingency?: string;
+        owner?: string;
+        triggers?: string[];
+    }[];
+    successCriteria?: string[];
+    kpis?: {
+        target?: number;
+        unit?: string;
+        metric?: string;
+        current?: number;
+    }[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    version?: number;
+}, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    constraints?: string[];
+    assumptions?: string[];
+    description?: string;
+    goal?: string;
+    resources?: {
+        type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+        name?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        capacity?: number;
+        allocated?: number;
+        costPerUnit?: number;
+        unit?: string;
+        availability?: {
+            from?: Date;
+            to?: Date;
+        }[];
+        skills?: string[];
+    }[];
+    tasks?: {
+        status?: TaskStatus;
+        name?: string;
+        complexity?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        tags?: string[];
+        dependencies?: string[];
+        description?: string;
+        parentId?: string;
+        priority?: Priority;
+        deadline?: Date;
+        resources?: string[];
+        estimatedDuration?: number;
+        actualDuration?: number;
+        subtasks?: string[];
+        assignedTo?: string;
+        startDate?: Date;
+        endDate?: Date;
+        progress?: number;
+    }[];
+    timeline?: {
+        duration?: number;
+        startDate?: Date;
+        endDate?: Date;
+        phases?: {
+            name?: string;
+            startDate?: Date;
+            endDate?: Date;
+            tasks?: string[];
+        }[];
+        criticalPath?: string[];
+        buffer?: number;
+        milestones?: {
+            completed?: boolean;
+            name?: string;
+            id?: string;
+            description?: string;
+            dueDate?: Date;
+            tasks?: string[];
+            deliverables?: string[];
+            completionDate?: Date;
+        }[];
+    };
+    risks?: {
+        status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+        id?: string;
+        category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+        description?: string;
+        probability?: number;
+        impact?: number;
+        riskScore?: number;
+        mitigation?: string[];
+        contingency?: string;
+        owner?: string;
+        triggers?: string[];
+    }[];
+    successCriteria?: string[];
+    kpis?: {
+        target?: number;
+        unit?: string;
+        metric?: string;
+        current?: number;
+    }[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    version?: number;
+}>;
+/**
+ * Plan Type
+ */
+export type Plan = z.infer<typeof PlanSchema>;
+/**
+ * Planning Result Schema
+ */
+export declare const PlanningResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodDate;
+    duration: z.ZodNumber;
+    errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    plan: z.ZodObject<{
+        id: z.ZodString;
+        goal: z.ZodString;
+        description: z.ZodString;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            status: z.ZodDefault<z.ZodNativeEnum<typeof TaskStatus>>;
+            priority: z.ZodDefault<z.ZodNativeEnum<typeof Priority>>;
+            estimatedDuration: z.ZodNumber;
+            actualDuration: z.ZodOptional<z.ZodNumber>;
+            complexity: z.ZodDefault<z.ZodNumber>;
+            dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            subtasks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            parentId: z.ZodOptional<z.ZodString>;
+            assignedTo: z.ZodOptional<z.ZodString>;
+            resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            startDate: z.ZodOptional<z.ZodDate>;
+            endDate: z.ZodOptional<z.ZodDate>;
+            deadline: z.ZodOptional<z.ZodDate>;
+            progress: z.ZodDefault<z.ZodNumber>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }, {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }>, "many">;
+        timeline: z.ZodObject<{
+            startDate: z.ZodDate;
+            endDate: z.ZodDate;
+            duration: z.ZodNumber;
+            phases: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                startDate: z.ZodDate;
+                endDate: z.ZodDate;
+                tasks: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }, {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }>, "many">;
+            criticalPath: z.ZodArray<z.ZodString, "many">;
+            buffer: z.ZodNumber;
+            milestones: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                dueDate: z.ZodDate;
+                tasks: z.ZodArray<z.ZodString, "many">;
+                deliverables: z.ZodArray<z.ZodString, "many">;
+                completed: z.ZodDefault<z.ZodBoolean>;
+                completionDate: z.ZodOptional<z.ZodDate>;
+            }, "strip", z.ZodTypeAny, {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }, {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        }, {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        }>;
+        resources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<["human", "material", "financial", "time", "tool", "service"]>;
+            capacity: z.ZodNumber;
+            allocated: z.ZodDefault<z.ZodNumber>;
+            costPerUnit: z.ZodDefault<z.ZodNumber>;
+            unit: z.ZodDefault<z.ZodString>;
+            availability: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                from: z.ZodDate;
+                to: z.ZodDate;
+            }, "strip", z.ZodTypeAny, {
+                from?: Date;
+                to?: Date;
+            }, {
+                from?: Date;
+                to?: Date;
+            }>, "many">>;
+            skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }, {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }>, "many">;
+        risks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            category: z.ZodEnum<["technical", "schedule", "budget", "resource", "external", "operational"]>;
+            probability: z.ZodNumber;
+            impact: z.ZodNumber;
+            riskScore: z.ZodNumber;
+            mitigation: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            contingency: z.ZodOptional<z.ZodString>;
+            owner: z.ZodOptional<z.ZodString>;
+            status: z.ZodDefault<z.ZodEnum<["identified", "monitoring", "mitigated", "occurred", "resolved"]>>;
+            triggers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }, {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }>, "many">;
+        assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        successCriteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        kpis: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            metric: z.ZodString;
+            target: z.ZodNumber;
+            current: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }, {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }>, "many">>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        version: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        constraints?: string[];
+        assumptions?: string[];
+        description?: string;
+        goal?: string;
+        resources?: {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }[];
+        tasks?: {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }[];
+        timeline?: {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        };
+        risks?: {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }[];
+        successCriteria?: string[];
+        kpis?: {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        version?: number;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        constraints?: string[];
+        assumptions?: string[];
+        description?: string;
+        goal?: string;
+        resources?: {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }[];
+        tasks?: {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }[];
+        timeline?: {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        };
+        risks?: {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }[];
+        successCriteria?: string[];
+        kpis?: {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        version?: number;
+    }>;
+    alternatives: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        goal: z.ZodString;
+        description: z.ZodString;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            status: z.ZodDefault<z.ZodNativeEnum<typeof TaskStatus>>;
+            priority: z.ZodDefault<z.ZodNativeEnum<typeof Priority>>;
+            estimatedDuration: z.ZodNumber;
+            actualDuration: z.ZodOptional<z.ZodNumber>;
+            complexity: z.ZodDefault<z.ZodNumber>;
+            dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            subtasks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            parentId: z.ZodOptional<z.ZodString>;
+            assignedTo: z.ZodOptional<z.ZodString>;
+            resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            startDate: z.ZodOptional<z.ZodDate>;
+            endDate: z.ZodOptional<z.ZodDate>;
+            deadline: z.ZodOptional<z.ZodDate>;
+            progress: z.ZodDefault<z.ZodNumber>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }, {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }>, "many">;
+        timeline: z.ZodObject<{
+            startDate: z.ZodDate;
+            endDate: z.ZodDate;
+            duration: z.ZodNumber;
+            phases: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                startDate: z.ZodDate;
+                endDate: z.ZodDate;
+                tasks: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }, {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }>, "many">;
+            criticalPath: z.ZodArray<z.ZodString, "many">;
+            buffer: z.ZodNumber;
+            milestones: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                dueDate: z.ZodDate;
+                tasks: z.ZodArray<z.ZodString, "many">;
+                deliverables: z.ZodArray<z.ZodString, "many">;
+                completed: z.ZodDefault<z.ZodBoolean>;
+                completionDate: z.ZodOptional<z.ZodDate>;
+            }, "strip", z.ZodTypeAny, {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }, {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        }, {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        }>;
+        resources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<["human", "material", "financial", "time", "tool", "service"]>;
+            capacity: z.ZodNumber;
+            allocated: z.ZodDefault<z.ZodNumber>;
+            costPerUnit: z.ZodDefault<z.ZodNumber>;
+            unit: z.ZodDefault<z.ZodString>;
+            availability: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                from: z.ZodDate;
+                to: z.ZodDate;
+            }, "strip", z.ZodTypeAny, {
+                from?: Date;
+                to?: Date;
+            }, {
+                from?: Date;
+                to?: Date;
+            }>, "many">>;
+            skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }, {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }>, "many">;
+        risks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            category: z.ZodEnum<["technical", "schedule", "budget", "resource", "external", "operational"]>;
+            probability: z.ZodNumber;
+            impact: z.ZodNumber;
+            riskScore: z.ZodNumber;
+            mitigation: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            contingency: z.ZodOptional<z.ZodString>;
+            owner: z.ZodOptional<z.ZodString>;
+            status: z.ZodDefault<z.ZodEnum<["identified", "monitoring", "mitigated", "occurred", "resolved"]>>;
+            triggers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }, {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }>, "many">;
+        assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        successCriteria: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        kpis: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            metric: z.ZodString;
+            target: z.ZodNumber;
+            current: z.ZodOptional<z.ZodNumber>;
+            unit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }, {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }>, "many">>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        version: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        constraints?: string[];
+        assumptions?: string[];
+        description?: string;
+        goal?: string;
+        resources?: {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }[];
+        tasks?: {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }[];
+        timeline?: {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        };
+        risks?: {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }[];
+        successCriteria?: string[];
+        kpis?: {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        version?: number;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        constraints?: string[];
+        assumptions?: string[];
+        description?: string;
+        goal?: string;
+        resources?: {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }[];
+        tasks?: {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }[];
+        timeline?: {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        };
+        risks?: {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }[];
+        successCriteria?: string[];
+        kpis?: {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        version?: number;
+    }>, "many">>;
+    recommendations: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    alternatives?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        constraints?: string[];
+        assumptions?: string[];
+        description?: string;
+        goal?: string;
+        resources?: {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }[];
+        tasks?: {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }[];
+        timeline?: {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        };
+        risks?: {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }[];
+        successCriteria?: string[];
+        kpis?: {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        version?: number;
+    }[];
+    recommendations?: string[];
+    plan?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        constraints?: string[];
+        assumptions?: string[];
+        description?: string;
+        goal?: string;
+        resources?: {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }[];
+        tasks?: {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }[];
+        timeline?: {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        };
+        risks?: {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }[];
+        successCriteria?: string[];
+        kpis?: {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        version?: number;
+    };
+    warnings?: string[];
+}, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    alternatives?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        constraints?: string[];
+        assumptions?: string[];
+        description?: string;
+        goal?: string;
+        resources?: {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }[];
+        tasks?: {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }[];
+        timeline?: {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        };
+        risks?: {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }[];
+        successCriteria?: string[];
+        kpis?: {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        version?: number;
+    }[];
+    recommendations?: string[];
+    plan?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        constraints?: string[];
+        assumptions?: string[];
+        description?: string;
+        goal?: string;
+        resources?: {
+            type?: "human" | "material" | "financial" | "time" | "tool" | "service";
+            name?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            capacity?: number;
+            allocated?: number;
+            costPerUnit?: number;
+            unit?: string;
+            availability?: {
+                from?: Date;
+                to?: Date;
+            }[];
+            skills?: string[];
+        }[];
+        tasks?: {
+            status?: TaskStatus;
+            name?: string;
+            complexity?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            tags?: string[];
+            dependencies?: string[];
+            description?: string;
+            parentId?: string;
+            priority?: Priority;
+            deadline?: Date;
+            resources?: string[];
+            estimatedDuration?: number;
+            actualDuration?: number;
+            subtasks?: string[];
+            assignedTo?: string;
+            startDate?: Date;
+            endDate?: Date;
+            progress?: number;
+        }[];
+        timeline?: {
+            duration?: number;
+            startDate?: Date;
+            endDate?: Date;
+            phases?: {
+                name?: string;
+                startDate?: Date;
+                endDate?: Date;
+                tasks?: string[];
+            }[];
+            criticalPath?: string[];
+            buffer?: number;
+            milestones?: {
+                completed?: boolean;
+                name?: string;
+                id?: string;
+                description?: string;
+                dueDate?: Date;
+                tasks?: string[];
+                deliverables?: string[];
+                completionDate?: Date;
+            }[];
+        };
+        risks?: {
+            status?: "identified" | "monitoring" | "mitigated" | "occurred" | "resolved";
+            id?: string;
+            category?: "resource" | "budget" | "technical" | "schedule" | "external" | "operational";
+            description?: string;
+            probability?: number;
+            impact?: number;
+            riskScore?: number;
+            mitigation?: string[];
+            contingency?: string;
+            owner?: string;
+            triggers?: string[];
+        }[];
+        successCriteria?: string[];
+        kpis?: {
+            target?: number;
+            unit?: string;
+            metric?: string;
+            current?: number;
+        }[];
+        createdAt?: Date;
+        updatedAt?: Date;
+        version?: number;
+    };
+    warnings?: string[];
+}>;
+/**
+ * Planning Result Type
+ */
+export type PlanningResult = z.infer<typeof PlanningResultSchema>;
+/**
+ * Progress Update Schema
+ */
+export declare const ProgressUpdateSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    progress: z.ZodNumber;
+    status: z.ZodNativeEnum<typeof TaskStatus>;
+    actualDuration: z.ZodOptional<z.ZodNumber>;
+    notes: z.ZodOptional<z.ZodString>;
+    blockers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    status?: TaskStatus;
+    timestamp?: Date;
+    actualDuration?: number;
+    progress?: number;
+    taskId?: string;
+    notes?: string;
+    blockers?: string[];
+}, {
+    status?: TaskStatus;
+    timestamp?: Date;
+    actualDuration?: number;
+    progress?: number;
+    taskId?: string;
+    notes?: string;
+    blockers?: string[];
+}>;
+/**
+ * Progress Update Type
+ */
+export type ProgressUpdate = z.infer<typeof ProgressUpdateSchema>;
+/**
+ * Planning Stage Enum
+ */
+export declare enum PlanningStage {
+    INITIATION = "initiation",
+    PLANNING = "planning",
+    EXECUTION = "execution",
+    MONITORING = "monitoring",
+    CLOSING = "closing"
 }
+/**
+ * Planning Stage Schema
+ */
+export declare const PlanningStageSchema: z.ZodNativeEnum<typeof PlanningStage>;
+/**
+ * Task Decomposition Rule Schema
+ */
+export declare const TaskDecompositionRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    pattern: z.ZodString;
+    subtasks: z.ZodArray<z.ZodObject<{
+        template: z.ZodString;
+        estimatedDuration: z.ZodNumber;
+        complexity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        complexity?: number;
+        estimatedDuration?: number;
+        template?: string;
+    }, {
+        complexity?: number;
+        estimatedDuration?: number;
+        template?: string;
+    }>, "many">;
+    priority: z.ZodNativeEnum<typeof Priority>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    priority?: Priority;
+    subtasks?: {
+        complexity?: number;
+        estimatedDuration?: number;
+        template?: string;
+    }[];
+    pattern?: string;
+}, {
+    id?: string;
+    priority?: Priority;
+    subtasks?: {
+        complexity?: number;
+        estimatedDuration?: number;
+        template?: string;
+    }[];
+    pattern?: string;
+}>;
+/**
+ * Task Decomposition Rule Type
+ */
+export type TaskDecompositionRule = z.infer<typeof TaskDecompositionRuleSchema>;
 //# sourceMappingURL=planning.d.ts.map