@emmahyde/thinking-patterns/dist/src/schemas/ScientificMethodSchema.d.ts

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

import { z } from 'zod';
/**
 * Scientific Method Schema
 *
 * Defines the structure for formal hypothesis testing and experimentation
 * following the scientific method. Includes hypothesis formulation, experimental
 * design, prediction testing, and systematic analysis of results.
 */
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" | "refuted" | "supported" | "refined";
    confidence: number;
    statement: string;
    iteration: number;
    domain: string;
    assumptions: string[];
    variables: {
        type: "independent" | "dependent" | "controlled" | "confounding";
        name: string;
        operationalization?: string | undefined;
    }[];
    hypothesisId: string;
    alternativeTo?: string[] | undefined;
    refinementOf?: string | undefined;
}, {
    status: "proposed" | "testing" | "refuted" | "supported" | "refined";
    confidence: number;
    statement: string;
    iteration: number;
    domain: string;
    assumptions: 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[];
    nextSteps?: string[] | undefined;
    results?: string | undefined;
    outcomeMatched?: boolean | undefined;
    unexpectedObservations?: string[] | undefined;
    limitations?: string[] | undefined;
}, {
    hypothesisId: string;
    design: string;
    methodology: string;
    predictions: {
        if: string;
        then: string;
        else?: string | undefined;
    }[];
    experimentId: string;
    controlMeasures: string[];
    nextSteps?: string[] | undefined;
    results?: string | undefined;
    outcomeMatched?: boolean | undefined;
    unexpectedObservations?: string[] | undefined;
    limitations?: 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" | "refuted" | "supported" | "refined";
        confidence: number;
        statement: string;
        iteration: number;
        domain: string;
        assumptions: string[];
        variables: {
            type: "independent" | "dependent" | "controlled" | "confounding";
            name: string;
            operationalization?: string | undefined;
        }[];
        hypothesisId: string;
        alternativeTo?: string[] | undefined;
        refinementOf?: string | undefined;
    }, {
        status: "proposed" | "testing" | "refuted" | "supported" | "refined";
        confidence: number;
        statement: string;
        iteration: number;
        domain: string;
        assumptions: 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[];
        nextSteps?: string[] | undefined;
        results?: string | undefined;
        outcomeMatched?: boolean | undefined;
        unexpectedObservations?: string[] | undefined;
        limitations?: string[] | undefined;
    }, {
        hypothesisId: string;
        design: string;
        methodology: string;
        predictions: {
            if: string;
            then: string;
            else?: string | undefined;
        }[];
        experimentId: string;
        controlMeasures: string[];
        nextSteps?: string[] | undefined;
        results?: string | undefined;
        outcomeMatched?: boolean | undefined;
        unexpectedObservations?: string[] | undefined;
        limitations?: 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" | "refuted" | "supported" | "refined";
        confidence: number;
        statement: string;
        iteration: number;
        domain: string;
        assumptions: 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[];
        nextSteps?: string[] | undefined;
        results?: string | undefined;
        outcomeMatched?: boolean | undefined;
        unexpectedObservations?: string[] | undefined;
        limitations?: 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" | "refuted" | "supported" | "refined";
        confidence: number;
        statement: string;
        iteration: number;
        domain: string;
        assumptions: 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[];
        nextSteps?: string[] | undefined;
        results?: string | undefined;
        outcomeMatched?: boolean | undefined;
        unexpectedObservations?: string[] | undefined;
        limitations?: string[] | undefined;
    } | undefined;
}>;
export type ScientificMethodData = z.infer<typeof ScientificMethodSchema>;
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>;