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

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

import { z } from 'zod';
/**
 * Problem Decomposition Schema
 *
 * Defines the structure for systematic problem breakdown and task decomposition.
 * Includes hierarchical task structures, resource requirements, risk assessment,
 * stakeholder management, and progress tracking capabilities.
 */
export declare const ResourceRequirementSchema: z.ZodObject<{
    type: z.ZodEnum<["human", "financial", "technical", "infrastructure", "external"]>;
    description: z.ZodString;
    quantity: z.ZodOptional<z.ZodString>;
    availability: z.ZodEnum<["available", "limited", "unavailable", "unknown"]>;
    criticality: z.ZodEnum<["low", "medium", "high", "critical"]>;
}, "strip", z.ZodTypeAny, {
    type: "human" | "financial" | "technical" | "infrastructure" | "external";
    description: string;
    availability: "unknown" | "available" | "limited" | "unavailable";
    criticality: "low" | "medium" | "high" | "critical";
    quantity?: string | undefined;
}, {
    type: "human" | "financial" | "technical" | "infrastructure" | "external";
    description: string;
    availability: "unknown" | "available" | "limited" | "unavailable";
    criticality: "low" | "medium" | "high" | "critical";
    quantity?: string | undefined;
}>;
export declare const RiskSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    description: z.ZodString;
    probability: z.ZodNumber;
    impact: z.ZodEnum<["low", "medium", "high", "critical"]>;
    category: z.ZodEnum<["technical", "resource", "timeline", "external", "quality"]>;
    mitigation: z.ZodOptional<z.ZodString>;
    contingency: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    description: string;
    category: "technical" | "external" | "resource" | "timeline" | "quality";
    impact: "low" | "medium" | "high" | "critical";
    probability: number;
    id?: string | undefined;
    mitigation?: string | undefined;
    contingency?: string | undefined;
}, {
    description: string;
    category: "technical" | "external" | "resource" | "timeline" | "quality";
    impact: "low" | "medium" | "high" | "critical";
    probability: number;
    id?: string | undefined;
    mitigation?: string | undefined;
    contingency?: string | undefined;
}>;
export declare const StakeholderSchema: z.ZodObject<{
    name: z.ZodString;
    role: z.ZodEnum<["owner", "contributor", "reviewer", "approver", "informed"]>;
    influence: z.ZodEnum<["low", "medium", "high"]>;
    interest: z.ZodEnum<["low", "medium", "high"]>;
    availability: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    name: string;
    role: "owner" | "contributor" | "reviewer" | "approver" | "informed";
    influence: "low" | "medium" | "high";
    interest: "low" | "medium" | "high";
    availability?: string | undefined;
}, {
    name: string;
    role: "owner" | "contributor" | "reviewer" | "approver" | "informed";
    influence: "low" | "medium" | "high";
    interest: "low" | "medium" | "high";
    availability?: string | undefined;
}>;
export declare const AcceptanceCriteriaSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    description: z.ZodString;
    measurable: z.ZodBoolean;
    priority: z.ZodEnum<["must-have", "should-have", "could-have", "won't-have"]>;
    testable: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    description: string;
    priority: "must-have" | "should-have" | "could-have" | "won't-have";
    measurable: boolean;
    testable: boolean;
    id?: string | undefined;
}, {
    description: string;
    priority: "must-have" | "should-have" | "could-have" | "won't-have";
    measurable: boolean;
    testable: boolean;
    id?: string | undefined;
}>;
export declare const ProgressTrackingSchema: z.ZodObject<{
    status: z.ZodEnum<["not-started", "in-progress", "blocked", "completed", "cancelled"]>;
    percentComplete: z.ZodOptional<z.ZodNumber>;
    startDate: z.ZodOptional<z.ZodString>;
    endDate: z.ZodOptional<z.ZodString>;
    lastUpdated: z.ZodOptional<z.ZodString>;
    blockers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    milestones: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        date: z.ZodString;
        achieved: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        date: string;
        name: string;
        achieved: boolean;
    }, {
        date: string;
        name: string;
        achieved: boolean;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    status: "not-started" | "in-progress" | "blocked" | "completed" | "cancelled";
    percentComplete?: number | undefined;
    startDate?: string | undefined;
    endDate?: string | undefined;
    lastUpdated?: string | undefined;
    blockers?: string[] | undefined;
    milestones?: {
        date: string;
        name: string;
        achieved: boolean;
    }[] | undefined;
}, {
    status: "not-started" | "in-progress" | "blocked" | "completed" | "cancelled";
    percentComplete?: number | undefined;
    startDate?: string | undefined;
    endDate?: string | undefined;
    lastUpdated?: string | undefined;
    blockers?: string[] | undefined;
    milestones?: {
        date: string;
        name: string;
        achieved: boolean;
    }[] | undefined;
}>;
export type Task = {
    id: string;
    description: string;
    subTasks?: Task[];
    dependencies?: string[];
    effortEstimate?: string;
    implementationOrder?: number;
    priority?: "low" | "medium" | "high" | "critical";
    complexity?: "low" | "medium" | "high";
    category?: string;
    tags?: string[];
    resourceRequirements?: z.infer<typeof ResourceRequirementSchema>[];
    risks?: z.infer<typeof RiskSchema>[];
    stakeholders?: z.infer<typeof StakeholderSchema>[];
    acceptanceCriteria?: z.infer<typeof AcceptanceCriteriaSchema>[];
    progress?: z.infer<typeof ProgressTrackingSchema>;
    assumptions?: string[];
    constraints?: string[];
    deliverables?: string[];
};
export declare const TaskSchema: z.ZodType<Task>;
export declare const DecompositionMetricsSchema: z.ZodObject<{
    totalTasks: z.ZodNumber;
    maxDepth: z.ZodNumber;
    estimatedTotalEffort: z.ZodOptional<z.ZodString>;
    criticalPath: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    riskScore: z.ZodOptional<z.ZodNumber>;
    complexityDistribution: z.ZodOptional<z.ZodObject<{
        low: z.ZodNumber;
        medium: z.ZodNumber;
        high: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        low: number;
        medium: number;
        high: number;
    }, {
        low: number;
        medium: number;
        high: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    totalTasks: number;
    maxDepth: number;
    estimatedTotalEffort?: string | undefined;
    criticalPath?: string[] | undefined;
    riskScore?: number | undefined;
    complexityDistribution?: {
        low: number;
        medium: number;
        high: number;
    } | undefined;
}, {
    totalTasks: number;
    maxDepth: number;
    estimatedTotalEffort?: string | undefined;
    criticalPath?: string[] | undefined;
    riskScore?: number | undefined;
    complexityDistribution?: {
        low: number;
        medium: number;
        high: number;
    } | undefined;
}>;
export declare const ProblemDecompositionSchema: z.ZodObject<{
    problem: z.ZodString;
    decompositionId: z.ZodOptional<z.ZodString>;
    methodology: z.ZodOptional<z.ZodString>;
    scope: z.ZodOptional<z.ZodString>;
    objectives: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    decomposition: z.ZodArray<z.ZodType<Task, z.ZodTypeDef, Task>, "many">;
    metrics: z.ZodOptional<z.ZodObject<{
        totalTasks: z.ZodNumber;
        maxDepth: z.ZodNumber;
        estimatedTotalEffort: z.ZodOptional<z.ZodString>;
        criticalPath: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        riskScore: z.ZodOptional<z.ZodNumber>;
        complexityDistribution: z.ZodOptional<z.ZodObject<{
            low: z.ZodNumber;
            medium: z.ZodNumber;
            high: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            low: number;
            medium: number;
            high: number;
        }, {
            low: number;
            medium: number;
            high: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        totalTasks: number;
        maxDepth: number;
        estimatedTotalEffort?: string | undefined;
        criticalPath?: string[] | undefined;
        riskScore?: number | undefined;
        complexityDistribution?: {
            low: number;
            medium: number;
            high: number;
        } | undefined;
    }, {
        totalTasks: number;
        maxDepth: number;
        estimatedTotalEffort?: string | undefined;
        criticalPath?: string[] | undefined;
        riskScore?: number | undefined;
        complexityDistribution?: {
            low: number;
            medium: number;
            high: number;
        } | undefined;
    }>>;
    completenessCheck: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    reviewNotes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    alternativeApproaches: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    createdBy: z.ZodOptional<z.ZodString>;
    createdDate: z.ZodOptional<z.ZodString>;
    lastModified: z.ZodOptional<z.ZodString>;
    version: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    problem: string;
    decomposition: Task[];
    methodology?: string | undefined;
    decompositionId?: string | undefined;
    scope?: string | undefined;
    objectives?: string[] | undefined;
    metrics?: {
        totalTasks: number;
        maxDepth: number;
        estimatedTotalEffort?: string | undefined;
        criticalPath?: string[] | undefined;
        riskScore?: number | undefined;
        complexityDistribution?: {
            low: number;
            medium: number;
            high: number;
        } | undefined;
    } | undefined;
    completenessCheck?: string[] | undefined;
    reviewNotes?: string[] | undefined;
    alternativeApproaches?: string[] | undefined;
    createdBy?: string | undefined;
    createdDate?: string | undefined;
    lastModified?: string | undefined;
    version?: string | undefined;
}, {
    problem: string;
    decomposition: Task[];
    methodology?: string | undefined;
    decompositionId?: string | undefined;
    scope?: string | undefined;
    objectives?: string[] | undefined;
    metrics?: {
        totalTasks: number;
        maxDepth: number;
        estimatedTotalEffort?: string | undefined;
        criticalPath?: string[] | undefined;
        riskScore?: number | undefined;
        complexityDistribution?: {
            low: number;
            medium: number;
            high: number;
        } | undefined;
    } | undefined;
    completenessCheck?: string[] | undefined;
    reviewNotes?: string[] | undefined;
    alternativeApproaches?: string[] | undefined;
    createdBy?: string | undefined;
    createdDate?: string | undefined;
    lastModified?: string | undefined;
    version?: string | undefined;
}>;
export type ProblemDecompositionData = z.infer<typeof ProblemDecompositionSchema>;
export type ResourceRequirementData = z.infer<typeof ResourceRequirementSchema>;
export type RiskData = z.infer<typeof RiskSchema>;
export type StakeholderData = z.infer<typeof StakeholderSchema>;
export type AcceptanceCriteriaData = z.infer<typeof AcceptanceCriteriaSchema>;
export type ProgressTrackingData = z.infer<typeof ProgressTrackingSchema>;
export type DecompositionMetricsData = z.infer<typeof DecompositionMetricsSchema>;