import { z } from "zod";
import { AgentStartedV1 } from "./schemas/agent.started.v1.js";
import { AgentCompletedV1 } from "./schemas/agent.completed.v1.js";
import { AgentFailedV1 } from "./schemas/agent.failed.v1.js";
import { AgentHitlRequestedV1 } from "./schemas/agent.hitl_requested.v1.js";
import { AgentHitlResolvedV1 } from "./schemas/agent.hitl_resolved.v1.js";
import { IncidentSloBurnV1 } from "./schemas/incident.slo_burn.v1.js";
import { IncidentDetectedV1 } from "./schemas/incident.detected.v1.js";
import { ForgeInboxReplyClassifiedV1 } from "./schemas/forge.inbox.reply_classified.v1.js";
import { ForgeLeadQualifiedV1 } from "./schemas/forge.lead.qualified.v1.js";
import { ForgeOutreachSentV1 } from "./schemas/forge.outreach.sent.v1.js";
import { ForgePolicyTriggeredV1 } from "./schemas/forge.policy.triggered.v1.js";
import { VaubanVaultRebalanceProposedV1 } from "./schemas/vauban.vault.rebalance_proposed.v1.js";
import { VaubanVaultRebalancedV1 } from "./schemas/vauban.vault.rebalanced.v1.js";
import { GlacisIdentityVerifiedV1 } from "./schemas/glacis.identity.verified.v1.js";
import { CitadelSprintClosedV1 } from "./schemas/citadel.sprint.closed.v1.js";
import { CitadelSprintAnalyzedV1 } from "./schemas/citadel.sprint.analyzed.v1.js";
import { BrainSkillExtractedV1 } from "./schemas/brain.skill.extracted.v1.js";
import { CcCostRecordedV1 } from "./schemas/cc.cost.recorded.v1.js";
import { CcCostAnomalyDetectedV1 } from "./schemas/cc.cost.anomaly_detected.v1.js";
import { TenantProvisionedV1 } from "./schemas/tenant.provisioned.v1.js";
import { TenantBudgetExceededV1 } from "./schemas/tenant.budget.exceeded.v1.js";
import { VaubanVaultAnalyzedV1 } from "./schemas/vauban.vault.analyzed.v1.js";
import { VaubanGoalCheckedV1 } from "./schemas/vauban.goal.checked.v1.js";
import { VaubanRebalancingCheckedV1 } from "./schemas/vauban.rebalancing.checked.v1.js";
import { VaubanTaxCheckedV1 } from "./schemas/vauban.tax.checked.v1.js";
import { VaubanVaultCompoundedV1 } from "./schemas/vauban.vault.compounded.v1.js";
import { VaubanFinanceForecastGeneratedV1 } from "./schemas/vauban-finance.forecast.generated.v1.js";
import { VaubanFinanceTradeExecutedV1 } from "./schemas/vauban-finance.trade.executed.v1.js";
export declare const EventSchemas: {
    readonly "agent.started": z.ZodObject<{
        agentName: z.ZodString;
        runId: z.ZodString;
        inputs: z.ZodUnknown;
        tenantId: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        runId: string;
        agentName: string;
        tenantId?: string | undefined;
        inputs?: unknown;
    }, {
        runId: string;
        agentName: string;
        tenantId?: string | undefined;
        inputs?: unknown;
    }>;
    readonly "agent.completed": z.ZodObject<{
        agentName: z.ZodString;
        runId: z.ZodString;
        outputs: z.ZodUnknown;
        durationMs: z.ZodNumber;
        costUsd: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        runId: string;
        costUsd: number;
        durationMs: number;
        agentName: string;
        outputs?: unknown;
    }, {
        runId: string;
        costUsd: number;
        durationMs: number;
        agentName: string;
        outputs?: unknown;
    }>;
    readonly "agent.failed": z.ZodObject<{
        agentName: z.ZodString;
        runId: z.ZodString;
        error: z.ZodString;
        retryCount: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        error: string;
        runId: string;
        agentName: string;
        retryCount: number;
    }, {
        error: string;
        runId: string;
        agentName: string;
        retryCount: number;
    }>;
    readonly "agent.hitl_requested": z.ZodObject<{
        approvalId: z.ZodString;
        question: z.ZodString;
        deadline: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        approvalId: string;
        question: string;
        deadline: string;
    }, {
        approvalId: string;
        question: string;
        deadline: string;
    }>;
    readonly "agent.hitl_resolved": z.ZodObject<{
        approvalId: z.ZodString;
        decision: z.ZodEnum<["approved", "rejected"]>;
        by: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        decision: "rejected" | "approved";
        by: string;
        approvalId: string;
    }, {
        decision: "rejected" | "approved";
        by: string;
        approvalId: string;
    }>;
    readonly "incident.slo_burn": z.ZodObject<{
        slo: z.ZodString;
        burnRate: z.ZodNumber;
        severity: z.ZodEnum<["low", "medium", "high", "critical"]>;
    }, "strict", z.ZodTypeAny, {
        slo: string;
        burnRate: number;
        severity: "critical" | "low" | "medium" | "high";
    }, {
        slo: string;
        burnRate: number;
        severity: "critical" | "low" | "medium" | "high";
    }>;
    readonly "incident.detected": z.ZodObject<{
        source: z.ZodString;
        severity: z.ZodEnum<["low", "medium", "high", "critical"]>;
        summary: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        source: string;
        severity: "critical" | "low" | "medium" | "high";
        summary: string;
    }, {
        source: string;
        severity: "critical" | "low" | "medium" | "high";
        summary: string;
    }>;
    readonly "forge.inbox.reply_classified": z.ZodObject<{
        uid: z.ZodString;
        from: z.ZodString;
        subject: z.ZodString;
        type: z.ZodEnum<["INTERESTED", "NOT_INTERESTED", "BOUNCE", "SPAM", "OTHER"]>;
        priority: z.ZodEnum<["HIGH", "MEDIUM", "LOW"]>;
        signal: z.ZodString;
        nextAction: z.ZodString;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        type: "INTERESTED" | "NOT_INTERESTED" | "BOUNCE" | "SPAM" | "OTHER";
        timestamp: string;
        schemaVersion: string;
        signal: string;
        priority: "HIGH" | "MEDIUM" | "LOW";
        from: string;
        subject: string;
        uid: string;
        nextAction: string;
    }, {
        type: "INTERESTED" | "NOT_INTERESTED" | "BOUNCE" | "SPAM" | "OTHER";
        timestamp: string;
        schemaVersion: string;
        signal: string;
        priority: "HIGH" | "MEDIUM" | "LOW";
        from: string;
        subject: string;
        uid: string;
        nextAction: string;
    }>;
    readonly "forge.lead.qualified": z.ZodObject<{
        leadId: z.ZodString;
        score: z.ZodNumber;
        source: z.ZodEnum<["inbound", "outbound", "referral"]>;
    }, "strict", z.ZodTypeAny, {
        source: "inbound" | "outbound" | "referral";
        score: number;
        leadId: string;
    }, {
        source: "inbound" | "outbound" | "referral";
        score: number;
        leadId: string;
    }>;
    readonly "forge.outreach.sent": z.ZodObject<{
        leadId: z.ZodString;
        channel: z.ZodEnum<["email", "linkedin", "x", "telegram"]>;
        content: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        content: string;
        channel: "telegram" | "email" | "linkedin" | "x";
        leadId: string;
    }, {
        content: string;
        channel: "telegram" | "email" | "linkedin" | "x";
        leadId: string;
    }>;
    readonly "forge.policy.triggered": z.ZodObject<{
        policyId: z.ZodString;
        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    }, "strict", z.ZodTypeAny, {
        context: Record<string, unknown>;
        policyId: string;
    }, {
        context: Record<string, unknown>;
        policyId: string;
    }>;
    readonly "vauban.vault.rebalance_proposed": z.ZodObject<{
        vaultId: z.ZodString;
        currentRatio: z.ZodNumber;
        targetRatio: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        vaultId: string;
        currentRatio: number;
        targetRatio: number;
    }, {
        vaultId: string;
        currentRatio: number;
        targetRatio: number;
    }>;
    readonly "vauban.vault.rebalanced": z.ZodObject<{
        vaultId: z.ZodString;
        txHash: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        vaultId: string;
        txHash: string;
    }, {
        vaultId: string;
        txHash: string;
    }>;
    readonly "vauban.vault.analyzed": z.ZodObject<{
        vaultId: z.ZodString;
        tvlUsd: z.ZodNumber;
        anomalies: z.ZodArray<z.ZodObject<{
            type: z.ZodString;
            severity: z.ZodEnum<["info", "warning", "error", "critical"]>;
            metric: z.ZodString;
            current: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
            expected: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
            description: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            expected: string | number;
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
            current: string | number;
        }, {
            expected: string | number;
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
            current: string | number;
        }>, "many">;
        overallSeverity: z.ZodEnum<["info", "warning", "error", "critical"]>;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        vaultId: string;
        overallSeverity: "info" | "error" | "critical" | "warning";
        tvlUsd: number;
        anomalies: {
            expected: string | number;
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
            current: string | number;
        }[];
    }, {
        timestamp: string;
        schemaVersion: string;
        vaultId: string;
        overallSeverity: "info" | "error" | "critical" | "warning";
        tvlUsd: number;
        anomalies: {
            expected: string | number;
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
            current: string | number;
        }[];
    }>;
    readonly "vauban.goal.checked": z.ZodObject<{
        goalId: z.ZodString;
        successRate: z.ZodNumber;
        alertLevel: z.ZodEnum<["none", "warning", "critical"]>;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        goalId: string;
        successRate: number;
        alertLevel: "none" | "critical" | "warning";
    }, {
        timestamp: string;
        schemaVersion: string;
        goalId: string;
        successRate: number;
        alertLevel: "none" | "critical" | "warning";
    }>;
    readonly "vauban.rebalancing.checked": z.ZodObject<{
        portfolioId: z.ZodString;
        maxDrift: z.ZodNumber;
        alertLevel: z.ZodEnum<["none", "warning", "critical"]>;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        alertLevel: "none" | "critical" | "warning";
        portfolioId: string;
        maxDrift: number;
    }, {
        timestamp: string;
        schemaVersion: string;
        alertLevel: "none" | "critical" | "warning";
        portfolioId: string;
        maxDrift: number;
    }>;
    readonly "vauban.tax.checked": z.ZodObject<{
        userId: z.ZodString;
        rulesTriggered: z.ZodArray<z.ZodString, "many">;
        alertLevel: z.ZodEnum<["none", "warning", "critical"]>;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        userId: string;
        alertLevel: "none" | "critical" | "warning";
        rulesTriggered: string[];
    }, {
        timestamp: string;
        schemaVersion: string;
        userId: string;
        alertLevel: "none" | "critical" | "warning";
        rulesTriggered: string[];
    }>;
    readonly "vauban.vault.compounded": z.ZodObject<{
        vaultId: z.ZodString;
        compoundedAt: z.ZodString;
        rewardsUsd: z.ZodNumber;
        caller: z.ZodString;
        txHash: z.ZodOptional<z.ZodString>;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        schemaVersion: string;
        vaultId: string;
        compoundedAt: string;
        rewardsUsd: number;
        caller: string;
        txHash?: string | undefined;
    }, {
        schemaVersion: string;
        vaultId: string;
        compoundedAt: string;
        rewardsUsd: number;
        caller: string;
        txHash?: string | undefined;
    }>;
    readonly "vauban-finance.forecast.generated": z.ZodObject<{
        scenarioId: z.ZodString;
        successRate: z.ZodNumber;
        paramVelocity: z.ZodNumber;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        successRate: number;
        scenarioId: string;
        paramVelocity: number;
    }, {
        timestamp: string;
        schemaVersion: string;
        successRate: number;
        scenarioId: string;
        paramVelocity: number;
    }>;
    readonly "vauban-finance.trade.executed": z.ZodObject<{
        symbol: z.ZodString;
        direction: z.ZodEnum<["long", "short", "hold"]>;
        quantity: z.ZodNumber;
        conviction: z.ZodNumber;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        symbol: string;
        timestamp: string;
        schemaVersion: string;
        direction: "long" | "short" | "hold";
        quantity: number;
        conviction: number;
    }, {
        symbol: string;
        timestamp: string;
        schemaVersion: string;
        direction: "long" | "short" | "hold";
        quantity: number;
        conviction: number;
    }>;
    readonly "glacis.identity.verified": z.ZodObject<{
        userId: z.ZodString;
        method: z.ZodEnum<["zk_passport", "zk_email", "world_id"]>;
    }, "strict", z.ZodTypeAny, {
        method: "zk_passport" | "zk_email" | "world_id";
        userId: string;
    }, {
        method: "zk_passport" | "zk_email" | "world_id";
        userId: string;
    }>;
    readonly "citadel.sprint.closed": z.ZodObject<{
        sprintId: z.ZodString;
        completed: z.ZodNumber;
        carryOver: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        completed: number;
        sprintId: string;
        carryOver: number;
    }, {
        completed: number;
        sprintId: string;
        carryOver: number;
    }>;
    readonly "citadel.sprint.analyzed": z.ZodObject<{
        sprintId: z.ZodString;
        healthScore: z.ZodNumber;
        overallSeverity: z.ZodEnum<["info", "warning", "error", "critical"]>;
        insights: z.ZodArray<z.ZodObject<{
            type: z.ZodString;
            severity: z.ZodEnum<["info", "warning", "error", "critical"]>;
            metric: z.ZodString;
            description: z.ZodString;
        }, "strict", z.ZodTypeAny, {
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
        }, {
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
        }>, "many">;
        blockers: z.ZodArray<z.ZodString, "many">;
        recommendations: z.ZodArray<z.ZodString, "many">;
        timestamp: z.ZodString;
        schemaVersion: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        timestamp: string;
        schemaVersion: string;
        insights: {
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
        }[];
        sprintId: string;
        healthScore: number;
        overallSeverity: "info" | "error" | "critical" | "warning";
        blockers: string[];
        recommendations: string[];
    }, {
        timestamp: string;
        schemaVersion: string;
        insights: {
            type: string;
            description: string;
            severity: "info" | "error" | "critical" | "warning";
            metric: string;
        }[];
        sprintId: string;
        healthScore: number;
        overallSeverity: "info" | "error" | "critical" | "warning";
        blockers: string[];
        recommendations: string[];
    }>;
    readonly "brain.skill.extracted": z.ZodObject<{
        skillId: z.ZodString;
        agentSource: z.ZodString;
        confidence: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        confidence: number;
        agentSource: string;
        skillId: string;
    }, {
        confidence: number;
        agentSource: string;
        skillId: string;
    }>;
    readonly "cc.cost.recorded": z.ZodObject<{
        agent: z.ZodString;
        costUsd: z.ZodNumber;
        tokens: z.ZodNumber;
        model: z.ZodString;
        tenantId: z.ZodOptional<z.ZodString>;
    }, "strict", z.ZodTypeAny, {
        model: string;
        costUsd: number;
        agent: string;
        tokens: number;
        tenantId?: string | undefined;
    }, {
        model: string;
        costUsd: number;
        agent: string;
        tokens: number;
        tenantId?: string | undefined;
    }>;
    readonly "cc.cost.anomaly_detected": z.ZodObject<{
        agent: z.ZodString;
        expected: z.ZodNumber;
        actual: z.ZodNumber;
        period: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        expected: number;
        agent: string;
        actual: number;
        period: string;
    }, {
        expected: number;
        agent: string;
        actual: number;
        period: string;
    }>;
    readonly "tenant.provisioned": z.ZodObject<{
        tenantId: z.ZodString;
        plan: z.ZodEnum<["starter", "team", "pro", "enterprise"]>;
        virtualKey: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        plan: "starter" | "team" | "pro" | "enterprise";
        tenantId: string;
        virtualKey: string;
    }, {
        plan: "starter" | "team" | "pro" | "enterprise";
        tenantId: string;
        virtualKey: string;
    }>;
    readonly "tenant.budget.exceeded": z.ZodObject<{
        tenantId: z.ZodString;
        period: z.ZodString;
        amountUsd: z.ZodNumber;
        limitUsd: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        tenantId: string;
        period: string;
        amountUsd: number;
        limitUsd: number;
    }, {
        tenantId: string;
        period: string;
        amountUsd: number;
        limitUsd: number;
    }>;
};
export type EventType = {
    type: "agent.started";
    payload: z.infer<typeof AgentStartedV1>;
} | {
    type: "agent.completed";
    payload: z.infer<typeof AgentCompletedV1>;
} | {
    type: "agent.failed";
    payload: z.infer<typeof AgentFailedV1>;
} | {
    type: "agent.hitl_requested";
    payload: z.infer<typeof AgentHitlRequestedV1>;
} | {
    type: "agent.hitl_resolved";
    payload: z.infer<typeof AgentHitlResolvedV1>;
} | {
    type: "incident.slo_burn";
    payload: z.infer<typeof IncidentSloBurnV1>;
} | {
    type: "incident.detected";
    payload: z.infer<typeof IncidentDetectedV1>;
} | {
    type: "forge.inbox.reply_classified";
    payload: z.infer<typeof ForgeInboxReplyClassifiedV1>;
} | {
    type: "forge.lead.qualified";
    payload: z.infer<typeof ForgeLeadQualifiedV1>;
} | {
    type: "forge.outreach.sent";
    payload: z.infer<typeof ForgeOutreachSentV1>;
} | {
    type: "forge.policy.triggered";
    payload: z.infer<typeof ForgePolicyTriggeredV1>;
} | {
    type: "vauban.vault.rebalance_proposed";
    payload: z.infer<typeof VaubanVaultRebalanceProposedV1>;
} | {
    type: "vauban.vault.rebalanced";
    payload: z.infer<typeof VaubanVaultRebalancedV1>;
} | {
    type: "glacis.identity.verified";
    payload: z.infer<typeof GlacisIdentityVerifiedV1>;
} | {
    type: "citadel.sprint.closed";
    payload: z.infer<typeof CitadelSprintClosedV1>;
} | {
    type: "citadel.sprint.analyzed";
    payload: z.infer<typeof CitadelSprintAnalyzedV1>;
} | {
    type: "brain.skill.extracted";
    payload: z.infer<typeof BrainSkillExtractedV1>;
} | {
    type: "cc.cost.recorded";
    payload: z.infer<typeof CcCostRecordedV1>;
} | {
    type: "cc.cost.anomaly_detected";
    payload: z.infer<typeof CcCostAnomalyDetectedV1>;
} | {
    type: "tenant.provisioned";
    payload: z.infer<typeof TenantProvisionedV1>;
} | {
    type: "tenant.budget.exceeded";
    payload: z.infer<typeof TenantBudgetExceededV1>;
} | {
    type: "vauban.vault.analyzed";
    payload: z.infer<typeof VaubanVaultAnalyzedV1>;
} | {
    type: "vauban.goal.checked";
    payload: z.infer<typeof VaubanGoalCheckedV1>;
} | {
    type: "vauban.rebalancing.checked";
    payload: z.infer<typeof VaubanRebalancingCheckedV1>;
} | {
    type: "vauban.tax.checked";
    payload: z.infer<typeof VaubanTaxCheckedV1>;
} | {
    type: "vauban.vault.compounded";
    payload: z.infer<typeof VaubanVaultCompoundedV1>;
} | {
    type: "vauban-finance.forecast.generated";
    payload: z.infer<typeof VaubanFinanceForecastGeneratedV1>;
} | {
    type: "vauban-finance.trade.executed";
    payload: z.infer<typeof VaubanFinanceTradeExecutedV1>;
};
export type EventTypeName = keyof typeof EventSchemas;
export declare function resolveSchema(type: string): z.ZodObject<z.ZodRawShape> | undefined;
export declare function validateEvent(type: string, payload: unknown): {
    valid: boolean;
    error?: string;
};
//# sourceMappingURL=catalogue.d.ts.map