gthinking 1.2.1 → 2.1.1

package/dist/types/reasoning.d.ts

@@ -1,5 +1,11 @@
-import { TaskStatus } from './core';
-import { Evidence } from './analysis';
+/**
+ * Reasoning Types for gthinking v2.0.0
+ * Types for reasoning and logical inference functionality
+ */
+import { z } from 'zod';
+/**
+ * Reasoning Type Enum
+ */
 export declare enum ReasoningType {
     DEDUCTIVE = "deductive",
     INDUCTIVE = "inductive",
@@ -8,76 +14,2207 @@ export declare enum ReasoningType {
     CAUSAL = "causal",
     COUNTERFACTUAL = "counterfactual"
 }
-export interface ReasoningSession {
-    id: string;
-    problem: string;
-    type: ReasoningType;
-    steps: ReasoningStep[];
+/**
+ * Reasoning Type Schema
+ */
+export declare const ReasoningTypeSchema: z.ZodNativeEnum<typeof ReasoningType>;
+/**
+ * Reasoning Request Schema
+ */
+export declare const ReasoningRequestSchema: z.ZodObject<{
+    problem: z.ZodString;
+    type: z.ZodDefault<z.ZodNativeEnum<typeof ReasoningType>>;
+    context: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    options: z.ZodDefault<z.ZodObject<{
+        maxSteps: z.ZodDefault<z.ZodNumber>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        useLLM: z.ZodDefault<z.ZodBoolean>;
+        includeChainOfThought: z.ZodDefault<z.ZodBoolean>;
+        generateHypotheses: z.ZodDefault<z.ZodBoolean>;
+        decomposeProblem: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        maxSteps?: number;
+        useLLM?: boolean;
+        includeChainOfThought?: boolean;
+        generateHypotheses?: boolean;
+        decomposeProblem?: boolean;
+    }, {
+        confidence?: number;
+        maxSteps?: number;
+        useLLM?: boolean;
+        includeChainOfThought?: boolean;
+        generateHypotheses?: boolean;
+        decomposeProblem?: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    options?: {
+        confidence?: number;
+        maxSteps?: number;
+        useLLM?: boolean;
+        includeChainOfThought?: boolean;
+        generateHypotheses?: boolean;
+        decomposeProblem?: boolean;
+    };
+    type?: ReasoningType;
+    problem?: string;
+    context?: string[];
+    constraints?: string[];
+}, {
+    options?: {
+        confidence?: number;
+        maxSteps?: number;
+        useLLM?: boolean;
+        includeChainOfThought?: boolean;
+        generateHypotheses?: boolean;
+        decomposeProblem?: boolean;
+    };
+    type?: ReasoningType;
+    problem?: string;
+    context?: string[];
+    constraints?: string[];
+}>;
+/**
+ * Reasoning Request Type
+ */
+export type ReasoningRequest = z.infer<typeof ReasoningRequestSchema>;
+/**
+ * Reasoning Step Schema
+ */
+export declare const ReasoningStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    stepNumber: z.ZodNumber;
+    type: z.ZodEnum<["premise", "observation", "inference", "conclusion", "hypothesis", "evidence"]>;
+    content: z.ZodString;
+    premise: z.ZodOptional<z.ZodString>;
+    inference: z.ZodOptional<z.ZodString>;
+    conclusion: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    supportingEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    counterEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+    confidence?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    content?: string;
+    stepNumber?: number;
+    premise?: string;
+    inference?: string;
     conclusion?: string;
-    confidence: number;
-    startTime: Date;
-    endTime?: Date;
-}
-export interface ReasoningStep {
-    id: string;
-    stepNumber: number;
-    premise: string;
-    inference: string;
-    evidence: Evidence[];
-    assumptions: string[];
-    confidence: number;
-    nextSteps: string[];
-}
-export interface Hypothesis {
-    id: string;
-    statement: string;
-    supportingEvidence: Evidence[];
-    contradictingEvidence: Evidence[];
-    tests: HypothesisTest[];
-    status: 'proposed' | 'testing' | 'confirmed' | 'rejected';
-    confidence: number;
-}
-export interface HypothesisTest {
-    id: string;
-    description: string;
-    expectedOutcome: string;
-    actualOutcome?: string;
-    passed?: boolean;
-}
-export interface ChainOfThought {
-    id: string;
-    initialQuestion: string;
-    thoughts: ThoughtNode[];
-    finalAnswer?: string;
-    completeness: number;
-}
-export interface ThoughtNode {
-    id: string;
-    content: string;
+    supportingEvidence?: string[];
+    counterEvidence?: string[];
+    assumptions?: string[];
+    dependencies?: string[];
+}, {
+    type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+    confidence?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    content?: string;
+    stepNumber?: number;
+    premise?: string;
+    inference?: string;
+    conclusion?: string;
+    supportingEvidence?: string[];
+    counterEvidence?: string[];
+    assumptions?: string[];
+    dependencies?: string[];
+}>;
+/**
+ * Reasoning Step Type
+ */
+export type ReasoningStep = z.infer<typeof ReasoningStepSchema>;
+/**
+ * Hypothesis Schema
+ */
+export declare const HypothesisSchema: z.ZodObject<{
+    id: z.ZodString;
+    statement: z.ZodString;
+    plausibility: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        supports: z.ZodBoolean;
+        strength: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        description?: string;
+        supports?: boolean;
+        strength?: number;
+    }, {
+        description?: string;
+        supports?: boolean;
+        strength?: number;
+    }>, "many">;
+    testable: z.ZodBoolean;
+    tested: z.ZodDefault<z.ZodBoolean>;
+    testResult: z.ZodOptional<z.ZodEnum<["confirmed", "rejected", "inconclusive"]>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    evidence?: {
+        description?: string;
+        supports?: boolean;
+        strength?: number;
+    }[];
+    statement?: string;
+    plausibility?: number;
+    testable?: boolean;
+    tested?: boolean;
+    testResult?: "confirmed" | "rejected" | "inconclusive";
+}, {
+    id?: string;
+    evidence?: {
+        description?: string;
+        supports?: boolean;
+        strength?: number;
+    }[];
+    statement?: string;
+    plausibility?: number;
+    testable?: boolean;
+    tested?: boolean;
+    testResult?: "confirmed" | "rejected" | "inconclusive";
+}>;
+/**
+ * Hypothesis Type
+ */
+export type Hypothesis = z.infer<typeof HypothesisSchema>;
+/**
+ * Chain of Thought Node Schema
+ */
+export declare const ChainOfThoughtNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    type: z.ZodEnum<["question", "observation", "inference", "conclusion", "assumption"]>;
+    parentId: z.ZodOptional<z.ZodString>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    depth: z.ZodNumber;
+    confidence: z.ZodNumber;
+    supportingEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+    confidence?: number;
+    depth?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    content?: string;
+    children?: string[];
+    supportingEvidence?: string[];
     parentId?: string;
-    children: string[];
-    depth: number;
-    confidence: number;
-    type: 'question' | 'observation' | 'inference' | 'conclusion';
-}
-export interface ProblemDecomposition {
-    id: string;
-    originalProblem: string;
-    subProblems: SubProblem[];
-    dependencies: Dependency[];
-    solutionStrategy: string;
-}
-export interface SubProblem {
-    id: string;
-    description: string;
-    difficulty: number;
-    estimatedTime: number;
-    prerequisites: string[];
-    status: TaskStatus;
-}
-export interface Dependency {
-    from: string;
-    to: string;
-    type: 'requires' | 'enables' | 'conflicts';
-}
+}, {
+    type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+    confidence?: number;
+    depth?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    content?: string;
+    children?: string[];
+    supportingEvidence?: string[];
+    parentId?: string;
+}>;
+/**
+ * Chain of Thought Node Type
+ */
+export type ChainOfThoughtNode = z.infer<typeof ChainOfThoughtNodeSchema>;
+/**
+ * Chain of Thought Schema
+ */
+export declare const ChainOfThoughtSchema: z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        type: z.ZodEnum<["question", "observation", "inference", "conclusion", "assumption"]>;
+        parentId: z.ZodOptional<z.ZodString>;
+        children: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        depth: z.ZodNumber;
+        confidence: z.ZodNumber;
+        supportingEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+        confidence?: number;
+        depth?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        children?: string[];
+        supportingEvidence?: string[];
+        parentId?: string;
+    }, {
+        type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+        confidence?: number;
+        depth?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        children?: string[];
+        supportingEvidence?: string[];
+        parentId?: string;
+    }>, "many">;
+    rootNodeId: z.ZodString;
+    maxDepth: z.ZodNumber;
+    finalAnswer: z.ZodOptional<z.ZodString>;
+    completeness: z.ZodNumber;
+    coherence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    question?: string;
+    nodes?: {
+        type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+        confidence?: number;
+        depth?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        children?: string[];
+        supportingEvidence?: string[];
+        parentId?: string;
+    }[];
+    rootNodeId?: string;
+    maxDepth?: number;
+    finalAnswer?: string;
+    completeness?: number;
+    coherence?: number;
+}, {
+    id?: string;
+    question?: string;
+    nodes?: {
+        type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+        confidence?: number;
+        depth?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        children?: string[];
+        supportingEvidence?: string[];
+        parentId?: string;
+    }[];
+    rootNodeId?: string;
+    maxDepth?: number;
+    finalAnswer?: string;
+    completeness?: number;
+    coherence?: number;
+}>;
+/**
+ * Chain of Thought Type
+ */
+export type ChainOfThought = z.infer<typeof ChainOfThoughtSchema>;
+/**
+ * Logical Rule Schema
+ */
+export declare const LogicalRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    premises: z.ZodArray<z.ZodString, "many">;
+    conclusion: z.ZodString;
+    confidence: z.ZodNumber;
+    domain: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    name?: string;
+    id?: string;
+    conclusion?: string;
+    premises?: string[];
+    domain?: string;
+}, {
+    confidence?: number;
+    name?: string;
+    id?: string;
+    conclusion?: string;
+    premises?: string[];
+    domain?: string;
+}>;
+/**
+ * Logical Rule Type
+ */
+export type LogicalRule = z.infer<typeof LogicalRuleSchema>;
+/**
+ * Analogy Schema
+ */
+export declare const AnalogySchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceDomain: z.ZodString;
+    targetDomain: z.ZodString;
+    mapping: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        similarity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        source?: string;
+        target?: string;
+        similarity?: number;
+    }, {
+        source?: string;
+        target?: string;
+        similarity?: number;
+    }>, "many">;
+    strength: z.ZodNumber;
+    explanation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    explanation?: string;
+    strength?: number;
+    sourceDomain?: string;
+    targetDomain?: string;
+    mapping?: {
+        source?: string;
+        target?: string;
+        similarity?: number;
+    }[];
+}, {
+    id?: string;
+    explanation?: string;
+    strength?: number;
+    sourceDomain?: string;
+    targetDomain?: string;
+    mapping?: {
+        source?: string;
+        target?: string;
+        similarity?: number;
+    }[];
+}>;
+/**
+ * Analogy Type
+ */
+export type Analogy = z.infer<typeof AnalogySchema>;
+/**
+ * Causal Chain Schema
+ */
+export declare const CausalChainSchema: z.ZodObject<{
+    id: z.ZodString;
+    cause: z.ZodString;
+    effect: z.ZodString;
+    intermediates: z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        event?: string;
+    }, {
+        confidence?: number;
+        event?: string;
+    }>, "many">;
+    confidence: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    id?: string;
+    evidence?: string[];
+    cause?: string;
+    effect?: string;
+    intermediates?: {
+        confidence?: number;
+        event?: string;
+    }[];
+}, {
+    confidence?: number;
+    id?: string;
+    evidence?: string[];
+    cause?: string;
+    effect?: string;
+    intermediates?: {
+        confidence?: number;
+        event?: string;
+    }[];
+}>;
+/**
+ * Causal Chain Type
+ */
+export type CausalChain = z.infer<typeof CausalChainSchema>;
+/**
+ * Counterfactual Scenario Schema
+ */
+export declare const CounterfactualScenarioSchema: z.ZodObject<{
+    id: z.ZodString;
+    original: z.ZodString;
+    alternative: z.ZodString;
+    changes: z.ZodArray<z.ZodString, "many">;
+    consequences: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        probability: z.ZodNumber;
+        impact: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    }, "strip", z.ZodTypeAny, {
+        description?: string;
+        probability?: number;
+        impact?: "medium" | "low" | "high" | "critical";
+    }, {
+        description?: string;
+        probability?: number;
+        impact?: "medium" | "low" | "high" | "critical";
+    }>, "many">;
+    plausibility: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    plausibility?: number;
+    original?: string;
+    alternative?: string;
+    changes?: string[];
+    consequences?: {
+        description?: string;
+        probability?: number;
+        impact?: "medium" | "low" | "high" | "critical";
+    }[];
+}, {
+    id?: string;
+    plausibility?: number;
+    original?: string;
+    alternative?: string;
+    changes?: string[];
+    consequences?: {
+        description?: string;
+        probability?: number;
+        impact?: "medium" | "low" | "high" | "critical";
+    }[];
+}>;
+/**
+ * Counterfactual Scenario Type
+ */
+export type CounterfactualScenario = z.infer<typeof CounterfactualScenarioSchema>;
+/**
+ * Problem Component Schema
+ */
+export declare const ProblemComponentSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<["subproblem", "constraint", "resource", "objective", "stakeholder"]>;
+    complexity: z.ZodNumber;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    priority: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+    name?: string;
+    complexity?: number;
+    id?: string;
+    dependencies?: string[];
+    description?: string;
+    priority?: number;
+}, {
+    type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+    name?: string;
+    complexity?: number;
+    id?: string;
+    dependencies?: string[];
+    description?: string;
+    priority?: number;
+}>;
+/**
+ * Problem Component Type
+ */
+export type ProblemComponent = z.infer<typeof ProblemComponentSchema>;
+/**
+ * Problem Decomposition Schema
+ */
+export declare const ProblemDecompositionSchema: z.ZodObject<{
+    originalProblem: z.ZodString;
+    components: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<["subproblem", "constraint", "resource", "objective", "stakeholder"]>;
+        complexity: z.ZodNumber;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        priority: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+        name?: string;
+        complexity?: number;
+        id?: string;
+        dependencies?: string[];
+        description?: string;
+        priority?: number;
+    }, {
+        type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+        name?: string;
+        complexity?: number;
+        id?: string;
+        dependencies?: string[];
+        description?: string;
+        priority?: number;
+    }>, "many">;
+    relationships: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<["depends_on", "blocks", "enables", "conflicts_with"]>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+        from?: string;
+        to?: string;
+    }, {
+        type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+        from?: string;
+        to?: string;
+    }>, "many">;
+    complexity: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    complexity?: number;
+    originalProblem?: string;
+    components?: {
+        type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+        name?: string;
+        complexity?: number;
+        id?: string;
+        dependencies?: string[];
+        description?: string;
+        priority?: number;
+    }[];
+    relationships?: {
+        type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+        from?: string;
+        to?: string;
+    }[];
+}, {
+    complexity?: number;
+    originalProblem?: string;
+    components?: {
+        type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+        name?: string;
+        complexity?: number;
+        id?: string;
+        dependencies?: string[];
+        description?: string;
+        priority?: number;
+    }[];
+    relationships?: {
+        type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+        from?: string;
+        to?: string;
+    }[];
+}>;
+/**
+ * Problem Decomposition Type
+ */
+export type ProblemDecomposition = z.infer<typeof ProblemDecompositionSchema>;
+/**
+ * Reasoning Session Schema
+ */
+export declare const ReasoningSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    request: z.ZodObject<{
+        problem: z.ZodString;
+        type: z.ZodDefault<z.ZodNativeEnum<typeof ReasoningType>>;
+        context: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        options: z.ZodDefault<z.ZodObject<{
+            maxSteps: z.ZodDefault<z.ZodNumber>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            useLLM: z.ZodDefault<z.ZodBoolean>;
+            includeChainOfThought: z.ZodDefault<z.ZodBoolean>;
+            generateHypotheses: z.ZodDefault<z.ZodBoolean>;
+            decomposeProblem: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            confidence?: number;
+            maxSteps?: number;
+            useLLM?: boolean;
+            includeChainOfThought?: boolean;
+            generateHypotheses?: boolean;
+            decomposeProblem?: boolean;
+        }, {
+            confidence?: number;
+            maxSteps?: number;
+            useLLM?: boolean;
+            includeChainOfThought?: boolean;
+            generateHypotheses?: boolean;
+            decomposeProblem?: boolean;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        options?: {
+            confidence?: number;
+            maxSteps?: number;
+            useLLM?: boolean;
+            includeChainOfThought?: boolean;
+            generateHypotheses?: boolean;
+            decomposeProblem?: boolean;
+        };
+        type?: ReasoningType;
+        problem?: string;
+        context?: string[];
+        constraints?: string[];
+    }, {
+        options?: {
+            confidence?: number;
+            maxSteps?: number;
+            useLLM?: boolean;
+            includeChainOfThought?: boolean;
+            generateHypotheses?: boolean;
+            decomposeProblem?: boolean;
+        };
+        type?: ReasoningType;
+        problem?: string;
+        context?: string[];
+        constraints?: string[];
+    }>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stepNumber: z.ZodNumber;
+        type: z.ZodEnum<["premise", "observation", "inference", "conclusion", "hypothesis", "evidence"]>;
+        content: z.ZodString;
+        premise: z.ZodOptional<z.ZodString>;
+        inference: z.ZodOptional<z.ZodString>;
+        conclusion: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodNumber;
+        supportingEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        counterEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        stepNumber?: number;
+        premise?: string;
+        inference?: string;
+        conclusion?: string;
+        supportingEvidence?: string[];
+        counterEvidence?: string[];
+        assumptions?: string[];
+        dependencies?: string[];
+    }, {
+        type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        stepNumber?: number;
+        premise?: string;
+        inference?: string;
+        conclusion?: string;
+        supportingEvidence?: string[];
+        counterEvidence?: string[];
+        assumptions?: string[];
+        dependencies?: string[];
+    }>, "many">;
+    hypotheses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        statement: z.ZodString;
+        plausibility: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            supports: z.ZodBoolean;
+            strength: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            description?: string;
+            supports?: boolean;
+            strength?: number;
+        }, {
+            description?: string;
+            supports?: boolean;
+            strength?: number;
+        }>, "many">;
+        testable: z.ZodBoolean;
+        tested: z.ZodDefault<z.ZodBoolean>;
+        testResult: z.ZodOptional<z.ZodEnum<["confirmed", "rejected", "inconclusive"]>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        evidence?: {
+            description?: string;
+            supports?: boolean;
+            strength?: number;
+        }[];
+        statement?: string;
+        plausibility?: number;
+        testable?: boolean;
+        tested?: boolean;
+        testResult?: "confirmed" | "rejected" | "inconclusive";
+    }, {
+        id?: string;
+        evidence?: {
+            description?: string;
+            supports?: boolean;
+            strength?: number;
+        }[];
+        statement?: string;
+        plausibility?: number;
+        testable?: boolean;
+        tested?: boolean;
+        testResult?: "confirmed" | "rejected" | "inconclusive";
+    }>, "many">;
+    chainOfThought: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            type: z.ZodEnum<["question", "observation", "inference", "conclusion", "assumption"]>;
+            parentId: z.ZodOptional<z.ZodString>;
+            children: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            depth: z.ZodNumber;
+            confidence: z.ZodNumber;
+            supportingEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+            confidence?: number;
+            depth?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            children?: string[];
+            supportingEvidence?: string[];
+            parentId?: string;
+        }, {
+            type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+            confidence?: number;
+            depth?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            children?: string[];
+            supportingEvidence?: string[];
+            parentId?: string;
+        }>, "many">;
+        rootNodeId: z.ZodString;
+        maxDepth: z.ZodNumber;
+        finalAnswer: z.ZodOptional<z.ZodString>;
+        completeness: z.ZodNumber;
+        coherence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        question?: string;
+        nodes?: {
+            type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+            confidence?: number;
+            depth?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            children?: string[];
+            supportingEvidence?: string[];
+            parentId?: string;
+        }[];
+        rootNodeId?: string;
+        maxDepth?: number;
+        finalAnswer?: string;
+        completeness?: number;
+        coherence?: number;
+    }, {
+        id?: string;
+        question?: string;
+        nodes?: {
+            type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+            confidence?: number;
+            depth?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            children?: string[];
+            supportingEvidence?: string[];
+            parentId?: string;
+        }[];
+        rootNodeId?: string;
+        maxDepth?: number;
+        finalAnswer?: string;
+        completeness?: number;
+        coherence?: number;
+    }>>;
+    decomposition: z.ZodOptional<z.ZodObject<{
+        originalProblem: z.ZodString;
+        components: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<["subproblem", "constraint", "resource", "objective", "stakeholder"]>;
+            complexity: z.ZodNumber;
+            dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            priority: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+            name?: string;
+            complexity?: number;
+            id?: string;
+            dependencies?: string[];
+            description?: string;
+            priority?: number;
+        }, {
+            type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+            name?: string;
+            complexity?: number;
+            id?: string;
+            dependencies?: string[];
+            description?: string;
+            priority?: number;
+        }>, "many">;
+        relationships: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodEnum<["depends_on", "blocks", "enables", "conflicts_with"]>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+            from?: string;
+            to?: string;
+        }, {
+            type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+            from?: string;
+            to?: string;
+        }>, "many">;
+        complexity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        complexity?: number;
+        originalProblem?: string;
+        components?: {
+            type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+            name?: string;
+            complexity?: number;
+            id?: string;
+            dependencies?: string[];
+            description?: string;
+            priority?: number;
+        }[];
+        relationships?: {
+            type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+            from?: string;
+            to?: string;
+        }[];
+    }, {
+        complexity?: number;
+        originalProblem?: string;
+        components?: {
+            type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+            name?: string;
+            complexity?: number;
+            id?: string;
+            dependencies?: string[];
+            description?: string;
+            priority?: number;
+        }[];
+        relationships?: {
+            type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+            from?: string;
+            to?: string;
+        }[];
+    }>>;
+    analogies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceDomain: z.ZodString;
+        targetDomain: z.ZodString;
+        mapping: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            target: z.ZodString;
+            similarity: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            source?: string;
+            target?: string;
+            similarity?: number;
+        }, {
+            source?: string;
+            target?: string;
+            similarity?: number;
+        }>, "many">;
+        strength: z.ZodNumber;
+        explanation: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        explanation?: string;
+        strength?: number;
+        sourceDomain?: string;
+        targetDomain?: string;
+        mapping?: {
+            source?: string;
+            target?: string;
+            similarity?: number;
+        }[];
+    }, {
+        id?: string;
+        explanation?: string;
+        strength?: number;
+        sourceDomain?: string;
+        targetDomain?: string;
+        mapping?: {
+            source?: string;
+            target?: string;
+            similarity?: number;
+        }[];
+    }>, "many">>;
+    causalChains: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        cause: z.ZodString;
+        effect: z.ZodString;
+        intermediates: z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            confidence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            confidence?: number;
+            event?: string;
+        }, {
+            confidence?: number;
+            event?: string;
+        }>, "many">;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        id?: string;
+        evidence?: string[];
+        cause?: string;
+        effect?: string;
+        intermediates?: {
+            confidence?: number;
+            event?: string;
+        }[];
+    }, {
+        confidence?: number;
+        id?: string;
+        evidence?: string[];
+        cause?: string;
+        effect?: string;
+        intermediates?: {
+            confidence?: number;
+            event?: string;
+        }[];
+    }>, "many">>;
+    counterfactuals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        original: z.ZodString;
+        alternative: z.ZodString;
+        changes: z.ZodArray<z.ZodString, "many">;
+        consequences: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            probability: z.ZodNumber;
+            impact: z.ZodEnum<["low", "medium", "high", "critical"]>;
+        }, "strip", z.ZodTypeAny, {
+            description?: string;
+            probability?: number;
+            impact?: "medium" | "low" | "high" | "critical";
+        }, {
+            description?: string;
+            probability?: number;
+            impact?: "medium" | "low" | "high" | "critical";
+        }>, "many">;
+        plausibility: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        plausibility?: number;
+        original?: string;
+        alternative?: string;
+        changes?: string[];
+        consequences?: {
+            description?: string;
+            probability?: number;
+            impact?: "medium" | "low" | "high" | "critical";
+        }[];
+    }, {
+        id?: string;
+        plausibility?: number;
+        original?: string;
+        alternative?: string;
+        changes?: string[];
+        consequences?: {
+            description?: string;
+            probability?: number;
+            impact?: "medium" | "low" | "high" | "critical";
+        }[];
+    }>, "many">>;
+    conclusion: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    startedAt: z.ZodDate;
+    completedAt: z.ZodOptional<z.ZodDate>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    request?: {
+        options?: {
+            confidence?: number;
+            maxSteps?: number;
+            useLLM?: boolean;
+            includeChainOfThought?: boolean;
+            generateHypotheses?: boolean;
+            decomposeProblem?: boolean;
+        };
+        type?: ReasoningType;
+        problem?: string;
+        context?: string[];
+        constraints?: string[];
+    };
+    conclusion?: string;
+    steps?: {
+        type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        stepNumber?: number;
+        premise?: string;
+        inference?: string;
+        conclusion?: string;
+        supportingEvidence?: string[];
+        counterEvidence?: string[];
+        assumptions?: string[];
+        dependencies?: string[];
+    }[];
+    hypotheses?: {
+        id?: string;
+        evidence?: {
+            description?: string;
+            supports?: boolean;
+            strength?: number;
+        }[];
+        statement?: string;
+        plausibility?: number;
+        testable?: boolean;
+        tested?: boolean;
+        testResult?: "confirmed" | "rejected" | "inconclusive";
+    }[];
+    chainOfThought?: {
+        id?: string;
+        question?: string;
+        nodes?: {
+            type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+            confidence?: number;
+            depth?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            children?: string[];
+            supportingEvidence?: string[];
+            parentId?: string;
+        }[];
+        rootNodeId?: string;
+        maxDepth?: number;
+        finalAnswer?: string;
+        completeness?: number;
+        coherence?: number;
+    };
+    decomposition?: {
+        complexity?: number;
+        originalProblem?: string;
+        components?: {
+            type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+            name?: string;
+            complexity?: number;
+            id?: string;
+            dependencies?: string[];
+            description?: string;
+            priority?: number;
+        }[];
+        relationships?: {
+            type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+            from?: string;
+            to?: string;
+        }[];
+    };
+    analogies?: {
+        id?: string;
+        explanation?: string;
+        strength?: number;
+        sourceDomain?: string;
+        targetDomain?: string;
+        mapping?: {
+            source?: string;
+            target?: string;
+            similarity?: number;
+        }[];
+    }[];
+    causalChains?: {
+        confidence?: number;
+        id?: string;
+        evidence?: string[];
+        cause?: string;
+        effect?: string;
+        intermediates?: {
+            confidence?: number;
+            event?: string;
+        }[];
+    }[];
+    counterfactuals?: {
+        id?: string;
+        plausibility?: number;
+        original?: string;
+        alternative?: string;
+        changes?: string[];
+        consequences?: {
+            description?: string;
+            probability?: number;
+            impact?: "medium" | "low" | "high" | "critical";
+        }[];
+    }[];
+    startedAt?: Date;
+    completedAt?: Date;
+}, {
+    confidence?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    request?: {
+        options?: {
+            confidence?: number;
+            maxSteps?: number;
+            useLLM?: boolean;
+            includeChainOfThought?: boolean;
+            generateHypotheses?: boolean;
+            decomposeProblem?: boolean;
+        };
+        type?: ReasoningType;
+        problem?: string;
+        context?: string[];
+        constraints?: string[];
+    };
+    conclusion?: string;
+    steps?: {
+        type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        stepNumber?: number;
+        premise?: string;
+        inference?: string;
+        conclusion?: string;
+        supportingEvidence?: string[];
+        counterEvidence?: string[];
+        assumptions?: string[];
+        dependencies?: string[];
+    }[];
+    hypotheses?: {
+        id?: string;
+        evidence?: {
+            description?: string;
+            supports?: boolean;
+            strength?: number;
+        }[];
+        statement?: string;
+        plausibility?: number;
+        testable?: boolean;
+        tested?: boolean;
+        testResult?: "confirmed" | "rejected" | "inconclusive";
+    }[];
+    chainOfThought?: {
+        id?: string;
+        question?: string;
+        nodes?: {
+            type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+            confidence?: number;
+            depth?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            children?: string[];
+            supportingEvidence?: string[];
+            parentId?: string;
+        }[];
+        rootNodeId?: string;
+        maxDepth?: number;
+        finalAnswer?: string;
+        completeness?: number;
+        coherence?: number;
+    };
+    decomposition?: {
+        complexity?: number;
+        originalProblem?: string;
+        components?: {
+            type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+            name?: string;
+            complexity?: number;
+            id?: string;
+            dependencies?: string[];
+            description?: string;
+            priority?: number;
+        }[];
+        relationships?: {
+            type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+            from?: string;
+            to?: string;
+        }[];
+    };
+    analogies?: {
+        id?: string;
+        explanation?: string;
+        strength?: number;
+        sourceDomain?: string;
+        targetDomain?: string;
+        mapping?: {
+            source?: string;
+            target?: string;
+            similarity?: number;
+        }[];
+    }[];
+    causalChains?: {
+        confidence?: number;
+        id?: string;
+        evidence?: string[];
+        cause?: string;
+        effect?: string;
+        intermediates?: {
+            confidence?: number;
+            event?: string;
+        }[];
+    }[];
+    counterfactuals?: {
+        id?: string;
+        plausibility?: number;
+        original?: string;
+        alternative?: string;
+        changes?: string[];
+        consequences?: {
+            description?: string;
+            probability?: number;
+            impact?: "medium" | "low" | "high" | "critical";
+        }[];
+    }[];
+    startedAt?: Date;
+    completedAt?: Date;
+}>;
+/**
+ * Reasoning Session Type
+ */
+export type ReasoningSession = z.infer<typeof ReasoningSessionSchema>;
+/**
+ * Reasoning Result Schema
+ */
+export declare const ReasoningResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodDate;
+    duration: z.ZodNumber;
+    errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    session: z.ZodObject<{
+        id: z.ZodString;
+        request: z.ZodObject<{
+            problem: z.ZodString;
+            type: z.ZodDefault<z.ZodNativeEnum<typeof ReasoningType>>;
+            context: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            options: z.ZodDefault<z.ZodObject<{
+                maxSteps: z.ZodDefault<z.ZodNumber>;
+                confidence: z.ZodDefault<z.ZodNumber>;
+                useLLM: z.ZodDefault<z.ZodBoolean>;
+                includeChainOfThought: z.ZodDefault<z.ZodBoolean>;
+                generateHypotheses: z.ZodDefault<z.ZodBoolean>;
+                decomposeProblem: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                confidence?: number;
+                maxSteps?: number;
+                useLLM?: boolean;
+                includeChainOfThought?: boolean;
+                generateHypotheses?: boolean;
+                decomposeProblem?: boolean;
+            }, {
+                confidence?: number;
+                maxSteps?: number;
+                useLLM?: boolean;
+                includeChainOfThought?: boolean;
+                generateHypotheses?: boolean;
+                decomposeProblem?: boolean;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            options?: {
+                confidence?: number;
+                maxSteps?: number;
+                useLLM?: boolean;
+                includeChainOfThought?: boolean;
+                generateHypotheses?: boolean;
+                decomposeProblem?: boolean;
+            };
+            type?: ReasoningType;
+            problem?: string;
+            context?: string[];
+            constraints?: string[];
+        }, {
+            options?: {
+                confidence?: number;
+                maxSteps?: number;
+                useLLM?: boolean;
+                includeChainOfThought?: boolean;
+                generateHypotheses?: boolean;
+                decomposeProblem?: boolean;
+            };
+            type?: ReasoningType;
+            problem?: string;
+            context?: string[];
+            constraints?: string[];
+        }>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            stepNumber: z.ZodNumber;
+            type: z.ZodEnum<["premise", "observation", "inference", "conclusion", "hypothesis", "evidence"]>;
+            content: z.ZodString;
+            premise: z.ZodOptional<z.ZodString>;
+            inference: z.ZodOptional<z.ZodString>;
+            conclusion: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodNumber;
+            supportingEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            counterEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            stepNumber?: number;
+            premise?: string;
+            inference?: string;
+            conclusion?: string;
+            supportingEvidence?: string[];
+            counterEvidence?: string[];
+            assumptions?: string[];
+            dependencies?: string[];
+        }, {
+            type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            stepNumber?: number;
+            premise?: string;
+            inference?: string;
+            conclusion?: string;
+            supportingEvidence?: string[];
+            counterEvidence?: string[];
+            assumptions?: string[];
+            dependencies?: string[];
+        }>, "many">;
+        hypotheses: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            plausibility: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                description: z.ZodString;
+                supports: z.ZodBoolean;
+                strength: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                description?: string;
+                supports?: boolean;
+                strength?: number;
+            }, {
+                description?: string;
+                supports?: boolean;
+                strength?: number;
+            }>, "many">;
+            testable: z.ZodBoolean;
+            tested: z.ZodDefault<z.ZodBoolean>;
+            testResult: z.ZodOptional<z.ZodEnum<["confirmed", "rejected", "inconclusive"]>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            evidence?: {
+                description?: string;
+                supports?: boolean;
+                strength?: number;
+            }[];
+            statement?: string;
+            plausibility?: number;
+            testable?: boolean;
+            tested?: boolean;
+            testResult?: "confirmed" | "rejected" | "inconclusive";
+        }, {
+            id?: string;
+            evidence?: {
+                description?: string;
+                supports?: boolean;
+                strength?: number;
+            }[];
+            statement?: string;
+            plausibility?: number;
+            testable?: boolean;
+            tested?: boolean;
+            testResult?: "confirmed" | "rejected" | "inconclusive";
+        }>, "many">;
+        chainOfThought: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            question: z.ZodString;
+            nodes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                content: z.ZodString;
+                type: z.ZodEnum<["question", "observation", "inference", "conclusion", "assumption"]>;
+                parentId: z.ZodOptional<z.ZodString>;
+                children: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                depth: z.ZodNumber;
+                confidence: z.ZodNumber;
+                supportingEvidence: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+                confidence?: number;
+                depth?: number;
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                children?: string[];
+                supportingEvidence?: string[];
+                parentId?: string;
+            }, {
+                type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+                confidence?: number;
+                depth?: number;
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                children?: string[];
+                supportingEvidence?: string[];
+                parentId?: string;
+            }>, "many">;
+            rootNodeId: z.ZodString;
+            maxDepth: z.ZodNumber;
+            finalAnswer: z.ZodOptional<z.ZodString>;
+            completeness: z.ZodNumber;
+            coherence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            question?: string;
+            nodes?: {
+                type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+                confidence?: number;
+                depth?: number;
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                children?: string[];
+                supportingEvidence?: string[];
+                parentId?: string;
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            finalAnswer?: string;
+            completeness?: number;
+            coherence?: number;
+        }, {
+            id?: string;
+            question?: string;
+            nodes?: {
+                type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+                confidence?: number;
+                depth?: number;
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                children?: string[];
+                supportingEvidence?: string[];
+                parentId?: string;
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            finalAnswer?: string;
+            completeness?: number;
+            coherence?: number;
+        }>>;
+        decomposition: z.ZodOptional<z.ZodObject<{
+            originalProblem: z.ZodString;
+            components: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                type: z.ZodEnum<["subproblem", "constraint", "resource", "objective", "stakeholder"]>;
+                complexity: z.ZodNumber;
+                dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                priority: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+                name?: string;
+                complexity?: number;
+                id?: string;
+                dependencies?: string[];
+                description?: string;
+                priority?: number;
+            }, {
+                type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+                name?: string;
+                complexity?: number;
+                id?: string;
+                dependencies?: string[];
+                description?: string;
+                priority?: number;
+            }>, "many">;
+            relationships: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                type: z.ZodEnum<["depends_on", "blocks", "enables", "conflicts_with"]>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+                from?: string;
+                to?: string;
+            }, {
+                type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+                from?: string;
+                to?: string;
+            }>, "many">;
+            complexity: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            complexity?: number;
+            originalProblem?: string;
+            components?: {
+                type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+                name?: string;
+                complexity?: number;
+                id?: string;
+                dependencies?: string[];
+                description?: string;
+                priority?: number;
+            }[];
+            relationships?: {
+                type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+                from?: string;
+                to?: string;
+            }[];
+        }, {
+            complexity?: number;
+            originalProblem?: string;
+            components?: {
+                type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+                name?: string;
+                complexity?: number;
+                id?: string;
+                dependencies?: string[];
+                description?: string;
+                priority?: number;
+            }[];
+            relationships?: {
+                type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+                from?: string;
+                to?: string;
+            }[];
+        }>>;
+        analogies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sourceDomain: z.ZodString;
+            targetDomain: z.ZodString;
+            mapping: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                similarity: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                source?: string;
+                target?: string;
+                similarity?: number;
+            }, {
+                source?: string;
+                target?: string;
+                similarity?: number;
+            }>, "many">;
+            strength: z.ZodNumber;
+            explanation: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            explanation?: string;
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                similarity?: number;
+            }[];
+        }, {
+            id?: string;
+            explanation?: string;
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                similarity?: number;
+            }[];
+        }>, "many">>;
+        causalChains: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            cause: z.ZodString;
+            effect: z.ZodString;
+            intermediates: z.ZodArray<z.ZodObject<{
+                event: z.ZodString;
+                confidence: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                confidence?: number;
+                event?: string;
+            }, {
+                confidence?: number;
+                event?: string;
+            }>, "many">;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            confidence?: number;
+            id?: string;
+            evidence?: string[];
+            cause?: string;
+            effect?: string;
+            intermediates?: {
+                confidence?: number;
+                event?: string;
+            }[];
+        }, {
+            confidence?: number;
+            id?: string;
+            evidence?: string[];
+            cause?: string;
+            effect?: string;
+            intermediates?: {
+                confidence?: number;
+                event?: string;
+            }[];
+        }>, "many">>;
+        counterfactuals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            original: z.ZodString;
+            alternative: z.ZodString;
+            changes: z.ZodArray<z.ZodString, "many">;
+            consequences: z.ZodArray<z.ZodObject<{
+                description: z.ZodString;
+                probability: z.ZodNumber;
+                impact: z.ZodEnum<["low", "medium", "high", "critical"]>;
+            }, "strip", z.ZodTypeAny, {
+                description?: string;
+                probability?: number;
+                impact?: "medium" | "low" | "high" | "critical";
+            }, {
+                description?: string;
+                probability?: number;
+                impact?: "medium" | "low" | "high" | "critical";
+            }>, "many">;
+            plausibility: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            plausibility?: number;
+            original?: string;
+            alternative?: string;
+            changes?: string[];
+            consequences?: {
+                description?: string;
+                probability?: number;
+                impact?: "medium" | "low" | "high" | "critical";
+            }[];
+        }, {
+            id?: string;
+            plausibility?: number;
+            original?: string;
+            alternative?: string;
+            changes?: string[];
+            consequences?: {
+                description?: string;
+                probability?: number;
+                impact?: "medium" | "low" | "high" | "critical";
+            }[];
+        }>, "many">>;
+        conclusion: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodNumber;
+        startedAt: z.ZodDate;
+        completedAt: z.ZodOptional<z.ZodDate>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        request?: {
+            options?: {
+                confidence?: number;
+                maxSteps?: number;
+                useLLM?: boolean;
+                includeChainOfThought?: boolean;
+                generateHypotheses?: boolean;
+                decomposeProblem?: boolean;
+            };
+            type?: ReasoningType;
+            problem?: string;
+            context?: string[];
+            constraints?: string[];
+        };
+        conclusion?: string;
+        steps?: {
+            type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            stepNumber?: number;
+            premise?: string;
+            inference?: string;
+            conclusion?: string;
+            supportingEvidence?: string[];
+            counterEvidence?: string[];
+            assumptions?: string[];
+            dependencies?: string[];
+        }[];
+        hypotheses?: {
+            id?: string;
+            evidence?: {
+                description?: string;
+                supports?: boolean;
+                strength?: number;
+            }[];
+            statement?: string;
+            plausibility?: number;
+            testable?: boolean;
+            tested?: boolean;
+            testResult?: "confirmed" | "rejected" | "inconclusive";
+        }[];
+        chainOfThought?: {
+            id?: string;
+            question?: string;
+            nodes?: {
+                type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+                confidence?: number;
+                depth?: number;
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                children?: string[];
+                supportingEvidence?: string[];
+                parentId?: string;
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            finalAnswer?: string;
+            completeness?: number;
+            coherence?: number;
+        };
+        decomposition?: {
+            complexity?: number;
+            originalProblem?: string;
+            components?: {
+                type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+                name?: string;
+                complexity?: number;
+                id?: string;
+                dependencies?: string[];
+                description?: string;
+                priority?: number;
+            }[];
+            relationships?: {
+                type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+                from?: string;
+                to?: string;
+            }[];
+        };
+        analogies?: {
+            id?: string;
+            explanation?: string;
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                similarity?: number;
+            }[];
+        }[];
+        causalChains?: {
+            confidence?: number;
+            id?: string;
+            evidence?: string[];
+            cause?: string;
+            effect?: string;
+            intermediates?: {
+                confidence?: number;
+                event?: string;
+            }[];
+        }[];
+        counterfactuals?: {
+            id?: string;
+            plausibility?: number;
+            original?: string;
+            alternative?: string;
+            changes?: string[];
+            consequences?: {
+                description?: string;
+                probability?: number;
+                impact?: "medium" | "low" | "high" | "critical";
+            }[];
+        }[];
+        startedAt?: Date;
+        completedAt?: Date;
+    }, {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        request?: {
+            options?: {
+                confidence?: number;
+                maxSteps?: number;
+                useLLM?: boolean;
+                includeChainOfThought?: boolean;
+                generateHypotheses?: boolean;
+                decomposeProblem?: boolean;
+            };
+            type?: ReasoningType;
+            problem?: string;
+            context?: string[];
+            constraints?: string[];
+        };
+        conclusion?: string;
+        steps?: {
+            type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            stepNumber?: number;
+            premise?: string;
+            inference?: string;
+            conclusion?: string;
+            supportingEvidence?: string[];
+            counterEvidence?: string[];
+            assumptions?: string[];
+            dependencies?: string[];
+        }[];
+        hypotheses?: {
+            id?: string;
+            evidence?: {
+                description?: string;
+                supports?: boolean;
+                strength?: number;
+            }[];
+            statement?: string;
+            plausibility?: number;
+            testable?: boolean;
+            tested?: boolean;
+            testResult?: "confirmed" | "rejected" | "inconclusive";
+        }[];
+        chainOfThought?: {
+            id?: string;
+            question?: string;
+            nodes?: {
+                type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+                confidence?: number;
+                depth?: number;
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                children?: string[];
+                supportingEvidence?: string[];
+                parentId?: string;
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            finalAnswer?: string;
+            completeness?: number;
+            coherence?: number;
+        };
+        decomposition?: {
+            complexity?: number;
+            originalProblem?: string;
+            components?: {
+                type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+                name?: string;
+                complexity?: number;
+                id?: string;
+                dependencies?: string[];
+                description?: string;
+                priority?: number;
+            }[];
+            relationships?: {
+                type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+                from?: string;
+                to?: string;
+            }[];
+        };
+        analogies?: {
+            id?: string;
+            explanation?: string;
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                similarity?: number;
+            }[];
+        }[];
+        causalChains?: {
+            confidence?: number;
+            id?: string;
+            evidence?: string[];
+            cause?: string;
+            effect?: string;
+            intermediates?: {
+                confidence?: number;
+                event?: string;
+            }[];
+        }[];
+        counterfactuals?: {
+            id?: string;
+            plausibility?: number;
+            original?: string;
+            alternative?: string;
+            changes?: string[];
+            consequences?: {
+                description?: string;
+                probability?: number;
+                impact?: "medium" | "low" | "high" | "critical";
+            }[];
+        }[];
+        startedAt?: Date;
+        completedAt?: Date;
+    }>;
+    conclusion: z.ZodString;
+    recommendations: z.ZodArray<z.ZodString, "many">;
+    confidenceBreakdown: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    conclusion?: string;
+    session?: {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        request?: {
+            options?: {
+                confidence?: number;
+                maxSteps?: number;
+                useLLM?: boolean;
+                includeChainOfThought?: boolean;
+                generateHypotheses?: boolean;
+                decomposeProblem?: boolean;
+            };
+            type?: ReasoningType;
+            problem?: string;
+            context?: string[];
+            constraints?: string[];
+        };
+        conclusion?: string;
+        steps?: {
+            type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            stepNumber?: number;
+            premise?: string;
+            inference?: string;
+            conclusion?: string;
+            supportingEvidence?: string[];
+            counterEvidence?: string[];
+            assumptions?: string[];
+            dependencies?: string[];
+        }[];
+        hypotheses?: {
+            id?: string;
+            evidence?: {
+                description?: string;
+                supports?: boolean;
+                strength?: number;
+            }[];
+            statement?: string;
+            plausibility?: number;
+            testable?: boolean;
+            tested?: boolean;
+            testResult?: "confirmed" | "rejected" | "inconclusive";
+        }[];
+        chainOfThought?: {
+            id?: string;
+            question?: string;
+            nodes?: {
+                type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+                confidence?: number;
+                depth?: number;
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                children?: string[];
+                supportingEvidence?: string[];
+                parentId?: string;
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            finalAnswer?: string;
+            completeness?: number;
+            coherence?: number;
+        };
+        decomposition?: {
+            complexity?: number;
+            originalProblem?: string;
+            components?: {
+                type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+                name?: string;
+                complexity?: number;
+                id?: string;
+                dependencies?: string[];
+                description?: string;
+                priority?: number;
+            }[];
+            relationships?: {
+                type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+                from?: string;
+                to?: string;
+            }[];
+        };
+        analogies?: {
+            id?: string;
+            explanation?: string;
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                similarity?: number;
+            }[];
+        }[];
+        causalChains?: {
+            confidence?: number;
+            id?: string;
+            evidence?: string[];
+            cause?: string;
+            effect?: string;
+            intermediates?: {
+                confidence?: number;
+                event?: string;
+            }[];
+        }[];
+        counterfactuals?: {
+            id?: string;
+            plausibility?: number;
+            original?: string;
+            alternative?: string;
+            changes?: string[];
+            consequences?: {
+                description?: string;
+                probability?: number;
+                impact?: "medium" | "low" | "high" | "critical";
+            }[];
+        }[];
+        startedAt?: Date;
+        completedAt?: Date;
+    };
+    recommendations?: string[];
+    confidenceBreakdown?: Record<string, number>;
+}, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    conclusion?: string;
+    session?: {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        request?: {
+            options?: {
+                confidence?: number;
+                maxSteps?: number;
+                useLLM?: boolean;
+                includeChainOfThought?: boolean;
+                generateHypotheses?: boolean;
+                decomposeProblem?: boolean;
+            };
+            type?: ReasoningType;
+            problem?: string;
+            context?: string[];
+            constraints?: string[];
+        };
+        conclusion?: string;
+        steps?: {
+            type?: "premise" | "observation" | "inference" | "conclusion" | "hypothesis" | "evidence";
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            stepNumber?: number;
+            premise?: string;
+            inference?: string;
+            conclusion?: string;
+            supportingEvidence?: string[];
+            counterEvidence?: string[];
+            assumptions?: string[];
+            dependencies?: string[];
+        }[];
+        hypotheses?: {
+            id?: string;
+            evidence?: {
+                description?: string;
+                supports?: boolean;
+                strength?: number;
+            }[];
+            statement?: string;
+            plausibility?: number;
+            testable?: boolean;
+            tested?: boolean;
+            testResult?: "confirmed" | "rejected" | "inconclusive";
+        }[];
+        chainOfThought?: {
+            id?: string;
+            question?: string;
+            nodes?: {
+                type?: "observation" | "inference" | "conclusion" | "question" | "assumption";
+                confidence?: number;
+                depth?: number;
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                children?: string[];
+                supportingEvidence?: string[];
+                parentId?: string;
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            finalAnswer?: string;
+            completeness?: number;
+            coherence?: number;
+        };
+        decomposition?: {
+            complexity?: number;
+            originalProblem?: string;
+            components?: {
+                type?: "subproblem" | "constraint" | "resource" | "objective" | "stakeholder";
+                name?: string;
+                complexity?: number;
+                id?: string;
+                dependencies?: string[];
+                description?: string;
+                priority?: number;
+            }[];
+            relationships?: {
+                type?: "depends_on" | "blocks" | "enables" | "conflicts_with";
+                from?: string;
+                to?: string;
+            }[];
+        };
+        analogies?: {
+            id?: string;
+            explanation?: string;
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                similarity?: number;
+            }[];
+        }[];
+        causalChains?: {
+            confidence?: number;
+            id?: string;
+            evidence?: string[];
+            cause?: string;
+            effect?: string;
+            intermediates?: {
+                confidence?: number;
+                event?: string;
+            }[];
+        }[];
+        counterfactuals?: {
+            id?: string;
+            plausibility?: number;
+            original?: string;
+            alternative?: string;
+            changes?: string[];
+            consequences?: {
+                description?: string;
+                probability?: number;
+                impact?: "medium" | "low" | "high" | "critical";
+            }[];
+        }[];
+        startedAt?: Date;
+        completedAt?: Date;
+    };
+    recommendations?: string[];
+    confidenceBreakdown?: Record<string, number>;
+}>;
+/**
+ * Reasoning Result Type
+ */
+export type ReasoningResult = z.infer<typeof ReasoningResultSchema>;
 //# sourceMappingURL=reasoning.d.ts.map