@emmahyde/thought-patterns/dist/src/schemas/AllToolSchemas.d.ts

MCP server combining systematic thinking, mental models, debugging approaches, and stochastic algorithms for comprehensive cognitive pattern support

import { z } from 'zod';
export declare const MentalModelSchema: z.ZodObject<{
    modelName: z.ZodString;
    problem: z.ZodString;
    steps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    reasoning: z.ZodOptional<z.ZodString>;
    conclusion: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    modelName: string;
    problem: string;
    steps?: string[] | undefined;
    reasoning?: string | undefined;
    conclusion?: string | undefined;
}, {
    modelName: string;
    problem: string;
    steps?: string[] | undefined;
    reasoning?: string | undefined;
    conclusion?: string | undefined;
}>;
export declare const DebuggingApproachSchema: z.ZodObject<{
    approachName: z.ZodString;
    issue: z.ZodString;
    steps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    findings: z.ZodOptional<z.ZodString>;
    resolution: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    approachName: string;
    issue: string;
    steps?: string[] | undefined;
    findings?: string | undefined;
    resolution?: string | undefined;
}, {
    approachName: string;
    issue: string;
    steps?: string[] | undefined;
    findings?: string | undefined;
    resolution?: string | undefined;
}>;
export declare const StochasticAlgorithmSchema: z.ZodObject<{
    algorithm: z.ZodString;
    problem: z.ZodString;
    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    result: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    problem: string;
    algorithm: string;
    parameters?: Record<string, unknown> | undefined;
    result?: string | undefined;
}, {
    problem: string;
    algorithm: string;
    parameters?: Record<string, unknown> | undefined;
    result?: string | undefined;
}>;
export declare const PersonaSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    expertise: z.ZodArray<z.ZodString, "many">;
    background: z.ZodString;
    perspective: z.ZodString;
    biases: z.ZodArray<z.ZodString, "many">;
    communication: z.ZodObject<{
        style: z.ZodString;
        tone: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        style: string;
        tone: string;
    }, {
        style: string;
        tone: string;
    }>;
}, "strip", z.ZodTypeAny, {
    id: string;
    name: string;
    expertise: string[];
    background: string;
    perspective: string;
    biases: string[];
    communication: {
        style: string;
        tone: string;
    };
}, {
    id: string;
    name: string;
    expertise: string[];
    background: string;
    perspective: string;
    biases: string[];
    communication: {
        style: string;
        tone: string;
    };
}>;
export declare const ContributionSchema: z.ZodObject<{
    personaId: z.ZodString;
    content: z.ZodString;
    type: z.ZodEnum<["observation", "question", "insight", "concern", "suggestion", "challenge", "synthesis"]>;
    confidence: z.ZodNumber;
    referenceIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    type: "observation" | "question" | "insight" | "concern" | "suggestion" | "challenge" | "synthesis";
    confidence: number;
    personaId: string;
    content: string;
    referenceIds?: string[] | undefined;
}, {
    type: "observation" | "question" | "insight" | "concern" | "suggestion" | "challenge" | "synthesis";
    confidence: number;
    personaId: string;
    content: string;
    referenceIds?: string[] | undefined;
}>;
export declare const DisagreementPositionSchema: z.ZodObject<{
    personaId: z.ZodString;
    position: z.ZodString;
    arguments: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    personaId: string;
    position: string;
    arguments: string[];
}, {
    personaId: string;
    position: string;
    arguments: string[];
}>;
export declare const DisagreementResolutionSchema: z.ZodObject<{
    type: z.ZodEnum<["consensus", "compromise", "integration", "tabled"]>;
    description: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "consensus" | "compromise" | "integration" | "tabled";
    description: string;
}, {
    type: "consensus" | "compromise" | "integration" | "tabled";
    description: string;
}>;
export declare const DisagreementSchema: z.ZodObject<{
    topic: z.ZodString;
    positions: z.ZodArray<z.ZodObject<{
        personaId: z.ZodString;
        position: z.ZodString;
        arguments: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        personaId: string;
        position: string;
        arguments: string[];
    }, {
        personaId: string;
        position: string;
        arguments: string[];
    }>, "many">;
    resolution: z.ZodOptional<z.ZodObject<{
        type: z.ZodEnum<["consensus", "compromise", "integration", "tabled"]>;
        description: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        type: "consensus" | "compromise" | "integration" | "tabled";
        description: string;
    }, {
        type: "consensus" | "compromise" | "integration" | "tabled";
        description: string;
    }>>;
}, "strip", z.ZodTypeAny, {
    topic: string;
    positions: {
        personaId: string;
        position: string;
        arguments: string[];
    }[];
    resolution?: {
        type: "consensus" | "compromise" | "integration" | "tabled";
        description: string;
    } | undefined;
}, {
    topic: string;
    positions: {
        personaId: string;
        position: string;
        arguments: string[];
    }[];
    resolution?: {
        type: "consensus" | "compromise" | "integration" | "tabled";
        description: string;
    } | undefined;
}>;
export declare const CollaborativeReasoningSchema: z.ZodObject<{
    topic: z.ZodString;
    personas: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        expertise: z.ZodArray<z.ZodString, "many">;
        background: z.ZodString;
        perspective: z.ZodString;
        biases: z.ZodArray<z.ZodString, "many">;
        communication: z.ZodObject<{
            style: z.ZodString;
            tone: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            style: string;
            tone: string;
        }, {
            style: string;
            tone: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        name: string;
        expertise: string[];
        background: string;
        perspective: string;
        biases: string[];
        communication: {
            style: string;
            tone: string;
        };
    }, {
        id: string;
        name: string;
        expertise: string[];
        background: string;
        perspective: string;
        biases: string[];
        communication: {
            style: string;
            tone: string;
        };
    }>, "many">;
    contributions: z.ZodArray<z.ZodObject<{
        personaId: z.ZodString;
        content: z.ZodString;
        type: z.ZodEnum<["observation", "question", "insight", "concern", "suggestion", "challenge", "synthesis"]>;
        confidence: z.ZodNumber;
        referenceIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        type: "observation" | "question" | "insight" | "concern" | "suggestion" | "challenge" | "synthesis";
        confidence: number;
        personaId: string;
        content: string;
        referenceIds?: string[] | undefined;
    }, {
        type: "observation" | "question" | "insight" | "concern" | "suggestion" | "challenge" | "synthesis";
        confidence: number;
        personaId: string;
        content: string;
        referenceIds?: string[] | undefined;
    }>, "many">;
    stage: z.ZodEnum<["problem-definition", "ideation", "critique", "integration", "decision", "reflection"]>;
    activePersonaId: z.ZodString;
    nextPersonaId: z.ZodOptional<z.ZodString>;
    consensusPoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    disagreements: z.ZodOptional<z.ZodArray<z.ZodObject<{
        topic: z.ZodString;
        positions: z.ZodArray<z.ZodObject<{
            personaId: z.ZodString;
            position: z.ZodString;
            arguments: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            personaId: string;
            position: string;
            arguments: string[];
        }, {
            personaId: string;
            position: string;
            arguments: string[];
        }>, "many">;
        resolution: z.ZodOptional<z.ZodObject<{
            type: z.ZodEnum<["consensus", "compromise", "integration", "tabled"]>;
            description: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            type: "consensus" | "compromise" | "integration" | "tabled";
            description: string;
        }, {
            type: "consensus" | "compromise" | "integration" | "tabled";
            description: string;
        }>>;
    }, "strip", z.ZodTypeAny, {
        topic: string;
        positions: {
            personaId: string;
            position: string;
            arguments: string[];
        }[];
        resolution?: {
            type: "consensus" | "compromise" | "integration" | "tabled";
            description: string;
        } | undefined;
    }, {
        topic: string;
        positions: {
            personaId: string;
            position: string;
            arguments: string[];
        }[];
        resolution?: {
            type: "consensus" | "compromise" | "integration" | "tabled";
            description: string;
        } | undefined;
    }>, "many">>;
    keyInsights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    openQuestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    finalRecommendation: z.ZodOptional<z.ZodString>;
    sessionId: z.ZodString;
    iteration: z.ZodNumber;
    suggestedContributionTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["observation", "question", "insight", "concern", "suggestion", "challenge", "synthesis"]>, "many">>;
    nextContributionNeeded: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    topic: string;
    personas: {
        id: string;
        name: string;
        expertise: string[];
        background: string;
        perspective: string;
        biases: string[];
        communication: {
            style: string;
            tone: string;
        };
    }[];
    contributions: {
        type: "observation" | "question" | "insight" | "concern" | "suggestion" | "challenge" | "synthesis";
        confidence: number;
        personaId: string;
        content: string;
        referenceIds?: string[] | undefined;
    }[];
    stage: "integration" | "problem-definition" | "ideation" | "critique" | "decision" | "reflection";
    activePersonaId: string;
    sessionId: string;
    iteration: number;
    nextContributionNeeded: boolean;
    nextPersonaId?: string | undefined;
    consensusPoints?: string[] | undefined;
    disagreements?: {
        topic: string;
        positions: {
            personaId: string;
            position: string;
            arguments: string[];
        }[];
        resolution?: {
            type: "consensus" | "compromise" | "integration" | "tabled";
            description: string;
        } | undefined;
    }[] | undefined;
    keyInsights?: string[] | undefined;
    openQuestions?: string[] | undefined;
    finalRecommendation?: string | undefined;
    suggestedContributionTypes?: ("observation" | "question" | "insight" | "concern" | "suggestion" | "challenge" | "synthesis")[] | undefined;
}, {
    topic: string;
    personas: {
        id: string;
        name: string;
        expertise: string[];
        background: string;
        perspective: string;
        biases: string[];
        communication: {
            style: string;
            tone: string;
        };
    }[];
    contributions: {
        type: "observation" | "question" | "insight" | "concern" | "suggestion" | "challenge" | "synthesis";
        confidence: number;
        personaId: string;
        content: string;
        referenceIds?: string[] | undefined;
    }[];
    stage: "integration" | "problem-definition" | "ideation" | "critique" | "decision" | "reflection";
    activePersonaId: string;
    sessionId: string;
    iteration: number;
    nextContributionNeeded: boolean;
    nextPersonaId?: string | undefined;
    consensusPoints?: string[] | undefined;
    disagreements?: {
        topic: string;
        positions: {
            personaId: string;
            position: string;
            arguments: string[];
        }[];
        resolution?: {
            type: "consensus" | "compromise" | "integration" | "tabled";
            description: string;
        } | undefined;
    }[] | undefined;
    keyInsights?: string[] | undefined;
    openQuestions?: string[] | undefined;
    finalRecommendation?: string | undefined;
    suggestedContributionTypes?: ("observation" | "question" | "insight" | "concern" | "suggestion" | "challenge" | "synthesis")[] | undefined;
}>;
export declare const DecisionOptionSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    description: z.ZodString;
}, "strip", z.ZodTypeAny, {
    name: string;
    description: string;
    id?: string | undefined;
}, {
    name: string;
    description: string;
    id?: string | undefined;
}>;
export declare const DecisionCriterionSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    description: z.ZodString;
    weight: z.ZodNumber;
    evaluationMethod: z.ZodEnum<["quantitative", "qualitative", "boolean"]>;
}, "strip", z.ZodTypeAny, {
    name: string;
    description: string;
    weight: number;
    evaluationMethod: "boolean" | "quantitative" | "qualitative";
    id?: string | undefined;
}, {
    name: string;
    description: string;
    weight: number;
    evaluationMethod: "boolean" | "quantitative" | "qualitative";
    id?: string | undefined;
}>;
export declare const CriterionEvaluationSchema: z.ZodObject<{
    criterionId: z.ZodString;
    optionId: z.ZodString;
    score: z.ZodNumber;
    justification: z.ZodString;
}, "strip", z.ZodTypeAny, {
    criterionId: string;
    optionId: string;
    score: number;
    justification: string;
}, {
    criterionId: string;
    optionId: string;
    score: number;
    justification: string;
}>;
export declare const PossibleOutcomeSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    description: z.ZodString;
    probability: z.ZodNumber;
    value: z.ZodNumber;
    optionId: z.ZodString;
    confidenceInEstimate: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    value: number;
    description: string;
    optionId: string;
    probability: number;
    confidenceInEstimate: number;
    id?: string | undefined;
}, {
    value: number;
    description: string;
    optionId: string;
    probability: number;
    confidenceInEstimate: number;
    id?: string | undefined;
}>;
export declare const InformationGapSchema: z.ZodObject<{
    description: z.ZodString;
    impact: z.ZodNumber;
    researchMethod: z.ZodString;
}, "strip", z.ZodTypeAny, {
    description: string;
    impact: number;
    researchMethod: string;
}, {
    description: string;
    impact: number;
    researchMethod: string;
}>;
export declare const DecisionFrameworkSchema: z.ZodObject<{
    decisionStatement: z.ZodString;
    options: z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        description: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        description: string;
        id?: string | undefined;
    }, {
        name: string;
        description: string;
        id?: string | undefined;
    }>, "many">;
    criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodString;
        description: z.ZodString;
        weight: z.ZodNumber;
        evaluationMethod: z.ZodEnum<["quantitative", "qualitative", "boolean"]>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        description: string;
        weight: number;
        evaluationMethod: "boolean" | "quantitative" | "qualitative";
        id?: string | undefined;
    }, {
        name: string;
        description: string;
        weight: number;
        evaluationMethod: "boolean" | "quantitative" | "qualitative";
        id?: string | undefined;
    }>, "many">>;
    stakeholders: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    timeHorizon: z.ZodOptional<z.ZodString>;
    riskTolerance: z.ZodOptional<z.ZodEnum<["risk-averse", "risk-neutral", "risk-seeking"]>>;
    possibleOutcomes: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        description: z.ZodString;
        probability: z.ZodNumber;
        value: z.ZodNumber;
        optionId: z.ZodString;
        confidenceInEstimate: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        value: number;
        description: string;
        optionId: string;
        probability: number;
        confidenceInEstimate: number;
        id?: string | undefined;
    }, {
        value: number;
        description: string;
        optionId: string;
        probability: number;
        confidenceInEstimate: number;
        id?: string | undefined;
    }>, "many">>;
    criteriaEvaluations: z.ZodOptional<z.ZodArray<z.ZodObject<{
        criterionId: z.ZodString;
        optionId: z.ZodString;
        score: z.ZodNumber;
        justification: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        criterionId: string;
        optionId: string;
        score: number;
        justification: string;
    }, {
        criterionId: string;
        optionId: string;
        score: number;
        justification: string;
    }>, "many">>;
    informationGaps: z.ZodOptional<z.ZodArray<z.ZodObject<{
        description: z.ZodString;
        impact: z.ZodNumber;
        researchMethod: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        description: string;
        impact: number;
        researchMethod: string;
    }, {
        description: string;
        impact: number;
        researchMethod: string;
    }>, "many">>;
    analysisType: z.ZodEnum<["expected-utility", "multi-criteria", "maximin", "minimax-regret", "satisficing"]>;
    stage: z.ZodEnum<["problem-definition", "options", "criteria", "evaluation", "analysis", "recommendation"]>;
    recommendation: z.ZodOptional<z.ZodString>;
    sensitivityInsights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    expectedValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    multiCriteriaScores: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    decisionId: z.ZodString;
    iteration: z.ZodNumber;
    suggestedNextStage: z.ZodOptional<z.ZodString>;
    nextStageNeeded: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    options: {
        name: string;
        description: string;
        id?: string | undefined;
    }[];
    stage: "options" | "problem-definition" | "criteria" | "evaluation" | "analysis" | "recommendation";
    iteration: number;
    decisionStatement: string;
    analysisType: "expected-utility" | "multi-criteria" | "maximin" | "minimax-regret" | "satisficing";
    decisionId: string;
    nextStageNeeded: boolean;
    criteria?: {
        name: string;
        description: string;
        weight: number;
        evaluationMethod: "boolean" | "quantitative" | "qualitative";
        id?: string | undefined;
    }[] | undefined;
    stakeholders?: string[] | undefined;
    constraints?: string[] | undefined;
    timeHorizon?: string | undefined;
    riskTolerance?: "risk-averse" | "risk-neutral" | "risk-seeking" | undefined;
    possibleOutcomes?: {
        value: number;
        description: string;
        optionId: string;
        probability: number;
        confidenceInEstimate: number;
        id?: string | undefined;
    }[] | undefined;
    criteriaEvaluations?: {
        criterionId: string;
        optionId: string;
        score: number;
        justification: string;
    }[] | undefined;
    informationGaps?: {
        description: string;
        impact: number;
        researchMethod: string;
    }[] | undefined;
    recommendation?: string | undefined;
    sensitivityInsights?: string[] | undefined;
    expectedValues?: Record<string, number> | undefined;
    multiCriteriaScores?: Record<string, number> | undefined;
    suggestedNextStage?: string | undefined;
}, {
    options: {
        name: string;
        description: string;
        id?: string | undefined;
    }[];
    stage: "options" | "problem-definition" | "criteria" | "evaluation" | "analysis" | "recommendation";
    iteration: number;
    decisionStatement: string;
    analysisType: "expected-utility" | "multi-criteria" | "maximin" | "minimax-regret" | "satisficing";
    decisionId: string;
    nextStageNeeded: boolean;
    criteria?: {
        name: string;
        description: string;
        weight: number;
        evaluationMethod: "boolean" | "quantitative" | "qualitative";
        id?: string | undefined;
    }[] | undefined;
    stakeholders?: string[] | undefined;
    constraints?: string[] | undefined;
    timeHorizon?: string | undefined;
    riskTolerance?: "risk-averse" | "risk-neutral" | "risk-seeking" | undefined;
    possibleOutcomes?: {
        value: number;
        description: string;
        optionId: string;
        probability: number;
        confidenceInEstimate: number;
        id?: string | undefined;
    }[] | undefined;
    criteriaEvaluations?: {
        criterionId: string;
        optionId: string;
        score: number;
        justification: string;
    }[] | undefined;
    informationGaps?: {
        description: string;
        impact: number;
        researchMethod: string;
    }[] | undefined;
    recommendation?: string | undefined;
    sensitivityInsights?: string[] | undefined;
    expectedValues?: Record<string, number> | undefined;
    multiCriteriaScores?: Record<string, number> | undefined;
    suggestedNextStage?: string | undefined;
}>;
export declare const KnowledgeAssessmentSchema: z.ZodObject<{
    domain: z.ZodString;
    knowledgeLevel: z.ZodEnum<["expert", "proficient", "familiar", "basic", "minimal", "none"]>;
    confidenceScore: z.ZodNumber;
    supportingEvidence: z.ZodString;
    knownLimitations: z.ZodArray<z.ZodString, "many">;
    relevantTrainingCutoff: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    domain: string;
    knowledgeLevel: "expert" | "proficient" | "familiar" | "basic" | "minimal" | "none";
    confidenceScore: number;
    supportingEvidence: string;
    knownLimitations: string[];
    relevantTrainingCutoff?: string | undefined;
}, {
    domain: string;
    knowledgeLevel: "expert" | "proficient" | "familiar" | "basic" | "minimal" | "none";
    confidenceScore: number;
    supportingEvidence: string;
    knownLimitations: string[];
    relevantTrainingCutoff?: string | undefined;
}>;
export declare const ClaimAssessmentSchema: z.ZodObject<{
    claim: z.ZodString;
    status: z.ZodEnum<["fact", "inference", "speculation", "uncertain"]>;
    confidenceScore: z.ZodNumber;
    evidenceBasis: z.ZodString;
    falsifiabilityCriteria: z.ZodOptional<z.ZodString>;
    alternativeInterpretations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    status: "fact" | "inference" | "speculation" | "uncertain";
    confidenceScore: number;
    claim: string;
    evidenceBasis: string;
    falsifiabilityCriteria?: string | undefined;
    alternativeInterpretations?: string[] | undefined;
}, {
    status: "fact" | "inference" | "speculation" | "uncertain";
    confidenceScore: number;
    claim: string;
    evidenceBasis: string;
    falsifiabilityCriteria?: string | undefined;
    alternativeInterpretations?: string[] | undefined;
}>;
export declare const ReasoningAssessmentSchema: z.ZodObject<{
    step: z.ZodString;
    potentialBiases: z.ZodArray<z.ZodString, "many">;
    assumptions: z.ZodArray<z.ZodString, "many">;
    logicalValidity: z.ZodNumber;
    inferenceStrength: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    step: string;
    potentialBiases: string[];
    assumptions: string[];
    logicalValidity: number;
    inferenceStrength: number;
}, {
    step: string;
    potentialBiases: string[];
    assumptions: string[];
    logicalValidity: number;
    inferenceStrength: number;
}>;
export declare const MetacognitiveMonitoringSchema: z.ZodObject<{
    task: z.ZodString;
    stage: z.ZodEnum<["knowledge-assessment", "planning", "execution", "monitoring", "evaluation", "reflection"]>;
    knowledgeAssessment: z.ZodOptional<z.ZodObject<{
        domain: z.ZodString;
        knowledgeLevel: z.ZodEnum<["expert", "proficient", "familiar", "basic", "minimal", "none"]>;
        confidenceScore: z.ZodNumber;
        supportingEvidence: z.ZodString;
        knownLimitations: z.ZodArray<z.ZodString, "many">;
        relevantTrainingCutoff: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        domain: string;
        knowledgeLevel: "expert" | "proficient" | "familiar" | "basic" | "minimal" | "none";
        confidenceScore: number;
        supportingEvidence: string;
        knownLimitations: string[];
        relevantTrainingCutoff?: string | undefined;
    }, {
        domain: string;
        knowledgeLevel: "expert" | "proficient" | "familiar" | "basic" | "minimal" | "none";
        confidenceScore: number;
        supportingEvidence: string;
        knownLimitations: string[];
        relevantTrainingCutoff?: string | undefined;
    }>>;
    claims: z.ZodOptional<z.ZodArray<z.ZodObject<{
        claim: z.ZodString;
        status: z.ZodEnum<["fact", "inference", "speculation", "uncertain"]>;
        confidenceScore: z.ZodNumber;
        evidenceBasis: z.ZodString;
        falsifiabilityCriteria: z.ZodOptional<z.ZodString>;
        alternativeInterpretations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        status: "fact" | "inference" | "speculation" | "uncertain";
        confidenceScore: number;
        claim: string;
        evidenceBasis: string;
        falsifiabilityCriteria?: string | undefined;
        alternativeInterpretations?: string[] | undefined;
    }, {
        status: "fact" | "inference" | "speculation" | "uncertain";
        confidenceScore: number;
        claim: string;
        evidenceBasis: string;
        falsifiabilityCriteria?: string | undefined;
        alternativeInterpretations?: string[] | undefined;
    }>, "many">>;
    reasoningSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
        step: z.ZodString;
        potentialBiases: z.ZodArray<z.ZodString, "many">;
        assumptions: z.ZodArray<z.ZodString, "many">;
        logicalValidity: z.ZodNumber;
        inferenceStrength: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        step: string;
        potentialBiases: string[];
        assumptions: string[];
        logicalValidity: number;
        inferenceStrength: number;
    }, {
        step: string;
        potentialBiases: string[];
        assumptions: string[];
        logicalValidity: number;
        inferenceStrength: number;
    }>, "many">>;
    overallConfidence: z.ZodNumber;
    uncertaintyAreas: z.ZodArray<z.ZodString, "many">;
    recommendedApproach: z.ZodString;
    monitoringId: z.ZodString;
    iteration: z.ZodNumber;
    suggestedAssessments: z.ZodOptional<z.ZodArray<z.ZodEnum<["knowledge", "claim", "reasoning", "overall"]>, "many">>;
    nextAssessmentNeeded: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    stage: "reflection" | "evaluation" | "knowledge-assessment" | "planning" | "execution" | "monitoring";
    iteration: number;
    task: string;
    overallConfidence: number;
    uncertaintyAreas: string[];
    recommendedApproach: string;
    monitoringId: string;
    nextAssessmentNeeded: boolean;
    knowledgeAssessment?: {
        domain: string;
        knowledgeLevel: "expert" | "proficient" | "familiar" | "basic" | "minimal" | "none";
        confidenceScore: number;
        supportingEvidence: string;
        knownLimitations: string[];
        relevantTrainingCutoff?: string | undefined;
    } | undefined;
    claims?: {
        status: "fact" | "inference" | "speculation" | "uncertain";
        confidenceScore: number;
        claim: string;
        evidenceBasis: string;
        falsifiabilityCriteria?: string | undefined;
        alternativeInterpretations?: string[] | undefined;
    }[] | undefined;
    reasoningSteps?: {
        step: string;
        potentialBiases: string[];
        assumptions: string[];
        logicalValidity: number;
        inferenceStrength: number;
    }[] | undefined;
    suggestedAssessments?: ("reasoning" | "claim" | "knowledge" | "overall")[] | undefined;
}, {
    stage: "reflection" | "evaluation" | "knowledge-assessment" | "planning" | "execution" | "monitoring";
    iteration: number;
    task: string;
    overallConfidence: number;
    uncertaintyAreas: string[];
    recommendedApproach: string;
    monitoringId: string;
    nextAssessmentNeeded: boolean;
    knowledgeAssessment?: {
        domain: string;
        knowledgeLevel: "expert" | "proficient" | "familiar" | "basic" | "minimal" | "none";
        confidenceScore: number;
        supportingEvidence: string;
        knownLimitations: string[];
        relevantTrainingCutoff?: string | undefined;
    } | undefined;
    claims?: {
        status: "fact" | "inference" | "speculation" | "uncertain";
        confidenceScore: number;
        claim: string;
        evidenceBasis: string;
        falsifiabilityCriteria?: string | undefined;
        alternativeInterpretations?: string[] | undefined;
    }[] | undefined;
    reasoningSteps?: {
        step: string;
        potentialBiases: string[];
        assumptions: string[];
        logicalValidity: number;
        inferenceStrength: number;
    }[] | undefined;
    suggestedAssessments?: ("reasoning" | "claim" | "knowledge" | "overall")[] | undefined;
}>;
export declare const VariableSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodEnum<["independent", "dependent", "controlled", "confounding"]>;
    operationalization: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type: "independent" | "dependent" | "controlled" | "confounding";
    name: string;
    operationalization?: string | undefined;
}, {
    type: "independent" | "dependent" | "controlled" | "confounding";
    name: string;
    operationalization?: string | undefined;
}>;
export declare const HypothesisSchema: z.ZodObject<{
    statement: z.ZodString;
    variables: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodEnum<["independent", "dependent", "controlled", "confounding"]>;
        operationalization: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        type: "independent" | "dependent" | "controlled" | "confounding";
        name: string;
        operationalization?: string | undefined;
    }, {
        type: "independent" | "dependent" | "controlled" | "confounding";
        name: string;
        operationalization?: string | undefined;
    }>, "many">;
    assumptions: z.ZodArray<z.ZodString, "many">;
    hypothesisId: z.ZodString;
    confidence: z.ZodNumber;
    domain: z.ZodString;
    iteration: z.ZodNumber;
    alternativeTo: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    refinementOf: z.ZodOptional<z.ZodString>;
    status: z.ZodEnum<["proposed", "testing", "supported", "refuted", "refined"]>;
}, "strip", z.ZodTypeAny, {
    status: "proposed" | "testing" | "supported" | "refuted" | "refined";
    confidence: number;
    iteration: number;
    domain: string;
    assumptions: string[];
    statement: string;
    variables: {
        type: "independent" | "dependent" | "controlled" | "confounding";
        name: string;
        operationalization?: string | undefined;
    }[];
    hypothesisId: string;
    alternativeTo?: string[] | undefined;
    refinementOf?: string | undefined;
}, {
    status: "proposed" | "testing" | "supported" | "refuted" | "refined";
    confidence: number;
    iteration: number;
    domain: string;
    assumptions: string[];
    statement: string;
    variables: {
        type: "independent" | "dependent" | "controlled" | "confounding";
        name: string;
        operationalization?: string | undefined;
    }[];
    hypothesisId: string;
    alternativeTo?: string[] | undefined;
    refinementOf?: string | undefined;
}>;
export declare const PredictionSchema: z.ZodObject<{
    if: z.ZodString;
    then: z.ZodString;
    else: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    if: string;
    then: string;
    else?: string | undefined;
}, {
    if: string;
    then: string;
    else?: string | undefined;
}>;
export declare const ExperimentSchema: z.ZodObject<{
    design: z.ZodString;
    methodology: z.ZodString;
    predictions: z.ZodArray<z.ZodObject<{
        if: z.ZodString;
        then: z.ZodString;
        else: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        if: string;
        then: string;
        else?: string | undefined;
    }, {
        if: string;
        then: string;
        else?: string | undefined;
    }>, "many">;
    experimentId: z.ZodString;
    hypothesisId: z.ZodString;
    controlMeasures: z.ZodArray<z.ZodString, "many">;
    results: z.ZodOptional<z.ZodString>;
    outcomeMatched: z.ZodOptional<z.ZodBoolean>;
    unexpectedObservations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    limitations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    nextSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    hypothesisId: string;
    design: string;
    methodology: string;
    predictions: {
        if: string;
        then: string;
        else?: string | undefined;
    }[];
    experimentId: string;
    controlMeasures: string[];
    results?: string | undefined;
    outcomeMatched?: boolean | undefined;
    unexpectedObservations?: string[] | undefined;
    limitations?: string[] | undefined;
    nextSteps?: string[] | undefined;
}, {
    hypothesisId: string;
    design: string;
    methodology: string;
    predictions: {
        if: string;
        then: string;
        else?: string | undefined;
    }[];
    experimentId: string;
    controlMeasures: string[];
    results?: string | undefined;
    outcomeMatched?: boolean | undefined;
    unexpectedObservations?: string[] | undefined;
    limitations?: string[] | undefined;
    nextSteps?: string[] | undefined;
}>;
export declare const ScientificMethodSchema: z.ZodObject<{
    stage: z.ZodEnum<["observation", "question", "hypothesis", "experiment", "analysis", "conclusion", "iteration"]>;
    observation: z.ZodOptional<z.ZodString>;
    question: z.ZodOptional<z.ZodString>;
    hypothesis: z.ZodOptional<z.ZodObject<{
        statement: z.ZodString;
        variables: z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            type: z.ZodEnum<["independent", "dependent", "controlled", "confounding"]>;
            operationalization: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            type: "independent" | "dependent" | "controlled" | "confounding";
            name: string;
            operationalization?: string | undefined;
        }, {
            type: "independent" | "dependent" | "controlled" | "confounding";
            name: string;
            operationalization?: string | undefined;
        }>, "many">;
        assumptions: z.ZodArray<z.ZodString, "many">;
        hypothesisId: z.ZodString;
        confidence: z.ZodNumber;
        domain: z.ZodString;
        iteration: z.ZodNumber;
        alternativeTo: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        refinementOf: z.ZodOptional<z.ZodString>;
        status: z.ZodEnum<["proposed", "testing", "supported", "refuted", "refined"]>;
    }, "strip", z.ZodTypeAny, {
        status: "proposed" | "testing" | "supported" | "refuted" | "refined";
        confidence: number;
        iteration: number;
        domain: string;
        assumptions: string[];
        statement: string;
        variables: {
            type: "independent" | "dependent" | "controlled" | "confounding";
            name: string;
            operationalization?: string | undefined;
        }[];
        hypothesisId: string;
        alternativeTo?: string[] | undefined;
        refinementOf?: string | undefined;
    }, {
        status: "proposed" | "testing" | "supported" | "refuted" | "refined";
        confidence: number;
        iteration: number;
        domain: string;
        assumptions: string[];
        statement: string;
        variables: {
            type: "independent" | "dependent" | "controlled" | "confounding";
            name: string;
            operationalization?: string | undefined;
        }[];
        hypothesisId: string;
        alternativeTo?: string[] | undefined;
        refinementOf?: string | undefined;
    }>>;
    experiment: z.ZodOptional<z.ZodObject<{
        design: z.ZodString;
        methodology: z.ZodString;
        predictions: z.ZodArray<z.ZodObject<{
            if: z.ZodString;
            then: z.ZodString;
            else: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            if: string;
            then: string;
            else?: string | undefined;
        }, {
            if: string;
            then: string;
            else?: string | undefined;
        }>, "many">;
        experimentId: z.ZodString;
        hypothesisId: z.ZodString;
        controlMeasures: z.ZodArray<z.ZodString, "many">;
        results: z.ZodOptional<z.ZodString>;
        outcomeMatched: z.ZodOptional<z.ZodBoolean>;
        unexpectedObservations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        limitations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        nextSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        hypothesisId: string;
        design: string;
        methodology: string;
        predictions: {
            if: string;
            then: string;
            else?: string | undefined;
        }[];
        experimentId: string;
        controlMeasures: string[];
        results?: string | undefined;
        outcomeMatched?: boolean | undefined;
        unexpectedObservations?: string[] | undefined;
        limitations?: string[] | undefined;
        nextSteps?: string[] | undefined;
    }, {
        hypothesisId: string;
        design: string;
        methodology: string;
        predictions: {
            if: string;
            then: string;
            else?: string | undefined;
        }[];
        experimentId: string;
        controlMeasures: string[];
        results?: string | undefined;
        outcomeMatched?: boolean | undefined;
        unexpectedObservations?: string[] | undefined;
        limitations?: string[] | undefined;
        nextSteps?: string[] | undefined;
    }>>;
    analysis: z.ZodOptional<z.ZodString>;
    conclusion: z.ZodOptional<z.ZodString>;
    inquiryId: z.ZodString;
    iteration: z.ZodNumber;
    nextStageNeeded: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    stage: "conclusion" | "observation" | "question" | "iteration" | "analysis" | "hypothesis" | "experiment";
    iteration: number;
    nextStageNeeded: boolean;
    inquiryId: string;
    conclusion?: string | undefined;
    observation?: string | undefined;
    question?: string | undefined;
    analysis?: string | undefined;
    hypothesis?: {
        status: "proposed" | "testing" | "supported" | "refuted" | "refined";
        confidence: number;
        iteration: number;
        domain: string;
        assumptions: string[];
        statement: string;
        variables: {
            type: "independent" | "dependent" | "controlled" | "confounding";
            name: string;
            operationalization?: string | undefined;
        }[];
        hypothesisId: string;
        alternativeTo?: string[] | undefined;
        refinementOf?: string | undefined;
    } | undefined;
    experiment?: {
        hypothesisId: string;
        design: string;
        methodology: string;
        predictions: {
            if: string;
            then: string;
            else?: string | undefined;
        }[];
        experimentId: string;
        controlMeasures: string[];
        results?: string | undefined;
        outcomeMatched?: boolean | undefined;
        unexpectedObservations?: string[] | undefined;
        limitations?: string[] | undefined;
        nextSteps?: string[] | undefined;
    } | undefined;
}, {
    stage: "conclusion" | "observation" | "question" | "iteration" | "analysis" | "hypothesis" | "experiment";
    iteration: number;
    nextStageNeeded: boolean;
    inquiryId: string;
    conclusion?: string | undefined;
    observation?: string | undefined;
    question?: string | undefined;
    analysis?: string | undefined;
    hypothesis?: {
        status: "proposed" | "testing" | "supported" | "refuted" | "refined";
        confidence: number;
        iteration: number;
        domain: string;
        assumptions: string[];
        statement: string;
        variables: {
            type: "independent" | "dependent" | "controlled" | "confounding";
            name: string;
            operationalization?: string | undefined;
        }[];
        hypothesisId: string;
        alternativeTo?: string[] | undefined;
        refinementOf?: string | undefined;
    } | undefined;
    experiment?: {
        hypothesisId: string;
        design: string;
        methodology: string;
        predictions: {
            if: string;
            then: string;
            else?: string | undefined;
        }[];
        experimentId: string;
        controlMeasures: string[];
        results?: string | undefined;
        outcomeMatched?: boolean | undefined;
        unexpectedObservations?: string[] | undefined;
        limitations?: string[] | undefined;
        nextSteps?: string[] | undefined;
    } | undefined;
}>;
export declare const StructuredArgumentationSchema: z.ZodObject<{
    claim: z.ZodString;
    premises: z.ZodArray<z.ZodString, "many">;
    conclusion: z.ZodString;
    argumentId: z.ZodOptional<z.ZodString>;
    argumentType: z.ZodEnum<["thesis", "antithesis", "synthesis", "objection", "rebuttal"]>;
    confidence: z.ZodNumber;
    respondsTo: z.ZodOptional<z.ZodString>;
    supports: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    contradicts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    strengths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    weaknesses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    nextArgumentNeeded: z.ZodBoolean;
    suggestedNextTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["thesis", "antithesis", "synthesis", "objection", "rebuttal"]>, "many">>;
}, "strip", z.ZodTypeAny, {
    confidence: number;
    conclusion: string;
    claim: string;
    premises: string[];
    argumentType: "synthesis" | "thesis" | "antithesis" | "objection" | "rebuttal";
    nextArgumentNeeded: boolean;
    argumentId?: string | undefined;
    respondsTo?: string | undefined;
    supports?: string[] | undefined;
    contradicts?: string[] | undefined;
    strengths?: string[] | undefined;
    weaknesses?: string[] | undefined;
    suggestedNextTypes?: ("synthesis" | "thesis" | "antithesis" | "objection" | "rebuttal")[] | undefined;
}, {
    confidence: number;
    conclusion: string;
    claim: string;
    premises: string[];
    argumentType: "synthesis" | "thesis" | "antithesis" | "objection" | "rebuttal";
    nextArgumentNeeded: boolean;
    argumentId?: string | undefined;
    respondsTo?: string | undefined;
    supports?: string[] | undefined;
    contradicts?: string[] | undefined;
    strengths?: string[] | undefined;
    weaknesses?: string[] | undefined;
    suggestedNextTypes?: ("synthesis" | "thesis" | "antithesis" | "objection" | "rebuttal")[] | undefined;
}>;
export declare const VisualElementSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<["node", "edge", "container", "annotation"]>;
    label: z.ZodOptional<z.ZodString>;
    properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    source: z.ZodOptional<z.ZodString>;
    target: z.ZodOptional<z.ZodString>;
    contains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    type: "node" | "edge" | "container" | "annotation";
    properties: Record<string, unknown>;
    id: string;
    label?: string | undefined;
    source?: string | undefined;
    target?: string | undefined;
    contains?: string[] | undefined;
}, {
    type: "node" | "edge" | "container" | "annotation";
    properties: Record<string, unknown>;
    id: string;
    label?: string | undefined;
    source?: string | undefined;
    target?: string | undefined;
    contains?: string[] | undefined;
}>;
export declare const VisualReasoningSchema: z.ZodObject<{
    operation: z.ZodEnum<["create", "update", "delete", "transform", "observe"]>;
    elements: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["node", "edge", "container", "annotation"]>;
        label: z.ZodOptional<z.ZodString>;
        properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        source: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
        contains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        type: "node" | "edge" | "container" | "annotation";
        properties: Record<string, unknown>;
        id: string;
        label?: string | undefined;
        source?: string | undefined;
        target?: string | undefined;
        contains?: string[] | undefined;
    }, {
        type: "node" | "edge" | "container" | "annotation";
        properties: Record<string, unknown>;
        id: string;
        label?: string | undefined;
        source?: string | undefined;
        target?: string | undefined;
        contains?: string[] | undefined;
    }>, "many">>;
    transformationType: z.ZodOptional<z.ZodEnum<["rotate", "move", "resize", "recolor", "regroup"]>>;
    diagramId: z.ZodString;
    diagramType: z.ZodEnum<["graph", "flowchart", "stateDiagram", "conceptMap", "treeDiagram", "custom"]>;
    iteration: z.ZodNumber;
    observation: z.ZodOptional<z.ZodString>;
    insight: z.ZodOptional<z.ZodString>;
    hypothesis: z.ZodOptional<z.ZodString>;
    nextOperationNeeded: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    iteration: number;
    operation: "create" | "update" | "delete" | "transform" | "observe";
    diagramId: string;
    diagramType: "custom" | "graph" | "flowchart" | "stateDiagram" | "conceptMap" | "treeDiagram";
    nextOperationNeeded: boolean;
    observation?: string | undefined;
    insight?: string | undefined;
    hypothesis?: string | undefined;
    elements?: {
        type: "node" | "edge" | "container" | "annotation";
        properties: Record<string, unknown>;
        id: string;
        label?: string | undefined;
        source?: string | undefined;
        target?: string | undefined;
        contains?: string[] | undefined;
    }[] | undefined;
    transformationType?: "rotate" | "move" | "resize" | "recolor" | "regroup" | undefined;
}, {
    iteration: number;
    operation: "create" | "update" | "delete" | "transform" | "observe";
    diagramId: string;
    diagramType: "custom" | "graph" | "flowchart" | "stateDiagram" | "conceptMap" | "treeDiagram";
    nextOperationNeeded: boolean;
    observation?: string | undefined;
    insight?: string | undefined;
    hypothesis?: string | undefined;
    elements?: {
        type: "node" | "edge" | "container" | "annotation";
        properties: Record<string, unknown>;
        id: string;
        label?: string | undefined;
        source?: string | undefined;
        target?: string | undefined;
        contains?: string[] | undefined;
    }[] | undefined;
    transformationType?: "rotate" | "move" | "resize" | "recolor" | "regroup" | undefined;
}>;
export type MentalModelData = z.infer<typeof MentalModelSchema>;
export type DebuggingApproachData = z.infer<typeof DebuggingApproachSchema>;
export type StochasticAlgorithmData = z.infer<typeof StochasticAlgorithmSchema>;
export type CollaborativeReasoningData = z.infer<typeof CollaborativeReasoningSchema>;
export type DecisionFrameworkData = z.infer<typeof DecisionFrameworkSchema>;
export type MetacognitiveMonitoringData = z.infer<typeof MetacognitiveMonitoringSchema>;
export type ScientificMethodData = z.infer<typeof ScientificMethodSchema>;
export type StructuredArgumentationData = z.infer<typeof StructuredArgumentationSchema>;
export type VisualReasoningData = z.infer<typeof VisualReasoningSchema>;
export type PersonaData = z.infer<typeof PersonaSchema>;
export type ContributionData = z.infer<typeof ContributionSchema>;
export type DisagreementData = z.infer<typeof DisagreementSchema>;
export type DecisionOptionData = z.infer<typeof DecisionOptionSchema>;
export type DecisionCriterionData = z.infer<typeof DecisionCriterionSchema>;
export type KnowledgeAssessmentData = z.infer<typeof KnowledgeAssessmentSchema>;
export type ClaimAssessmentData = z.infer<typeof ClaimAssessmentSchema>;
export type ReasoningAssessmentData = z.infer<typeof ReasoningAssessmentSchema>;
export type VariableData = z.infer<typeof VariableSchema>;
export type HypothesisData = z.infer<typeof HypothesisSchema>;
export type PredictionData = z.infer<typeof PredictionSchema>;
export type ExperimentData = z.infer<typeof ExperimentSchema>;
export type VisualElementData = z.infer<typeof VisualElementSchema>;