gthinking 1.2.1 → 2.1.1

package/dist/types/creativity.d.ts

@@ -1,58 +1,2873 @@
-export interface CreativeSession {
-    id: string;
-    prompt: string;
-    techniques: CreativityTechnique[];
-    ideas: Idea[];
-    connections: Connection[];
-    sessionDuration: number;
-    divergentPhase: DivergentPhase;
-    convergentPhase: ConvergentPhase;
-}
-export type CreativityTechnique = 'brainstorming' | 'mind_mapping' | 'scamper' | 'six_thinking_hats' | 'lateral_thinking' | 'analogy' | 'reverse_thinking' | 'random_stimulus';
-export interface Idea {
-    id: string;
-    content: string;
-    technique: CreativityTechnique;
-    novelty: number;
-    feasibility: number;
-    impact: number;
-    relatedIdeas: string[];
-    tags: string[];
-    generatedAt: Date;
-}
-export interface Connection {
-    id: string;
-    from: string;
-    to: string;
-    connectionType: 'similarity' | 'contrast' | 'cause_effect' | 'analogy' | 'combination';
-    strength: number;
-    insight: string;
-}
-export interface DivergentPhase {
-    startTime: Date;
-    endTime: Date;
-    ideaCount: number;
-    explorationBreadth: number;
-}
-export interface ConvergentPhase {
-    startTime: Date;
-    endTime: Date;
-    selectedIdeas: string[];
-    synthesis: string;
-    actionItems: string[];
-}
-export interface OutOfBoxThinking {
-    id: string;
-    originalProblem: string;
-    reframedProblems: ReframedProblem[];
-    unconventionalApproaches: string[];
-    breakthroughPotential: number;
-}
-export interface ReframedProblem {
-    id: string;
-    perspective: string;
-    reframedStatement: string;
-    assumptionsChallenged: string[];
-    newPossibilities: string[];
+/**
+ * Creativity Types for gthinking v2.0.0
+ * Types for creative thinking and ideation functionality
+ */
+import { z } from 'zod';
+/**
+ * Creativity Technique Enum
+ */
+export declare enum CreativityTechnique {
+    BRAINSTORMING = "brainstorming",
+    SCAMPER = "scamper",
+    SIX_THINKING_HATS = "six_thinking_hats",
+    MIND_MAPPING = "mind_mapping",
+    ANALOGY = "analogy",
+    REVERSE_THINKING = "reverse_thinking",
+    RANDOM_STIMULUS = "random_stimulus",
+    LATERAL_THINKING = "lateral_thinking",
+    OUT_OF_BOX = "out_of_box",
+    CONCEPT_CONNECTION = "concept_connection"
 }
+/**
+ * Creativity Technique Schema
+ */
+export declare const CreativityTechniqueSchema: z.ZodNativeEnum<typeof CreativityTechnique>;
+/**
+ * Creative Session Request Schema
+ */
+export declare const CreativeSessionRequestSchema: z.ZodObject<{
+    challenge: z.ZodString;
+    techniques: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof CreativityTechnique>, "many">>;
+    options: z.ZodDefault<z.ZodObject<{
+        ideaCount: z.ZodDefault<z.ZodNumber>;
+        timeLimit: z.ZodDefault<z.ZodNumber>;
+        diversityWeight: z.ZodDefault<z.ZodNumber>;
+        noveltyWeight: z.ZodDefault<z.ZodNumber>;
+        feasibilityWeight: z.ZodDefault<z.ZodNumber>;
+        includeWildIdeas: z.ZodDefault<z.ZodBoolean>;
+        useLLM: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        useLLM?: boolean;
+        ideaCount?: number;
+        timeLimit?: number;
+        diversityWeight?: number;
+        noveltyWeight?: number;
+        feasibilityWeight?: number;
+        includeWildIdeas?: boolean;
+    }, {
+        useLLM?: boolean;
+        ideaCount?: number;
+        timeLimit?: number;
+        diversityWeight?: number;
+        noveltyWeight?: number;
+        feasibilityWeight?: number;
+        includeWildIdeas?: boolean;
+    }>>;
+    context: z.ZodDefault<z.ZodObject<{
+        domain: z.ZodOptional<z.ZodString>;
+        constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        previousIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        constraints?: string[];
+        domain?: string;
+        resources?: string[];
+        previousIdeas?: string[];
+    }, {
+        constraints?: string[];
+        domain?: string;
+        resources?: string[];
+        previousIdeas?: string[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    options?: {
+        useLLM?: boolean;
+        ideaCount?: number;
+        timeLimit?: number;
+        diversityWeight?: number;
+        noveltyWeight?: number;
+        feasibilityWeight?: number;
+        includeWildIdeas?: boolean;
+    };
+    context?: {
+        constraints?: string[];
+        domain?: string;
+        resources?: string[];
+        previousIdeas?: string[];
+    };
+    challenge?: string;
+    techniques?: CreativityTechnique[];
+}, {
+    options?: {
+        useLLM?: boolean;
+        ideaCount?: number;
+        timeLimit?: number;
+        diversityWeight?: number;
+        noveltyWeight?: number;
+        feasibilityWeight?: number;
+        includeWildIdeas?: boolean;
+    };
+    context?: {
+        constraints?: string[];
+        domain?: string;
+        resources?: string[];
+        previousIdeas?: string[];
+    };
+    challenge?: string;
+    techniques?: CreativityTechnique[];
+}>;
+/**
+ * Creative Session Request Type
+ */
+export type CreativeSessionRequest = z.infer<typeof CreativeSessionRequestSchema>;
+/**
+ * Idea Schema
+ */
+export declare const IdeaSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+    novelty: z.ZodNumber;
+    feasibility: z.ZodNumber;
+    impact: z.ZodNumber;
+    diversity: z.ZodNumber;
+    overallScore: z.ZodNumber;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    generatedAt: z.ZodDate;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    content?: string;
+    tags?: string[];
+    impact?: number;
+    technique?: CreativityTechnique;
+    novelty?: number;
+    feasibility?: number;
+    diversity?: number;
+    overallScore?: number;
+    relatedIdeas?: string[];
+    generatedAt?: Date;
+}, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    content?: string;
+    tags?: string[];
+    impact?: number;
+    technique?: CreativityTechnique;
+    novelty?: number;
+    feasibility?: number;
+    diversity?: number;
+    overallScore?: number;
+    relatedIdeas?: string[];
+    generatedAt?: Date;
+}>;
+/**
+ * Idea Type
+ */
+export type Idea = z.infer<typeof IdeaSchema>;
+/**
+ * Connection Schema
+ */
+export declare const ConnectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    type: z.ZodEnum<["similar", "opposite", "complementary", "causal", "analogous", "random"]>;
+    strength: z.ZodNumber;
+    explanation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+    id?: string;
+    from?: string;
+    to?: string;
+    explanation?: string;
+    strength?: number;
+}, {
+    type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+    id?: string;
+    from?: string;
+    to?: string;
+    explanation?: string;
+    strength?: number;
+}>;
+/**
+ * Connection Type
+ */
+export type Connection = z.infer<typeof ConnectionSchema>;
+/**
+ * Mind Map Node Schema
+ */
+export declare const MindMapNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    parentId: z.ZodOptional<z.ZodString>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    depth: z.ZodNumber;
+    ideas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    category: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        x?: number;
+        y?: number;
+    }, {
+        x?: number;
+        y?: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    depth?: number;
+    id?: string;
+    category?: string;
+    children?: string[];
+    parentId?: string;
+    label?: string;
+    ideas?: string[];
+    color?: string;
+    position?: {
+        x?: number;
+        y?: number;
+    };
+}, {
+    depth?: number;
+    id?: string;
+    category?: string;
+    children?: string[];
+    parentId?: string;
+    label?: string;
+    ideas?: string[];
+    color?: string;
+    position?: {
+        x?: number;
+        y?: number;
+    };
+}>;
+/**
+ * Mind Map Node Type
+ */
+export type MindMapNode = z.infer<typeof MindMapNodeSchema>;
+/**
+ * Mind Map Schema
+ */
+export declare const MindMapSchema: z.ZodObject<{
+    id: z.ZodString;
+    centralTopic: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        parentId: z.ZodOptional<z.ZodString>;
+        children: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        depth: z.ZodNumber;
+        ideas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        category: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        position: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            x?: number;
+            y?: number;
+        }, {
+            x?: number;
+            y?: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        depth?: number;
+        id?: string;
+        category?: string;
+        children?: string[];
+        parentId?: string;
+        label?: string;
+        ideas?: string[];
+        color?: string;
+        position?: {
+            x?: number;
+            y?: number;
+        };
+    }, {
+        depth?: number;
+        id?: string;
+        category?: string;
+        children?: string[];
+        parentId?: string;
+        label?: string;
+        ideas?: string[];
+        color?: string;
+        position?: {
+            x?: number;
+            y?: number;
+        };
+    }>, "many">;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<["similar", "opposite", "complementary", "causal", "analogous", "random"]>;
+        strength: z.ZodNumber;
+        explanation: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+        id?: string;
+        from?: string;
+        to?: string;
+        explanation?: string;
+        strength?: number;
+    }, {
+        type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+        id?: string;
+        from?: string;
+        to?: string;
+        explanation?: string;
+        strength?: number;
+    }>, "many">;
+    rootNodeId: z.ZodString;
+    maxDepth: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    nodes?: {
+        depth?: number;
+        id?: string;
+        category?: string;
+        children?: string[];
+        parentId?: string;
+        label?: string;
+        ideas?: string[];
+        color?: string;
+        position?: {
+            x?: number;
+            y?: number;
+        };
+    }[];
+    rootNodeId?: string;
+    maxDepth?: number;
+    centralTopic?: string;
+    connections?: {
+        type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+        id?: string;
+        from?: string;
+        to?: string;
+        explanation?: string;
+        strength?: number;
+    }[];
+}, {
+    id?: string;
+    nodes?: {
+        depth?: number;
+        id?: string;
+        category?: string;
+        children?: string[];
+        parentId?: string;
+        label?: string;
+        ideas?: string[];
+        color?: string;
+        position?: {
+            x?: number;
+            y?: number;
+        };
+    }[];
+    rootNodeId?: string;
+    maxDepth?: number;
+    centralTopic?: string;
+    connections?: {
+        type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+        id?: string;
+        from?: string;
+        to?: string;
+        explanation?: string;
+        strength?: number;
+    }[];
+}>;
+/**
+ * Mind Map Type
+ */
+export type MindMap = z.infer<typeof MindMapSchema>;
+/**
+ * SCAMPER Element Schema
+ */
+export declare const ScamperElementSchema: z.ZodObject<{
+    letter: z.ZodEnum<["S", "C", "A", "M", "P", "E", "R"]>;
+    action: z.ZodString;
+    description: z.ZodString;
+    ideas: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+        novelty: z.ZodNumber;
+        feasibility: z.ZodNumber;
+        impact: z.ZodNumber;
+        diversity: z.ZodNumber;
+        overallScore: z.ZodNumber;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        generatedAt: z.ZodDate;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    description?: string;
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+    action?: string;
+}, {
+    description?: string;
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+    action?: string;
+}>;
+/**
+ * SCAMPER Element Type
+ */
+export type ScamperElement = z.infer<typeof ScamperElementSchema>;
+/**
+ * Six Hats Result Schema
+ */
+export declare const SixHatsResultSchema: z.ZodObject<{
+    hat: z.ZodEnum<["white", "red", "black", "yellow", "green", "blue"]>;
+    perspective: z.ZodString;
+    ideas: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+        novelty: z.ZodNumber;
+        feasibility: z.ZodNumber;
+        impact: z.ZodNumber;
+        diversity: z.ZodNumber;
+        overallScore: z.ZodNumber;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        generatedAt: z.ZodDate;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }>, "many">;
+    insights: z.ZodArray<z.ZodString, "many">;
+    concerns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+    perspective?: string;
+    insights?: string[];
+    concerns?: string[];
+}, {
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+    perspective?: string;
+    insights?: string[];
+    concerns?: string[];
+}>;
+/**
+ * Six Hats Result Type
+ */
+export type SixHatsResult = z.infer<typeof SixHatsResultSchema>;
+/**
+ * Analogy Result Schema
+ */
+export declare const AnalogyResultSchema: z.ZodObject<{
+    sourceDomain: z.ZodString;
+    targetDomain: z.ZodString;
+    mapping: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        insight: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source?: string;
+        target?: string;
+        insight?: string;
+    }, {
+        source?: string;
+        target?: string;
+        insight?: string;
+    }>, "many">;
+    ideas: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+        novelty: z.ZodNumber;
+        feasibility: z.ZodNumber;
+        impact: z.ZodNumber;
+        diversity: z.ZodNumber;
+        overallScore: z.ZodNumber;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        generatedAt: z.ZodDate;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }>, "many">;
+    strength: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    strength?: number;
+    sourceDomain?: string;
+    targetDomain?: string;
+    mapping?: {
+        source?: string;
+        target?: string;
+        insight?: string;
+    }[];
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+}, {
+    strength?: number;
+    sourceDomain?: string;
+    targetDomain?: string;
+    mapping?: {
+        source?: string;
+        target?: string;
+        insight?: string;
+    }[];
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+}>;
+/**
+ * Analogy Result Type
+ */
+export type AnalogyResult = z.infer<typeof AnalogyResultSchema>;
+/**
+ * Creative Session Schema
+ */
+export declare const CreativeSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    request: z.ZodObject<{
+        challenge: z.ZodString;
+        techniques: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof CreativityTechnique>, "many">>;
+        options: z.ZodDefault<z.ZodObject<{
+            ideaCount: z.ZodDefault<z.ZodNumber>;
+            timeLimit: z.ZodDefault<z.ZodNumber>;
+            diversityWeight: z.ZodDefault<z.ZodNumber>;
+            noveltyWeight: z.ZodDefault<z.ZodNumber>;
+            feasibilityWeight: z.ZodDefault<z.ZodNumber>;
+            includeWildIdeas: z.ZodDefault<z.ZodBoolean>;
+            useLLM: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            useLLM?: boolean;
+            ideaCount?: number;
+            timeLimit?: number;
+            diversityWeight?: number;
+            noveltyWeight?: number;
+            feasibilityWeight?: number;
+            includeWildIdeas?: boolean;
+        }, {
+            useLLM?: boolean;
+            ideaCount?: number;
+            timeLimit?: number;
+            diversityWeight?: number;
+            noveltyWeight?: number;
+            feasibilityWeight?: number;
+            includeWildIdeas?: boolean;
+        }>>;
+        context: z.ZodDefault<z.ZodObject<{
+            domain: z.ZodOptional<z.ZodString>;
+            constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            previousIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            constraints?: string[];
+            domain?: string;
+            resources?: string[];
+            previousIdeas?: string[];
+        }, {
+            constraints?: string[];
+            domain?: string;
+            resources?: string[];
+            previousIdeas?: string[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        options?: {
+            useLLM?: boolean;
+            ideaCount?: number;
+            timeLimit?: number;
+            diversityWeight?: number;
+            noveltyWeight?: number;
+            feasibilityWeight?: number;
+            includeWildIdeas?: boolean;
+        };
+        context?: {
+            constraints?: string[];
+            domain?: string;
+            resources?: string[];
+            previousIdeas?: string[];
+        };
+        challenge?: string;
+        techniques?: CreativityTechnique[];
+    }, {
+        options?: {
+            useLLM?: boolean;
+            ideaCount?: number;
+            timeLimit?: number;
+            diversityWeight?: number;
+            noveltyWeight?: number;
+            feasibilityWeight?: number;
+            includeWildIdeas?: boolean;
+        };
+        context?: {
+            constraints?: string[];
+            domain?: string;
+            resources?: string[];
+            previousIdeas?: string[];
+        };
+        challenge?: string;
+        techniques?: CreativityTechnique[];
+    }>;
+    ideas: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+        novelty: z.ZodNumber;
+        feasibility: z.ZodNumber;
+        impact: z.ZodNumber;
+        diversity: z.ZodNumber;
+        overallScore: z.ZodNumber;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        generatedAt: z.ZodDate;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }>, "many">;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<["similar", "opposite", "complementary", "causal", "analogous", "random"]>;
+        strength: z.ZodNumber;
+        explanation: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+        id?: string;
+        from?: string;
+        to?: string;
+        explanation?: string;
+        strength?: number;
+    }, {
+        type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+        id?: string;
+        from?: string;
+        to?: string;
+        explanation?: string;
+        strength?: number;
+    }>, "many">;
+    mindMap: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        centralTopic: z.ZodString;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            parentId: z.ZodOptional<z.ZodString>;
+            children: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            depth: z.ZodNumber;
+            ideas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            category: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            position: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                x?: number;
+                y?: number;
+            }, {
+                x?: number;
+                y?: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            depth?: number;
+            id?: string;
+            category?: string;
+            children?: string[];
+            parentId?: string;
+            label?: string;
+            ideas?: string[];
+            color?: string;
+            position?: {
+                x?: number;
+                y?: number;
+            };
+        }, {
+            depth?: number;
+            id?: string;
+            category?: string;
+            children?: string[];
+            parentId?: string;
+            label?: string;
+            ideas?: string[];
+            color?: string;
+            position?: {
+                x?: number;
+                y?: number;
+            };
+        }>, "many">;
+        connections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodEnum<["similar", "opposite", "complementary", "causal", "analogous", "random"]>;
+            strength: z.ZodNumber;
+            explanation: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }, {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }>, "many">;
+        rootNodeId: z.ZodString;
+        maxDepth: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        nodes?: {
+            depth?: number;
+            id?: string;
+            category?: string;
+            children?: string[];
+            parentId?: string;
+            label?: string;
+            ideas?: string[];
+            color?: string;
+            position?: {
+                x?: number;
+                y?: number;
+            };
+        }[];
+        rootNodeId?: string;
+        maxDepth?: number;
+        centralTopic?: string;
+        connections?: {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }[];
+    }, {
+        id?: string;
+        nodes?: {
+            depth?: number;
+            id?: string;
+            category?: string;
+            children?: string[];
+            parentId?: string;
+            label?: string;
+            ideas?: string[];
+            color?: string;
+            position?: {
+                x?: number;
+                y?: number;
+            };
+        }[];
+        rootNodeId?: string;
+        maxDepth?: number;
+        centralTopic?: string;
+        connections?: {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }[];
+    }>>;
+    scamper: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        letter: z.ZodEnum<["S", "C", "A", "M", "P", "E", "R"]>;
+        action: z.ZodString;
+        description: z.ZodString;
+        ideas: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+            novelty: z.ZodNumber;
+            feasibility: z.ZodNumber;
+            impact: z.ZodNumber;
+            diversity: z.ZodNumber;
+            overallScore: z.ZodNumber;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            generatedAt: z.ZodDate;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        description?: string;
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+        action?: string;
+    }, {
+        description?: string;
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+        action?: string;
+    }>, "many">>;
+    sixHats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        hat: z.ZodEnum<["white", "red", "black", "yellow", "green", "blue"]>;
+        perspective: z.ZodString;
+        ideas: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+            novelty: z.ZodNumber;
+            feasibility: z.ZodNumber;
+            impact: z.ZodNumber;
+            diversity: z.ZodNumber;
+            overallScore: z.ZodNumber;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            generatedAt: z.ZodDate;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }>, "many">;
+        insights: z.ZodArray<z.ZodString, "many">;
+        concerns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+        perspective?: string;
+        insights?: string[];
+        concerns?: string[];
+    }, {
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+        perspective?: string;
+        insights?: string[];
+        concerns?: string[];
+    }>, "many">>;
+    analogies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        sourceDomain: z.ZodString;
+        targetDomain: z.ZodString;
+        mapping: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            target: z.ZodString;
+            insight: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            source?: string;
+            target?: string;
+            insight?: string;
+        }, {
+            source?: string;
+            target?: string;
+            insight?: string;
+        }>, "many">;
+        ideas: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+            novelty: z.ZodNumber;
+            feasibility: z.ZodNumber;
+            impact: z.ZodNumber;
+            diversity: z.ZodNumber;
+            overallScore: z.ZodNumber;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            generatedAt: z.ZodDate;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }>, "many">;
+        strength: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        strength?: number;
+        sourceDomain?: string;
+        targetDomain?: string;
+        mapping?: {
+            source?: string;
+            target?: string;
+            insight?: string;
+        }[];
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+    }, {
+        strength?: number;
+        sourceDomain?: string;
+        targetDomain?: string;
+        mapping?: {
+            source?: string;
+            target?: string;
+            insight?: string;
+        }[];
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+    }>, "many">>;
+    topIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    startedAt: z.ZodDate;
+    completedAt: z.ZodOptional<z.ZodDate>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    request?: {
+        options?: {
+            useLLM?: boolean;
+            ideaCount?: number;
+            timeLimit?: number;
+            diversityWeight?: number;
+            noveltyWeight?: number;
+            feasibilityWeight?: number;
+            includeWildIdeas?: boolean;
+        };
+        context?: {
+            constraints?: string[];
+            domain?: string;
+            resources?: string[];
+            previousIdeas?: string[];
+        };
+        challenge?: string;
+        techniques?: CreativityTechnique[];
+    };
+    analogies?: {
+        strength?: number;
+        sourceDomain?: string;
+        targetDomain?: string;
+        mapping?: {
+            source?: string;
+            target?: string;
+            insight?: string;
+        }[];
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+    }[];
+    startedAt?: Date;
+    completedAt?: Date;
+    scamper?: {
+        description?: string;
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+        action?: string;
+    }[];
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    connections?: {
+        type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+        id?: string;
+        from?: string;
+        to?: string;
+        explanation?: string;
+        strength?: number;
+    }[];
+    mindMap?: {
+        id?: string;
+        nodes?: {
+            depth?: number;
+            id?: string;
+            category?: string;
+            children?: string[];
+            parentId?: string;
+            label?: string;
+            ideas?: string[];
+            color?: string;
+            position?: {
+                x?: number;
+                y?: number;
+            };
+        }[];
+        rootNodeId?: string;
+        maxDepth?: number;
+        centralTopic?: string;
+        connections?: {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }[];
+    };
+    sixHats?: {
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+        perspective?: string;
+        insights?: string[];
+        concerns?: string[];
+    }[];
+    topIdeas?: string[];
+}, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    request?: {
+        options?: {
+            useLLM?: boolean;
+            ideaCount?: number;
+            timeLimit?: number;
+            diversityWeight?: number;
+            noveltyWeight?: number;
+            feasibilityWeight?: number;
+            includeWildIdeas?: boolean;
+        };
+        context?: {
+            constraints?: string[];
+            domain?: string;
+            resources?: string[];
+            previousIdeas?: string[];
+        };
+        challenge?: string;
+        techniques?: CreativityTechnique[];
+    };
+    analogies?: {
+        strength?: number;
+        sourceDomain?: string;
+        targetDomain?: string;
+        mapping?: {
+            source?: string;
+            target?: string;
+            insight?: string;
+        }[];
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+    }[];
+    startedAt?: Date;
+    completedAt?: Date;
+    scamper?: {
+        description?: string;
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+        action?: string;
+    }[];
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    connections?: {
+        type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+        id?: string;
+        from?: string;
+        to?: string;
+        explanation?: string;
+        strength?: number;
+    }[];
+    mindMap?: {
+        id?: string;
+        nodes?: {
+            depth?: number;
+            id?: string;
+            category?: string;
+            children?: string[];
+            parentId?: string;
+            label?: string;
+            ideas?: string[];
+            color?: string;
+            position?: {
+                x?: number;
+                y?: number;
+            };
+        }[];
+        rootNodeId?: string;
+        maxDepth?: number;
+        centralTopic?: string;
+        connections?: {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }[];
+    };
+    sixHats?: {
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+        perspective?: string;
+        insights?: string[];
+        concerns?: string[];
+    }[];
+    topIdeas?: string[];
+}>;
+/**
+ * Creative Session Type
+ */
+export type CreativeSession = z.infer<typeof CreativeSessionSchema>;
+/**
+ * Creative Result Schema
+ */
+export declare const CreativeResultSchema: 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<{
+            challenge: z.ZodString;
+            techniques: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof CreativityTechnique>, "many">>;
+            options: z.ZodDefault<z.ZodObject<{
+                ideaCount: z.ZodDefault<z.ZodNumber>;
+                timeLimit: z.ZodDefault<z.ZodNumber>;
+                diversityWeight: z.ZodDefault<z.ZodNumber>;
+                noveltyWeight: z.ZodDefault<z.ZodNumber>;
+                feasibilityWeight: z.ZodDefault<z.ZodNumber>;
+                includeWildIdeas: z.ZodDefault<z.ZodBoolean>;
+                useLLM: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                useLLM?: boolean;
+                ideaCount?: number;
+                timeLimit?: number;
+                diversityWeight?: number;
+                noveltyWeight?: number;
+                feasibilityWeight?: number;
+                includeWildIdeas?: boolean;
+            }, {
+                useLLM?: boolean;
+                ideaCount?: number;
+                timeLimit?: number;
+                diversityWeight?: number;
+                noveltyWeight?: number;
+                feasibilityWeight?: number;
+                includeWildIdeas?: boolean;
+            }>>;
+            context: z.ZodDefault<z.ZodObject<{
+                domain: z.ZodOptional<z.ZodString>;
+                constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                previousIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                constraints?: string[];
+                domain?: string;
+                resources?: string[];
+                previousIdeas?: string[];
+            }, {
+                constraints?: string[];
+                domain?: string;
+                resources?: string[];
+                previousIdeas?: string[];
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            options?: {
+                useLLM?: boolean;
+                ideaCount?: number;
+                timeLimit?: number;
+                diversityWeight?: number;
+                noveltyWeight?: number;
+                feasibilityWeight?: number;
+                includeWildIdeas?: boolean;
+            };
+            context?: {
+                constraints?: string[];
+                domain?: string;
+                resources?: string[];
+                previousIdeas?: string[];
+            };
+            challenge?: string;
+            techniques?: CreativityTechnique[];
+        }, {
+            options?: {
+                useLLM?: boolean;
+                ideaCount?: number;
+                timeLimit?: number;
+                diversityWeight?: number;
+                noveltyWeight?: number;
+                feasibilityWeight?: number;
+                includeWildIdeas?: boolean;
+            };
+            context?: {
+                constraints?: string[];
+                domain?: string;
+                resources?: string[];
+                previousIdeas?: string[];
+            };
+            challenge?: string;
+            techniques?: CreativityTechnique[];
+        }>;
+        ideas: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+            novelty: z.ZodNumber;
+            feasibility: z.ZodNumber;
+            impact: z.ZodNumber;
+            diversity: z.ZodNumber;
+            overallScore: z.ZodNumber;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            generatedAt: z.ZodDate;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }>, "many">;
+        connections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodEnum<["similar", "opposite", "complementary", "causal", "analogous", "random"]>;
+            strength: z.ZodNumber;
+            explanation: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }, {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }>, "many">;
+        mindMap: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            centralTopic: z.ZodString;
+            nodes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                parentId: z.ZodOptional<z.ZodString>;
+                children: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                depth: z.ZodNumber;
+                ideas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                category: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+                position: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    x?: number;
+                    y?: number;
+                }, {
+                    x?: number;
+                    y?: number;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                depth?: number;
+                id?: string;
+                category?: string;
+                children?: string[];
+                parentId?: string;
+                label?: string;
+                ideas?: string[];
+                color?: string;
+                position?: {
+                    x?: number;
+                    y?: number;
+                };
+            }, {
+                depth?: number;
+                id?: string;
+                category?: string;
+                children?: string[];
+                parentId?: string;
+                label?: string;
+                ideas?: string[];
+                color?: string;
+                position?: {
+                    x?: number;
+                    y?: number;
+                };
+            }>, "many">;
+            connections: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                from: z.ZodString;
+                to: z.ZodString;
+                type: z.ZodEnum<["similar", "opposite", "complementary", "causal", "analogous", "random"]>;
+                strength: z.ZodNumber;
+                explanation: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+                id?: string;
+                from?: string;
+                to?: string;
+                explanation?: string;
+                strength?: number;
+            }, {
+                type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+                id?: string;
+                from?: string;
+                to?: string;
+                explanation?: string;
+                strength?: number;
+            }>, "many">;
+            rootNodeId: z.ZodString;
+            maxDepth: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            nodes?: {
+                depth?: number;
+                id?: string;
+                category?: string;
+                children?: string[];
+                parentId?: string;
+                label?: string;
+                ideas?: string[];
+                color?: string;
+                position?: {
+                    x?: number;
+                    y?: number;
+                };
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            centralTopic?: string;
+            connections?: {
+                type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+                id?: string;
+                from?: string;
+                to?: string;
+                explanation?: string;
+                strength?: number;
+            }[];
+        }, {
+            id?: string;
+            nodes?: {
+                depth?: number;
+                id?: string;
+                category?: string;
+                children?: string[];
+                parentId?: string;
+                label?: string;
+                ideas?: string[];
+                color?: string;
+                position?: {
+                    x?: number;
+                    y?: number;
+                };
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            centralTopic?: string;
+            connections?: {
+                type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+                id?: string;
+                from?: string;
+                to?: string;
+                explanation?: string;
+                strength?: number;
+            }[];
+        }>>;
+        scamper: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            letter: z.ZodEnum<["S", "C", "A", "M", "P", "E", "R"]>;
+            action: z.ZodString;
+            description: z.ZodString;
+            ideas: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                content: z.ZodString;
+                technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+                novelty: z.ZodNumber;
+                feasibility: z.ZodNumber;
+                impact: z.ZodNumber;
+                diversity: z.ZodNumber;
+                overallScore: z.ZodNumber;
+                tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                generatedAt: z.ZodDate;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }, {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            description?: string;
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+            action?: string;
+        }, {
+            description?: string;
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+            action?: string;
+        }>, "many">>;
+        sixHats: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            hat: z.ZodEnum<["white", "red", "black", "yellow", "green", "blue"]>;
+            perspective: z.ZodString;
+            ideas: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                content: z.ZodString;
+                technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+                novelty: z.ZodNumber;
+                feasibility: z.ZodNumber;
+                impact: z.ZodNumber;
+                diversity: z.ZodNumber;
+                overallScore: z.ZodNumber;
+                tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                generatedAt: z.ZodDate;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }, {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }>, "many">;
+            insights: z.ZodArray<z.ZodString, "many">;
+            concerns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+            perspective?: string;
+            insights?: string[];
+            concerns?: string[];
+        }, {
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+            perspective?: string;
+            insights?: string[];
+            concerns?: string[];
+        }>, "many">>;
+        analogies: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            sourceDomain: z.ZodString;
+            targetDomain: z.ZodString;
+            mapping: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                insight: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                source?: string;
+                target?: string;
+                insight?: string;
+            }, {
+                source?: string;
+                target?: string;
+                insight?: string;
+            }>, "many">;
+            ideas: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                content: z.ZodString;
+                technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+                novelty: z.ZodNumber;
+                feasibility: z.ZodNumber;
+                impact: z.ZodNumber;
+                diversity: z.ZodNumber;
+                overallScore: z.ZodNumber;
+                tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                generatedAt: z.ZodDate;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }, {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }>, "many">;
+            strength: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                insight?: string;
+            }[];
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+        }, {
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                insight?: string;
+            }[];
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+        }>, "many">>;
+        topIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        startedAt: z.ZodDate;
+        completedAt: z.ZodOptional<z.ZodDate>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        request?: {
+            options?: {
+                useLLM?: boolean;
+                ideaCount?: number;
+                timeLimit?: number;
+                diversityWeight?: number;
+                noveltyWeight?: number;
+                feasibilityWeight?: number;
+                includeWildIdeas?: boolean;
+            };
+            context?: {
+                constraints?: string[];
+                domain?: string;
+                resources?: string[];
+                previousIdeas?: string[];
+            };
+            challenge?: string;
+            techniques?: CreativityTechnique[];
+        };
+        analogies?: {
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                insight?: string;
+            }[];
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+        }[];
+        startedAt?: Date;
+        completedAt?: Date;
+        scamper?: {
+            description?: string;
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+            action?: string;
+        }[];
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        connections?: {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }[];
+        mindMap?: {
+            id?: string;
+            nodes?: {
+                depth?: number;
+                id?: string;
+                category?: string;
+                children?: string[];
+                parentId?: string;
+                label?: string;
+                ideas?: string[];
+                color?: string;
+                position?: {
+                    x?: number;
+                    y?: number;
+                };
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            centralTopic?: string;
+            connections?: {
+                type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+                id?: string;
+                from?: string;
+                to?: string;
+                explanation?: string;
+                strength?: number;
+            }[];
+        };
+        sixHats?: {
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+            perspective?: string;
+            insights?: string[];
+            concerns?: string[];
+        }[];
+        topIdeas?: string[];
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        request?: {
+            options?: {
+                useLLM?: boolean;
+                ideaCount?: number;
+                timeLimit?: number;
+                diversityWeight?: number;
+                noveltyWeight?: number;
+                feasibilityWeight?: number;
+                includeWildIdeas?: boolean;
+            };
+            context?: {
+                constraints?: string[];
+                domain?: string;
+                resources?: string[];
+                previousIdeas?: string[];
+            };
+            challenge?: string;
+            techniques?: CreativityTechnique[];
+        };
+        analogies?: {
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                insight?: string;
+            }[];
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+        }[];
+        startedAt?: Date;
+        completedAt?: Date;
+        scamper?: {
+            description?: string;
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+            action?: string;
+        }[];
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        connections?: {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }[];
+        mindMap?: {
+            id?: string;
+            nodes?: {
+                depth?: number;
+                id?: string;
+                category?: string;
+                children?: string[];
+                parentId?: string;
+                label?: string;
+                ideas?: string[];
+                color?: string;
+                position?: {
+                    x?: number;
+                    y?: number;
+                };
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            centralTopic?: string;
+            connections?: {
+                type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+                id?: string;
+                from?: string;
+                to?: string;
+                explanation?: string;
+                strength?: number;
+            }[];
+        };
+        sixHats?: {
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+            perspective?: string;
+            insights?: string[];
+            concerns?: string[];
+        }[];
+        topIdeas?: string[];
+    }>;
+    topIdeas: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+        novelty: z.ZodNumber;
+        feasibility: z.ZodNumber;
+        impact: z.ZodNumber;
+        diversity: z.ZodNumber;
+        overallScore: z.ZodNumber;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        generatedAt: z.ZodDate;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }>, "many">;
+    recommendations: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    nextSteps: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    session?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        request?: {
+            options?: {
+                useLLM?: boolean;
+                ideaCount?: number;
+                timeLimit?: number;
+                diversityWeight?: number;
+                noveltyWeight?: number;
+                feasibilityWeight?: number;
+                includeWildIdeas?: boolean;
+            };
+            context?: {
+                constraints?: string[];
+                domain?: string;
+                resources?: string[];
+                previousIdeas?: string[];
+            };
+            challenge?: string;
+            techniques?: CreativityTechnique[];
+        };
+        analogies?: {
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                insight?: string;
+            }[];
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+        }[];
+        startedAt?: Date;
+        completedAt?: Date;
+        scamper?: {
+            description?: string;
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+            action?: string;
+        }[];
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        connections?: {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }[];
+        mindMap?: {
+            id?: string;
+            nodes?: {
+                depth?: number;
+                id?: string;
+                category?: string;
+                children?: string[];
+                parentId?: string;
+                label?: string;
+                ideas?: string[];
+                color?: string;
+                position?: {
+                    x?: number;
+                    y?: number;
+                };
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            centralTopic?: string;
+            connections?: {
+                type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+                id?: string;
+                from?: string;
+                to?: string;
+                explanation?: string;
+                strength?: number;
+            }[];
+        };
+        sixHats?: {
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+            perspective?: string;
+            insights?: string[];
+            concerns?: string[];
+        }[];
+        topIdeas?: string[];
+    };
+    recommendations?: string[];
+    topIdeas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    nextSteps?: string[];
+}, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    session?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        request?: {
+            options?: {
+                useLLM?: boolean;
+                ideaCount?: number;
+                timeLimit?: number;
+                diversityWeight?: number;
+                noveltyWeight?: number;
+                feasibilityWeight?: number;
+                includeWildIdeas?: boolean;
+            };
+            context?: {
+                constraints?: string[];
+                domain?: string;
+                resources?: string[];
+                previousIdeas?: string[];
+            };
+            challenge?: string;
+            techniques?: CreativityTechnique[];
+        };
+        analogies?: {
+            strength?: number;
+            sourceDomain?: string;
+            targetDomain?: string;
+            mapping?: {
+                source?: string;
+                target?: string;
+                insight?: string;
+            }[];
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+        }[];
+        startedAt?: Date;
+        completedAt?: Date;
+        scamper?: {
+            description?: string;
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            letter?: "S" | "C" | "A" | "M" | "P" | "E" | "R";
+            action?: string;
+        }[];
+        ideas?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            content?: string;
+            tags?: string[];
+            impact?: number;
+            technique?: CreativityTechnique;
+            novelty?: number;
+            feasibility?: number;
+            diversity?: number;
+            overallScore?: number;
+            relatedIdeas?: string[];
+            generatedAt?: Date;
+        }[];
+        connections?: {
+            type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+            id?: string;
+            from?: string;
+            to?: string;
+            explanation?: string;
+            strength?: number;
+        }[];
+        mindMap?: {
+            id?: string;
+            nodes?: {
+                depth?: number;
+                id?: string;
+                category?: string;
+                children?: string[];
+                parentId?: string;
+                label?: string;
+                ideas?: string[];
+                color?: string;
+                position?: {
+                    x?: number;
+                    y?: number;
+                };
+            }[];
+            rootNodeId?: string;
+            maxDepth?: number;
+            centralTopic?: string;
+            connections?: {
+                type?: "causal" | "similar" | "opposite" | "complementary" | "analogous" | "random";
+                id?: string;
+                from?: string;
+                to?: string;
+                explanation?: string;
+                strength?: number;
+            }[];
+        };
+        sixHats?: {
+            ideas?: {
+                id?: string;
+                metadata?: Record<string, unknown>;
+                content?: string;
+                tags?: string[];
+                impact?: number;
+                technique?: CreativityTechnique;
+                novelty?: number;
+                feasibility?: number;
+                diversity?: number;
+                overallScore?: number;
+                relatedIdeas?: string[];
+                generatedAt?: Date;
+            }[];
+            hat?: "white" | "red" | "black" | "yellow" | "green" | "blue";
+            perspective?: string;
+            insights?: string[];
+            concerns?: string[];
+        }[];
+        topIdeas?: string[];
+    };
+    recommendations?: string[];
+    topIdeas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    nextSteps?: string[];
+}>;
+/**
+ * Creative Result Type
+ */
+export type CreativeResult = z.infer<typeof CreativeResultSchema>;
+/**
+ * Idea Evaluation Criteria Schema
+ */
+export declare const IdeaEvaluationCriteriaSchema: z.ZodObject<{
+    novelty: z.ZodObject<{
+        weight: z.ZodDefault<z.ZodNumber>;
+        description: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        description?: string;
+        weight?: number;
+    }, {
+        description?: string;
+        weight?: number;
+    }>;
+    feasibility: z.ZodObject<{
+        weight: z.ZodDefault<z.ZodNumber>;
+        description: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        description?: string;
+        weight?: number;
+    }, {
+        description?: string;
+        weight?: number;
+    }>;
+    impact: z.ZodObject<{
+        weight: z.ZodDefault<z.ZodNumber>;
+        description: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        description?: string;
+        weight?: number;
+    }, {
+        description?: string;
+        weight?: number;
+    }>;
+    diversity: z.ZodObject<{
+        weight: z.ZodDefault<z.ZodNumber>;
+        description: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        description?: string;
+        weight?: number;
+    }, {
+        description?: string;
+        weight?: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    impact?: {
+        description?: string;
+        weight?: number;
+    };
+    novelty?: {
+        description?: string;
+        weight?: number;
+    };
+    feasibility?: {
+        description?: string;
+        weight?: number;
+    };
+    diversity?: {
+        description?: string;
+        weight?: number;
+    };
+}, {
+    impact?: {
+        description?: string;
+        weight?: number;
+    };
+    novelty?: {
+        description?: string;
+        weight?: number;
+    };
+    feasibility?: {
+        description?: string;
+        weight?: number;
+    };
+    diversity?: {
+        description?: string;
+        weight?: number;
+    };
+}>;
+/**
+ * Idea Evaluation Criteria Type
+ */
+export type IdeaEvaluationCriteria = z.infer<typeof IdeaEvaluationCriteriaSchema>;
+/**
+ * Perspective Schema for Out-of-Box thinking
+ */
+export declare const PerspectiveSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    questions: z.ZodArray<z.ZodString, "many">;
+    ideas: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        technique: z.ZodNativeEnum<typeof CreativityTechnique>;
+        novelty: z.ZodNumber;
+        feasibility: z.ZodNumber;
+        impact: z.ZodNumber;
+        diversity: z.ZodNumber;
+        overallScore: z.ZodNumber;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        relatedIdeas: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        generatedAt: z.ZodDate;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    description?: string;
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    questions?: string[];
+}, {
+    name?: string;
+    id?: string;
+    description?: string;
+    ideas?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        content?: string;
+        tags?: string[];
+        impact?: number;
+        technique?: CreativityTechnique;
+        novelty?: number;
+        feasibility?: number;
+        diversity?: number;
+        overallScore?: number;
+        relatedIdeas?: string[];
+        generatedAt?: Date;
+    }[];
+    questions?: string[];
+}>;
+/**
+ * Perspective Type
+ */
+export type Perspective = z.infer<typeof PerspectiveSchema>;
 //# sourceMappingURL=creativity.d.ts.map