import { z } from 'zod';
export type AgentMode = 'llm' | 'flow' | 'hybrid';
export type AgentTarget = 'config' | 'code' | 'both';
export declare const DomainAnalysisSchema: z.ZodObject<{
    domain: z.ZodString;
    subDomain: z.ZodString;
    entities: z.ZodArray<z.ZodString, "many">;
    workflows: z.ZodArray<z.ZodString, "many">;
    userIntents: z.ZodArray<z.ZodString, "many">;
    keyOutcomes: z.ZodArray<z.ZodString, "many">;
    constraints: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    domain: string;
    subDomain: string;
    entities: string[];
    workflows: string[];
    userIntents: string[];
    keyOutcomes: string[];
    constraints: string[];
}, {
    domain: string;
    subDomain: string;
    entities: string[];
    workflows: string[];
    userIntents: string[];
    keyOutcomes: string[];
    constraints: string[];
}>;
export type DomainAnalysis = {
    domain: string;
    subDomain?: string;
    entities: string[];
    workflows: string[];
    userIntents: string[];
    keyOutcomes: string[];
    constraints?: string[];
};
export declare const ToolRecommendationSchema: z.ZodObject<{
    toolName: z.ZodString;
    description: z.ZodString;
    reason: z.ZodString;
    whenToUse: z.ZodString;
    onError: z.ZodString;
    priority: z.ZodEnum<["required", "recommended", "optional"]>;
}, "strip", z.ZodTypeAny, {
    description: string;
    toolName: string;
    priority: "optional" | "required" | "recommended";
    reason: string;
    whenToUse: string;
    onError: string;
}, {
    description: string;
    toolName: string;
    priority: "optional" | "required" | "recommended";
    reason: string;
    whenToUse: string;
    onError: string;
}>;
export type ToolRecommendation = z.infer<typeof ToolRecommendationSchema>;
export declare const PromptLayerSchema: z.ZodObject<{
    name: z.ZodString;
    content: z.ZodString;
    purpose: z.ZodString;
}, "strip", z.ZodTypeAny, {
    name: string;
    content: string;
    purpose: string;
}, {
    name: string;
    content: string;
    purpose: string;
}>;
export type PromptLayer = z.infer<typeof PromptLayerSchema>;
export declare const SixLayerPromptSchema: z.ZodObject<{
    identityAndRole: z.ZodObject<{
        name: z.ZodString;
        content: z.ZodString;
        purpose: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        content: string;
        purpose: string;
    }, {
        name: string;
        content: string;
        purpose: string;
    }>;
    safetyAndGuardrails: z.ZodObject<{
        name: z.ZodString;
        content: z.ZodString;
        purpose: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        content: string;
        purpose: string;
    }, {
        name: string;
        content: string;
        purpose: string;
    }>;
    toolContract: z.ZodObject<{
        name: z.ZodString;
        content: z.ZodString;
        purpose: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        content: string;
        purpose: string;
    }, {
        name: string;
        content: string;
        purpose: string;
    }>;
    reasoningWorkflow: z.ZodObject<{
        name: z.ZodString;
        content: z.ZodString;
        purpose: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        content: string;
        purpose: string;
    }, {
        name: string;
        content: string;
        purpose: string;
    }>;
    executionPolicy: z.ZodObject<{
        name: z.ZodString;
        content: z.ZodString;
        purpose: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        content: string;
        purpose: string;
    }, {
        name: string;
        content: string;
        purpose: string;
    }>;
    outputConstraints: z.ZodObject<{
        name: z.ZodString;
        content: z.ZodString;
        purpose: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        name: string;
        content: string;
        purpose: string;
    }, {
        name: string;
        content: string;
        purpose: string;
    }>;
}, "strip", z.ZodTypeAny, {
    identityAndRole: {
        name: string;
        content: string;
        purpose: string;
    };
    safetyAndGuardrails: {
        name: string;
        content: string;
        purpose: string;
    };
    toolContract: {
        name: string;
        content: string;
        purpose: string;
    };
    reasoningWorkflow: {
        name: string;
        content: string;
        purpose: string;
    };
    executionPolicy: {
        name: string;
        content: string;
        purpose: string;
    };
    outputConstraints: {
        name: string;
        content: string;
        purpose: string;
    };
}, {
    identityAndRole: {
        name: string;
        content: string;
        purpose: string;
    };
    safetyAndGuardrails: {
        name: string;
        content: string;
        purpose: string;
    };
    toolContract: {
        name: string;
        content: string;
        purpose: string;
    };
    reasoningWorkflow: {
        name: string;
        content: string;
        purpose: string;
    };
    executionPolicy: {
        name: string;
        content: string;
        purpose: string;
    };
    outputConstraints: {
        name: string;
        content: string;
        purpose: string;
    };
}>;
export type SixLayerPrompt = z.infer<typeof SixLayerPromptSchema>;
export declare const FlowNodeSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    purpose: z.ZodString;
    toolCalls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    successCriteria: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    name: string;
    id: string;
    purpose: string;
    successCriteria: string[];
    toolCalls?: string[] | undefined;
}, {
    name: string;
    id: string;
    purpose: string;
    successCriteria: string[];
    toolCalls?: string[] | undefined;
}>;
export type FlowNode = z.infer<typeof FlowNodeSchema>;
export declare const FlowDesignSchema: z.ZodObject<{
    nodes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        purpose: z.ZodString;
        toolCalls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        successCriteria: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        name: string;
        id: string;
        purpose: string;
        successCriteria: string[];
        toolCalls?: string[] | undefined;
    }, {
        name: string;
        id: string;
        purpose: string;
        successCriteria: string[];
        toolCalls?: string[] | undefined;
    }>, "many">;
    entryPoint: z.ZodString;
    transitions: z.ZodArray<z.ZodObject<{
        from: z.ZodString;
        to: z.ZodString;
        trigger: z.ZodString;
        condition: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        from: string;
        to: string;
        trigger: string;
        condition?: string | undefined;
    }, {
        from: string;
        to: string;
        trigger: string;
        condition?: string | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    nodes: {
        name: string;
        id: string;
        purpose: string;
        successCriteria: string[];
        toolCalls?: string[] | undefined;
    }[];
    transitions: {
        from: string;
        to: string;
        trigger: string;
        condition?: string | undefined;
    }[];
    entryPoint: string;
}, {
    nodes: {
        name: string;
        id: string;
        purpose: string;
        successCriteria: string[];
        toolCalls?: string[] | undefined;
    }[];
    transitions: {
        from: string;
        to: string;
        trigger: string;
        condition?: string | undefined;
    }[];
    entryPoint: string;
}>;
export type FlowDesign = z.infer<typeof FlowDesignSchema>;
export declare const ToolSpecificationSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    inputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
    outputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
    integrationSteps: z.ZodArray<z.ZodString, "many">;
    requiredAuth: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    name: string;
    description: string;
    inputSchema: Record<string, any>;
    outputSchema: Record<string, any>;
    integrationSteps: string[];
    requiredAuth?: string[] | undefined;
}, {
    name: string;
    description: string;
    inputSchema: Record<string, any>;
    outputSchema: Record<string, any>;
    integrationSteps: string[];
    requiredAuth?: string[] | undefined;
}>;
export type ToolSpecification = z.infer<typeof ToolSpecificationSchema>;
export declare const ArchitectClarificationSchema: z.ZodObject<{
    question: z.ZodString;
    answer: z.ZodString;
}, "strip", z.ZodTypeAny, {
    question: string;
    answer: string;
}, {
    question: string;
    answer: string;
}>;
export type ArchitectClarification = z.infer<typeof ArchitectClarificationSchema>;
export declare const AgentBlueprintSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    useCase: z.ZodString;
    mode: z.ZodEnum<["llm", "flow", "hybrid"]>;
    target: z.ZodEnum<["config", "code", "both"]>;
    domainAnalysis: z.ZodObject<{
        domain: z.ZodString;
        subDomain: z.ZodString;
        entities: z.ZodArray<z.ZodString, "many">;
        workflows: z.ZodArray<z.ZodString, "many">;
        userIntents: z.ZodArray<z.ZodString, "many">;
        keyOutcomes: z.ZodArray<z.ZodString, "many">;
        constraints: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        domain: string;
        subDomain: string;
        entities: string[];
        workflows: string[];
        userIntents: string[];
        keyOutcomes: string[];
        constraints: string[];
    }, {
        domain: string;
        subDomain: string;
        entities: string[];
        workflows: string[];
        userIntents: string[];
        keyOutcomes: string[];
        constraints: string[];
    }>;
    selectedTools: z.ZodArray<z.ZodString, "many">;
    toolRecommendations: z.ZodArray<z.ZodObject<{
        toolName: z.ZodString;
        description: z.ZodString;
        reason: z.ZodString;
        whenToUse: z.ZodString;
        onError: z.ZodString;
        priority: z.ZodEnum<["required", "recommended", "optional"]>;
    }, "strip", z.ZodTypeAny, {
        description: string;
        toolName: string;
        priority: "optional" | "required" | "recommended";
        reason: string;
        whenToUse: string;
        onError: string;
    }, {
        description: string;
        toolName: string;
        priority: "optional" | "required" | "recommended";
        reason: string;
        whenToUse: string;
        onError: string;
    }>, "many">;
    toolPolicy: z.ZodRecord<z.ZodString, z.ZodString>;
    promptLayers: z.ZodObject<{
        identityAndRole: z.ZodObject<{
            name: z.ZodString;
            content: z.ZodString;
            purpose: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            content: string;
            purpose: string;
        }, {
            name: string;
            content: string;
            purpose: string;
        }>;
        safetyAndGuardrails: z.ZodObject<{
            name: z.ZodString;
            content: z.ZodString;
            purpose: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            content: string;
            purpose: string;
        }, {
            name: string;
            content: string;
            purpose: string;
        }>;
        toolContract: z.ZodObject<{
            name: z.ZodString;
            content: z.ZodString;
            purpose: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            content: string;
            purpose: string;
        }, {
            name: string;
            content: string;
            purpose: string;
        }>;
        reasoningWorkflow: z.ZodObject<{
            name: z.ZodString;
            content: z.ZodString;
            purpose: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            content: string;
            purpose: string;
        }, {
            name: string;
            content: string;
            purpose: string;
        }>;
        executionPolicy: z.ZodObject<{
            name: z.ZodString;
            content: z.ZodString;
            purpose: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            content: string;
            purpose: string;
        }, {
            name: string;
            content: string;
            purpose: string;
        }>;
        outputConstraints: z.ZodObject<{
            name: z.ZodString;
            content: z.ZodString;
            purpose: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            name: string;
            content: string;
            purpose: string;
        }, {
            name: string;
            content: string;
            purpose: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        identityAndRole: {
            name: string;
            content: string;
            purpose: string;
        };
        safetyAndGuardrails: {
            name: string;
            content: string;
            purpose: string;
        };
        toolContract: {
            name: string;
            content: string;
            purpose: string;
        };
        reasoningWorkflow: {
            name: string;
            content: string;
            purpose: string;
        };
        executionPolicy: {
            name: string;
            content: string;
            purpose: string;
        };
        outputConstraints: {
            name: string;
            content: string;
            purpose: string;
        };
    }, {
        identityAndRole: {
            name: string;
            content: string;
            purpose: string;
        };
        safetyAndGuardrails: {
            name: string;
            content: string;
            purpose: string;
        };
        toolContract: {
            name: string;
            content: string;
            purpose: string;
        };
        reasoningWorkflow: {
            name: string;
            content: string;
            purpose: string;
        };
        executionPolicy: {
            name: string;
            content: string;
            purpose: string;
        };
        outputConstraints: {
            name: string;
            content: string;
            purpose: string;
        };
    }>;
    flowDesign: z.ZodOptional<z.ZodObject<{
        nodes: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            purpose: z.ZodString;
            toolCalls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            successCriteria: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            name: string;
            id: string;
            purpose: string;
            successCriteria: string[];
            toolCalls?: string[] | undefined;
        }, {
            name: string;
            id: string;
            purpose: string;
            successCriteria: string[];
            toolCalls?: string[] | undefined;
        }>, "many">;
        entryPoint: z.ZodString;
        transitions: z.ZodArray<z.ZodObject<{
            from: z.ZodString;
            to: z.ZodString;
            trigger: z.ZodString;
            condition: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            from: string;
            to: string;
            trigger: string;
            condition?: string | undefined;
        }, {
            from: string;
            to: string;
            trigger: string;
            condition?: string | undefined;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        nodes: {
            name: string;
            id: string;
            purpose: string;
            successCriteria: string[];
            toolCalls?: string[] | undefined;
        }[];
        transitions: {
            from: string;
            to: string;
            trigger: string;
            condition?: string | undefined;
        }[];
        entryPoint: string;
    }, {
        nodes: {
            name: string;
            id: string;
            purpose: string;
            successCriteria: string[];
            toolCalls?: string[] | undefined;
        }[];
        transitions: {
            from: string;
            to: string;
            trigger: string;
            condition?: string | undefined;
        }[];
        entryPoint: string;
    }>>;
    evalPlan: z.ZodObject<{
        scenarios: z.ZodArray<z.ZodString, "many">;
        passCriteria: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        scenarios: string[];
        passCriteria?: string[] | undefined;
    }, {
        scenarios: string[];
        passCriteria?: string[] | undefined;
    }>;
    toolSpecifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        description: z.ZodString;
        inputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
        outputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
        integrationSteps: z.ZodArray<z.ZodString, "many">;
        requiredAuth: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        name: string;
        description: string;
        inputSchema: Record<string, any>;
        outputSchema: Record<string, any>;
        integrationSteps: string[];
        requiredAuth?: string[] | undefined;
    }, {
        name: string;
        description: string;
        inputSchema: Record<string, any>;
        outputSchema: Record<string, any>;
        integrationSteps: string[];
        requiredAuth?: string[] | undefined;
    }>, "many">>;
    generationMeta: z.ZodObject<{
        generatedAt: z.ZodString;
        model: z.ZodString;
        llmRequired: z.ZodBoolean;
        llmEnabled: z.ZodBoolean;
        llmMode: z.ZodOptional<z.ZodString>;
        interactive: z.ZodBoolean;
        clarificationCount: z.ZodNumber;
        clarifications: z.ZodArray<z.ZodObject<{
            question: z.ZodString;
            answer: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            question: string;
            answer: string;
        }, {
            question: string;
            answer: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        model: string;
        generatedAt: string;
        llmRequired: boolean;
        llmEnabled: boolean;
        interactive: boolean;
        clarificationCount: number;
        clarifications: {
            question: string;
            answer: string;
        }[];
        llmMode?: string | undefined;
    }, {
        model: string;
        generatedAt: string;
        llmRequired: boolean;
        llmEnabled: boolean;
        interactive: boolean;
        clarificationCount: number;
        clarifications: {
            question: string;
            answer: string;
        }[];
        llmMode?: string | undefined;
    }>;
}, "strict", z.ZodTypeAny, {
    mode: "llm" | "flow" | "hybrid";
    name: string;
    id: string;
    useCase: string;
    target: "code" | "config" | "both";
    domainAnalysis: {
        domain: string;
        subDomain: string;
        entities: string[];
        workflows: string[];
        userIntents: string[];
        keyOutcomes: string[];
        constraints: string[];
    };
    selectedTools: string[];
    toolRecommendations: {
        description: string;
        toolName: string;
        priority: "optional" | "required" | "recommended";
        reason: string;
        whenToUse: string;
        onError: string;
    }[];
    toolPolicy: Record<string, string>;
    promptLayers: {
        identityAndRole: {
            name: string;
            content: string;
            purpose: string;
        };
        safetyAndGuardrails: {
            name: string;
            content: string;
            purpose: string;
        };
        toolContract: {
            name: string;
            content: string;
            purpose: string;
        };
        reasoningWorkflow: {
            name: string;
            content: string;
            purpose: string;
        };
        executionPolicy: {
            name: string;
            content: string;
            purpose: string;
        };
        outputConstraints: {
            name: string;
            content: string;
            purpose: string;
        };
    };
    evalPlan: {
        scenarios: string[];
        passCriteria?: string[] | undefined;
    };
    generationMeta: {
        model: string;
        generatedAt: string;
        llmRequired: boolean;
        llmEnabled: boolean;
        interactive: boolean;
        clarificationCount: number;
        clarifications: {
            question: string;
            answer: string;
        }[];
        llmMode?: string | undefined;
    };
    flowDesign?: {
        nodes: {
            name: string;
            id: string;
            purpose: string;
            successCriteria: string[];
            toolCalls?: string[] | undefined;
        }[];
        transitions: {
            from: string;
            to: string;
            trigger: string;
            condition?: string | undefined;
        }[];
        entryPoint: string;
    } | undefined;
    toolSpecifications?: {
        name: string;
        description: string;
        inputSchema: Record<string, any>;
        outputSchema: Record<string, any>;
        integrationSteps: string[];
        requiredAuth?: string[] | undefined;
    }[] | undefined;
}, {
    mode: "llm" | "flow" | "hybrid";
    name: string;
    id: string;
    useCase: string;
    target: "code" | "config" | "both";
    domainAnalysis: {
        domain: string;
        subDomain: string;
        entities: string[];
        workflows: string[];
        userIntents: string[];
        keyOutcomes: string[];
        constraints: string[];
    };
    selectedTools: string[];
    toolRecommendations: {
        description: string;
        toolName: string;
        priority: "optional" | "required" | "recommended";
        reason: string;
        whenToUse: string;
        onError: string;
    }[];
    toolPolicy: Record<string, string>;
    promptLayers: {
        identityAndRole: {
            name: string;
            content: string;
            purpose: string;
        };
        safetyAndGuardrails: {
            name: string;
            content: string;
            purpose: string;
        };
        toolContract: {
            name: string;
            content: string;
            purpose: string;
        };
        reasoningWorkflow: {
            name: string;
            content: string;
            purpose: string;
        };
        executionPolicy: {
            name: string;
            content: string;
            purpose: string;
        };
        outputConstraints: {
            name: string;
            content: string;
            purpose: string;
        };
    };
    evalPlan: {
        scenarios: string[];
        passCriteria?: string[] | undefined;
    };
    generationMeta: {
        model: string;
        generatedAt: string;
        llmRequired: boolean;
        llmEnabled: boolean;
        interactive: boolean;
        clarificationCount: number;
        clarifications: {
            question: string;
            answer: string;
        }[];
        llmMode?: string | undefined;
    };
    flowDesign?: {
        nodes: {
            name: string;
            id: string;
            purpose: string;
            successCriteria: string[];
            toolCalls?: string[] | undefined;
        }[];
        transitions: {
            from: string;
            to: string;
            trigger: string;
            condition?: string | undefined;
        }[];
        entryPoint: string;
    } | undefined;
    toolSpecifications?: {
        name: string;
        description: string;
        inputSchema: Record<string, any>;
        outputSchema: Record<string, any>;
        integrationSteps: string[];
        requiredAuth?: string[] | undefined;
    }[] | undefined;
}>;
export type AgentBlueprint = z.infer<typeof AgentBlueprintSchema>;
export type DetailLevel = 'simple' | 'detailed';
export interface ArchitectOptions {
    useCase: string;
    mode?: AgentMode;
    target?: AgentTarget;
    name?: string;
    model?: string;
    contextText?: string;
    interactive?: boolean;
    maxQuestions?: number;
    cwd?: string;
    detailLevel?: DetailLevel;
}
export interface ArchitectResult {
    blueprint: AgentBlueprint;
    artifacts: {
        prompt?: string;
        flow?: object;
        code?: {
            prompt?: string;
            flow?: string;
        };
        rfc?: string;
    };
}