/**
 * Zod schemas for Knowledge Store validation
 * Based on data-model.md specification
 */
import { z } from 'zod';
/**
 * Schema for Value
 */
export declare const valueSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    priority: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    name: string;
    description: string;
    priority: number;
}, {
    name: string;
    description: string;
    priority: number;
}>;
/**
 * Schema for Belief
 */
export declare const beliefSchema: z.ZodObject<{
    statement: z.ZodString;
    confidence: z.ZodNumber;
    domain: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    domain: string[];
    statement: string;
    confidence: number;
}, {
    domain: string[];
    statement: string;
    confidence: number;
}>;
/**
 * Schema for Identity
 */
export declare const identitySchema: z.ZodObject<{
    professionalTitle: z.ZodOptional<z.ZodString>;
    expertise: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    yearsExperience: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    professionalTitle?: string | undefined;
    expertise?: string[] | undefined;
    yearsExperience?: number | undefined;
}, {
    professionalTitle?: string | undefined;
    expertise?: string[] | undefined;
    yearsExperience?: number | undefined;
}>;
/**
 * Schema for Philosophy
 */
export declare const philosophySchema: z.ZodObject<{
    values: z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodString;
        priority: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        name: string;
        description: string;
        priority: number;
    }, {
        name: string;
        description: string;
        priority: number;
    }>, "many">;
    beliefs: z.ZodArray<z.ZodObject<{
        statement: z.ZodString;
        confidence: z.ZodNumber;
        domain: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        domain: string[];
        statement: string;
        confidence: number;
    }, {
        domain: string[];
        statement: string;
        confidence: number;
    }>, "many">;
    identity: z.ZodObject<{
        professionalTitle: z.ZodOptional<z.ZodString>;
        expertise: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        yearsExperience: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        professionalTitle?: string | undefined;
        expertise?: string[] | undefined;
        yearsExperience?: number | undefined;
    }, {
        professionalTitle?: string | undefined;
        expertise?: string[] | undefined;
        yearsExperience?: number | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    values: {
        name: string;
        description: string;
        priority: number;
    }[];
    identity: {
        professionalTitle?: string | undefined;
        expertise?: string[] | undefined;
        yearsExperience?: number | undefined;
    };
    beliefs: {
        domain: string[];
        statement: string;
        confidence: number;
    }[];
}, {
    values: {
        name: string;
        description: string;
        priority: number;
    }[];
    identity: {
        professionalTitle?: string | undefined;
        expertise?: string[] | undefined;
        yearsExperience?: number | undefined;
    };
    beliefs: {
        domain: string[];
        statement: string;
        confidence: number;
    }[];
}>;
/**
 * Schema for Evidence
 */
export declare const evidenceSchema: z.ZodObject<{
    decision: z.ZodString;
    context: z.ZodString;
    outcome: z.ZodOptional<z.ZodEnum<["positive", "negative", "neutral"]>>;
    timestamp: z.ZodString;
}, "strip", z.ZodTypeAny, {
    context: string;
    decision: string;
    timestamp: string;
    outcome?: "positive" | "negative" | "neutral" | undefined;
}, {
    context: string;
    decision: string;
    timestamp: string;
    outcome?: "positive" | "negative" | "neutral" | undefined;
}>;
/**
 * Schema for PrincipleMetadata
 */
export declare const principleMetadataSchema: z.ZodObject<{
    createdAt: z.ZodString;
    updatedAt: z.ZodString;
    source: z.ZodOptional<z.ZodString>;
    deprecatedAt: z.ZodOptional<z.ZodString>;
    deprecationReason: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    createdAt: string;
    updatedAt: string;
    source?: string | undefined;
    deprecatedAt?: string | undefined;
    deprecationReason?: string | undefined;
}, {
    createdAt: string;
    updatedAt: string;
    source?: string | undefined;
    deprecatedAt?: string | undefined;
    deprecationReason?: string | undefined;
}>;
/**
 * Schema for Principle
 */
export declare const principleSchema: z.ZodObject<{
    id: z.ZodString;
    content: z.ZodString;
    domain: z.ZodArray<z.ZodString, "many">;
    weight: z.ZodNumber;
    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
        decision: z.ZodString;
        context: z.ZodString;
        outcome: z.ZodOptional<z.ZodEnum<["positive", "negative", "neutral"]>>;
        timestamp: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        context: string;
        decision: string;
        timestamp: string;
        outcome?: "positive" | "negative" | "neutral" | undefined;
    }, {
        context: string;
        decision: string;
        timestamp: string;
        outcome?: "positive" | "negative" | "neutral" | undefined;
    }>, "many">>;
    status: z.ZodEnum<["active", "deprecated", "draft"]>;
    metadata: z.ZodObject<{
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        source: z.ZodOptional<z.ZodString>;
        deprecatedAt: z.ZodOptional<z.ZodString>;
        deprecationReason: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        createdAt: string;
        updatedAt: string;
        source?: string | undefined;
        deprecatedAt?: string | undefined;
        deprecationReason?: string | undefined;
    }, {
        createdAt: string;
        updatedAt: string;
        source?: string | undefined;
        deprecatedAt?: string | undefined;
        deprecationReason?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    domain: string[];
    weight: number;
    status: "active" | "deprecated" | "draft";
    id: string;
    content: string;
    evidence: {
        context: string;
        decision: string;
        timestamp: string;
        outcome?: "positive" | "negative" | "neutral" | undefined;
    }[];
    metadata: {
        createdAt: string;
        updatedAt: string;
        source?: string | undefined;
        deprecatedAt?: string | undefined;
        deprecationReason?: string | undefined;
    };
}, {
    domain: string[];
    weight: number;
    status: "active" | "deprecated" | "draft";
    id: string;
    content: string;
    metadata: {
        createdAt: string;
        updatedAt: string;
        source?: string | undefined;
        deprecatedAt?: string | undefined;
        deprecationReason?: string | undefined;
    };
    evidence?: {
        context: string;
        decision: string;
        timestamp: string;
        outcome?: "positive" | "negative" | "neutral" | undefined;
    }[] | undefined;
}>;
/**
 * Schema for PatternOccurrence
 */
export declare const patternOccurrenceSchema: z.ZodObject<{
    context: z.ZodString;
    timestamp: z.ZodString;
    decision: z.ZodString;
}, "strip", z.ZodTypeAny, {
    context: string;
    decision: string;
    timestamp: string;
}, {
    context: string;
    decision: string;
    timestamp: string;
}>;
/**
 * Schema for Pattern
 */
export declare const patternSchema: z.ZodObject<{
    id: z.ZodString;
    description: z.ZodString;
    occurrences: z.ZodArray<z.ZodObject<{
        context: z.ZodString;
        timestamp: z.ZodString;
        decision: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        context: string;
        decision: string;
        timestamp: string;
    }, {
        context: string;
        decision: string;
        timestamp: string;
    }>, "many">;
    status: z.ZodEnum<["emerging", "established", "promoted", "rejected"]>;
    domain: z.ZodArray<z.ZodString, "many">;
    firstSeen: z.ZodString;
    lastSeen: z.ZodString;
    promotedTo: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    domain: string[];
    description: string;
    status: "emerging" | "established" | "promoted" | "rejected";
    id: string;
    occurrences: {
        context: string;
        decision: string;
        timestamp: string;
    }[];
    firstSeen: string;
    lastSeen: string;
    promotedTo?: string | undefined;
}, {
    domain: string[];
    description: string;
    status: "emerging" | "established" | "promoted" | "rejected";
    id: string;
    occurrences: {
        context: string;
        decision: string;
        timestamp: string;
    }[];
    firstSeen: string;
    lastSeen: string;
    promotedTo?: string | undefined;
}>;
/**
 * Schema for RecentDecision
 */
export declare const recentDecisionSchema: z.ZodObject<{
    summary: z.ZodString;
    timestamp: z.ZodString;
    principlesApplied: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    timestamp: string;
    summary: string;
    principlesApplied: string[];
}, {
    timestamp: string;
    summary: string;
    principlesApplied: string[];
}>;
/**
 * Schema for CurrentProject
 */
export declare const currentProjectSchema: z.ZodObject<{
    name: z.ZodString;
    type: z.ZodString;
    technologies: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    name: string;
    type: string;
    technologies: string[];
}, {
    name: string;
    type: string;
    technologies: string[];
}>;
/**
 * Schema for UserPreferences
 */
export declare const userPreferencesSchema: z.ZodObject<{
    verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
    codeStyle: z.ZodOptional<z.ZodString>;
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
    verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
    codeStyle: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
    verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
    codeStyle: z.ZodOptional<z.ZodString>;
}, z.ZodTypeAny, "passthrough">>;
/**
 * Schema for UserContext
 */
export declare const userContextSchema: z.ZodObject<{
    currentProject: z.ZodOptional<z.ZodObject<{
        name: z.ZodString;
        type: z.ZodString;
        technologies: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        name: string;
        type: string;
        technologies: string[];
    }, {
        name: string;
        type: string;
        technologies: string[];
    }>>;
    recentDecisions: z.ZodArray<z.ZodObject<{
        summary: z.ZodString;
        timestamp: z.ZodString;
        principlesApplied: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        timestamp: string;
        summary: string;
        principlesApplied: string[];
    }, {
        timestamp: string;
        summary: string;
        principlesApplied: string[];
    }>, "many">;
    activeGoals: z.ZodArray<z.ZodString, "many">;
    preferences: z.ZodObject<{
        verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
        codeStyle: z.ZodOptional<z.ZodString>;
    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
        verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
        codeStyle: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
        verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
        codeStyle: z.ZodOptional<z.ZodString>;
    }, z.ZodTypeAny, "passthrough">>;
}, "strip", z.ZodTypeAny, {
    recentDecisions: {
        timestamp: string;
        summary: string;
        principlesApplied: string[];
    }[];
    activeGoals: string[];
    preferences: {
        verbosity: "minimal" | "normal" | "detailed";
        codeStyle?: string | undefined;
    } & {
        [k: string]: unknown;
    };
    currentProject?: {
        name: string;
        type: string;
        technologies: string[];
    } | undefined;
}, {
    recentDecisions: {
        timestamp: string;
        summary: string;
        principlesApplied: string[];
    }[];
    activeGoals: string[];
    preferences: {
        verbosity: "minimal" | "normal" | "detailed";
        codeStyle?: string | undefined;
    } & {
        [k: string]: unknown;
    };
    currentProject?: {
        name: string;
        type: string;
        technologies: string[];
    } | undefined;
}>;
/**
 * Schema for KnowledgeMetadata
 */
export declare const knowledgeMetadataSchema: z.ZodObject<{
    createdAt: z.ZodString;
    updatedAt: z.ZodString;
    version: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    version: number;
    createdAt: string;
    updatedAt: string;
}, {
    version: number;
    createdAt: string;
    updatedAt: string;
}>;
/**
 * Schema for IndividualKnowledge
 */
export declare const individualKnowledgeSchema: z.ZodObject<{
    userId: z.ZodString;
    philosophy: z.ZodObject<{
        values: z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            description: z.ZodString;
            priority: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            name: string;
            description: string;
            priority: number;
        }, {
            name: string;
            description: string;
            priority: number;
        }>, "many">;
        beliefs: z.ZodArray<z.ZodObject<{
            statement: z.ZodString;
            confidence: z.ZodNumber;
            domain: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            domain: string[];
            statement: string;
            confidence: number;
        }, {
            domain: string[];
            statement: string;
            confidence: number;
        }>, "many">;
        identity: z.ZodObject<{
            professionalTitle: z.ZodOptional<z.ZodString>;
            expertise: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            yearsExperience: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            professionalTitle?: string | undefined;
            expertise?: string[] | undefined;
            yearsExperience?: number | undefined;
        }, {
            professionalTitle?: string | undefined;
            expertise?: string[] | undefined;
            yearsExperience?: number | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        values: {
            name: string;
            description: string;
            priority: number;
        }[];
        identity: {
            professionalTitle?: string | undefined;
            expertise?: string[] | undefined;
            yearsExperience?: number | undefined;
        };
        beliefs: {
            domain: string[];
            statement: string;
            confidence: number;
        }[];
    }, {
        values: {
            name: string;
            description: string;
            priority: number;
        }[];
        identity: {
            professionalTitle?: string | undefined;
            expertise?: string[] | undefined;
            yearsExperience?: number | undefined;
        };
        beliefs: {
            domain: string[];
            statement: string;
            confidence: number;
        }[];
    }>;
    principles: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        content: z.ZodString;
        domain: z.ZodArray<z.ZodString, "many">;
        weight: z.ZodNumber;
        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
            decision: z.ZodString;
            context: z.ZodString;
            outcome: z.ZodOptional<z.ZodEnum<["positive", "negative", "neutral"]>>;
            timestamp: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            context: string;
            decision: string;
            timestamp: string;
            outcome?: "positive" | "negative" | "neutral" | undefined;
        }, {
            context: string;
            decision: string;
            timestamp: string;
            outcome?: "positive" | "negative" | "neutral" | undefined;
        }>, "many">>;
        status: z.ZodEnum<["active", "deprecated", "draft"]>;
        metadata: z.ZodObject<{
            createdAt: z.ZodString;
            updatedAt: z.ZodString;
            source: z.ZodOptional<z.ZodString>;
            deprecatedAt: z.ZodOptional<z.ZodString>;
            deprecationReason: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            createdAt: string;
            updatedAt: string;
            source?: string | undefined;
            deprecatedAt?: string | undefined;
            deprecationReason?: string | undefined;
        }, {
            createdAt: string;
            updatedAt: string;
            source?: string | undefined;
            deprecatedAt?: string | undefined;
            deprecationReason?: string | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        domain: string[];
        weight: number;
        status: "active" | "deprecated" | "draft";
        id: string;
        content: string;
        evidence: {
            context: string;
            decision: string;
            timestamp: string;
            outcome?: "positive" | "negative" | "neutral" | undefined;
        }[];
        metadata: {
            createdAt: string;
            updatedAt: string;
            source?: string | undefined;
            deprecatedAt?: string | undefined;
            deprecationReason?: string | undefined;
        };
    }, {
        domain: string[];
        weight: number;
        status: "active" | "deprecated" | "draft";
        id: string;
        content: string;
        metadata: {
            createdAt: string;
            updatedAt: string;
            source?: string | undefined;
            deprecatedAt?: string | undefined;
            deprecationReason?: string | undefined;
        };
        evidence?: {
            context: string;
            decision: string;
            timestamp: string;
            outcome?: "positive" | "negative" | "neutral" | undefined;
        }[] | undefined;
    }>, "many">;
    patterns: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        description: z.ZodString;
        occurrences: z.ZodArray<z.ZodObject<{
            context: z.ZodString;
            timestamp: z.ZodString;
            decision: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            context: string;
            decision: string;
            timestamp: string;
        }, {
            context: string;
            decision: string;
            timestamp: string;
        }>, "many">;
        status: z.ZodEnum<["emerging", "established", "promoted", "rejected"]>;
        domain: z.ZodArray<z.ZodString, "many">;
        firstSeen: z.ZodString;
        lastSeen: z.ZodString;
        promotedTo: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        domain: string[];
        description: string;
        status: "emerging" | "established" | "promoted" | "rejected";
        id: string;
        occurrences: {
            context: string;
            decision: string;
            timestamp: string;
        }[];
        firstSeen: string;
        lastSeen: string;
        promotedTo?: string | undefined;
    }, {
        domain: string[];
        description: string;
        status: "emerging" | "established" | "promoted" | "rejected";
        id: string;
        occurrences: {
            context: string;
            decision: string;
            timestamp: string;
        }[];
        firstSeen: string;
        lastSeen: string;
        promotedTo?: string | undefined;
    }>, "many">;
    context: z.ZodObject<{
        currentProject: z.ZodOptional<z.ZodObject<{
            name: z.ZodString;
            type: z.ZodString;
            technologies: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            name: string;
            type: string;
            technologies: string[];
        }, {
            name: string;
            type: string;
            technologies: string[];
        }>>;
        recentDecisions: z.ZodArray<z.ZodObject<{
            summary: z.ZodString;
            timestamp: z.ZodString;
            principlesApplied: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            timestamp: string;
            summary: string;
            principlesApplied: string[];
        }, {
            timestamp: string;
            summary: string;
            principlesApplied: string[];
        }>, "many">;
        activeGoals: z.ZodArray<z.ZodString, "many">;
        preferences: z.ZodObject<{
            verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
            codeStyle: z.ZodOptional<z.ZodString>;
        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
            verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
            codeStyle: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
            verbosity: z.ZodEnum<["minimal", "normal", "detailed"]>;
            codeStyle: z.ZodOptional<z.ZodString>;
        }, z.ZodTypeAny, "passthrough">>;
    }, "strip", z.ZodTypeAny, {
        recentDecisions: {
            timestamp: string;
            summary: string;
            principlesApplied: string[];
        }[];
        activeGoals: string[];
        preferences: {
            verbosity: "minimal" | "normal" | "detailed";
            codeStyle?: string | undefined;
        } & {
            [k: string]: unknown;
        };
        currentProject?: {
            name: string;
            type: string;
            technologies: string[];
        } | undefined;
    }, {
        recentDecisions: {
            timestamp: string;
            summary: string;
            principlesApplied: string[];
        }[];
        activeGoals: string[];
        preferences: {
            verbosity: "minimal" | "normal" | "detailed";
            codeStyle?: string | undefined;
        } & {
            [k: string]: unknown;
        };
        currentProject?: {
            name: string;
            type: string;
            technologies: string[];
        } | undefined;
    }>;
    metadata: z.ZodObject<{
        createdAt: z.ZodString;
        updatedAt: z.ZodString;
        version: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        version: number;
        createdAt: string;
        updatedAt: string;
    }, {
        version: number;
        createdAt: string;
        updatedAt: string;
    }>;
}, "strip", z.ZodTypeAny, {
    philosophy: {
        values: {
            name: string;
            description: string;
            priority: number;
        }[];
        identity: {
            professionalTitle?: string | undefined;
            expertise?: string[] | undefined;
            yearsExperience?: number | undefined;
        };
        beliefs: {
            domain: string[];
            statement: string;
            confidence: number;
        }[];
    };
    principles: {
        domain: string[];
        weight: number;
        status: "active" | "deprecated" | "draft";
        id: string;
        content: string;
        evidence: {
            context: string;
            decision: string;
            timestamp: string;
            outcome?: "positive" | "negative" | "neutral" | undefined;
        }[];
        metadata: {
            createdAt: string;
            updatedAt: string;
            source?: string | undefined;
            deprecatedAt?: string | undefined;
            deprecationReason?: string | undefined;
        };
    }[];
    patterns: {
        domain: string[];
        description: string;
        status: "emerging" | "established" | "promoted" | "rejected";
        id: string;
        occurrences: {
            context: string;
            decision: string;
            timestamp: string;
        }[];
        firstSeen: string;
        lastSeen: string;
        promotedTo?: string | undefined;
    }[];
    context: {
        recentDecisions: {
            timestamp: string;
            summary: string;
            principlesApplied: string[];
        }[];
        activeGoals: string[];
        preferences: {
            verbosity: "minimal" | "normal" | "detailed";
            codeStyle?: string | undefined;
        } & {
            [k: string]: unknown;
        };
        currentProject?: {
            name: string;
            type: string;
            technologies: string[];
        } | undefined;
    };
    metadata: {
        version: number;
        createdAt: string;
        updatedAt: string;
    };
    userId: string;
}, {
    philosophy: {
        values: {
            name: string;
            description: string;
            priority: number;
        }[];
        identity: {
            professionalTitle?: string | undefined;
            expertise?: string[] | undefined;
            yearsExperience?: number | undefined;
        };
        beliefs: {
            domain: string[];
            statement: string;
            confidence: number;
        }[];
    };
    principles: {
        domain: string[];
        weight: number;
        status: "active" | "deprecated" | "draft";
        id: string;
        content: string;
        metadata: {
            createdAt: string;
            updatedAt: string;
            source?: string | undefined;
            deprecatedAt?: string | undefined;
            deprecationReason?: string | undefined;
        };
        evidence?: {
            context: string;
            decision: string;
            timestamp: string;
            outcome?: "positive" | "negative" | "neutral" | undefined;
        }[] | undefined;
    }[];
    patterns: {
        domain: string[];
        description: string;
        status: "emerging" | "established" | "promoted" | "rejected";
        id: string;
        occurrences: {
            context: string;
            decision: string;
            timestamp: string;
        }[];
        firstSeen: string;
        lastSeen: string;
        promotedTo?: string | undefined;
    }[];
    context: {
        recentDecisions: {
            timestamp: string;
            summary: string;
            principlesApplied: string[];
        }[];
        activeGoals: string[];
        preferences: {
            verbosity: "minimal" | "normal" | "detailed";
            codeStyle?: string | undefined;
        } & {
            [k: string]: unknown;
        };
        currentProject?: {
            name: string;
            type: string;
            technologies: string[];
        } | undefined;
    };
    metadata: {
        version: number;
        createdAt: string;
        updatedAt: string;
    };
    userId: string;
}>;
export type ValueInput = z.input<typeof valueSchema>;
export type BeliefInput = z.input<typeof beliefSchema>;
export type PhilosophyInput = z.input<typeof philosophySchema>;
export type EvidenceInput = z.input<typeof evidenceSchema>;
export type PrincipleInput = z.input<typeof principleSchema>;
export type PatternInput = z.input<typeof patternSchema>;
export type UserContextInput = z.input<typeof userContextSchema>;
export type IndividualKnowledgeInput = z.input<typeof individualKnowledgeSchema>;
//# sourceMappingURL=schemas.d.ts.map