agent-contracts/dist/index.d.ts

Declarative YAML DSL toolkit for defining, validating, and rendering multi-agent development workflows

import { z } from 'zod';

declare const SectionSchema: z.ZodObject<{
    title: z.ZodString;
    content: z.ZodOptional<z.ZodString>;
    list: z.ZodOptional<z.ZodEnum<{
        agents: "agents";
        workflow: "workflow";
        validations: "validations";
        guardrails: "guardrails";
    }>>;
}, z.core.$loose>;
type Section = z.infer<typeof SectionSchema>;
declare const RuleSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    description: z.ZodString;
    severity: z.ZodEnum<{
        optional: "optional";
        mandatory: "mandatory";
        recommended: "recommended";
    }>;
    detection_method: z.ZodOptional<z.ZodString>;
    escalation: z.ZodOptional<z.ZodString>;
    ref: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
type Rule = z.infer<typeof RuleSchema>;
declare const EscalationCriterionSchema: z.ZodObject<{
    condition: z.ZodString;
    action: z.ZodEnum<{
        stop_and_report: "stop_and_report";
        report_to_architect: "report_to_architect";
        wait_for_approval: "wait_for_approval";
    }>;
}, z.core.$loose>;
type EscalationCriterion = z.infer<typeof EscalationCriterionSchema>;
declare const PrerequisiteSchema: z.ZodObject<{
    action: z.ZodEnum<{
        read: "read";
        execute: "execute";
    }>;
    target: z.ZodString;
    required: z.ZodBoolean;
}, z.core.$loose>;
type Prerequisite = z.infer<typeof PrerequisiteSchema>;
declare const MemoryCapabilitySchema: z.ZodObject<{
    resumable: z.ZodOptional<z.ZodBoolean>;
    ref_required: z.ZodOptional<z.ZodBoolean>;
    emits_memory_ref: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type MemoryCapability = z.infer<typeof MemoryCapabilitySchema>;
declare const AgentSchema: z.ZodObject<{
    role_name: z.ZodString;
    purpose: z.ZodString;
    own_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
    can_read_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
    can_write_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
    can_execute_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
    can_perform_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
    can_invoke_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
    can_return_handoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
    dispatch_only: z.ZodOptional<z.ZodBoolean>;
    mode: z.ZodOptional<z.ZodEnum<{
        "read-only": "read-only";
        "read-write": "read-write";
    }>>;
    responsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodOptional<z.ZodString>;
        description: z.ZodString;
        severity: z.ZodEnum<{
            optional: "optional";
            mandatory: "mandatory";
            recommended: "recommended";
        }>;
        detection_method: z.ZodOptional<z.ZodString>;
        escalation: z.ZodOptional<z.ZodString>;
        ref: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>>>;
    anti_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
    escalation_criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
        condition: z.ZodString;
        action: z.ZodEnum<{
            stop_and_report: "stop_and_report";
            report_to_architect: "report_to_architect";
            wait_for_approval: "wait_for_approval";
        }>;
    }, z.core.$loose>>>;
    sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
        title: z.ZodString;
        content: z.ZodOptional<z.ZodString>;
        list: z.ZodOptional<z.ZodEnum<{
            agents: "agents";
            workflow: "workflow";
            validations: "validations";
            guardrails: "guardrails";
        }>>;
    }, z.core.$loose>>>;
    prerequisites: z.ZodOptional<z.ZodArray<z.ZodObject<{
        action: z.ZodEnum<{
            read: "read";
            execute: "execute";
        }>;
        target: z.ZodString;
        required: z.ZodBoolean;
    }, z.core.$loose>>>;
    guardrails: z.ZodOptional<z.ZodArray<z.ZodString>>;
    memory: z.ZodOptional<z.ZodObject<{
        resumable: z.ZodOptional<z.ZodBoolean>;
        ref_required: z.ZodOptional<z.ZodBoolean>;
        emits_memory_ref: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    effects: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$loose>;
type Agent = z.infer<typeof AgentSchema>;

declare const ArtifactSchema: z.ZodObject<{
    type: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    owner: z.ZodOptional<z.ZodString>;
    producers: z.ZodDefault<z.ZodArray<z.ZodString>>;
    editors: z.ZodDefault<z.ZodArray<z.ZodString>>;
    consumers: z.ZodDefault<z.ZodArray<z.ZodString>>;
    states: z.ZodDefault<z.ZodArray<z.ZodString>>;
    required_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
    visibility: z.ZodOptional<z.ZodString>;
    classification: z.ZodOptional<z.ZodString>;
    guardrails: z.ZodOptional<z.ZodArray<z.ZodString>>;
    authority: z.ZodOptional<z.ZodEnum<{
        canonical: "canonical";
        derived: "derived";
        generated: "generated";
        control: "control";
    }>>;
    path_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
    exclude_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
    manual_edit: z.ZodOptional<z.ZodEnum<{
        allowed: "allowed";
        discouraged: "discouraged";
        forbidden: "forbidden";
    }>>;
    change_control: z.ZodOptional<z.ZodEnum<{
        none: "none";
        "approval-required": "approval-required";
        "regeneration-required": "regeneration-required";
    }>>;
    derived_from: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
}, z.core.$loose>;
type Artifact = z.infer<typeof ArtifactSchema>;

declare const MatcherSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    type: z.ZodLiteral<"command_regex">;
    pattern: z.ZodString;
}, z.core.$loose>, z.ZodObject<{
    type: z.ZodLiteral<"content_regex">;
    pattern: z.ZodString;
    file_glob: z.ZodOptional<z.ZodString>;
    exclude_glob: z.ZodOptional<z.ZodString>;
}, z.core.$loose>, z.ZodObject<{
    type: z.ZodLiteral<"file_glob">;
    pattern: z.ZodString;
    exclude_glob: z.ZodOptional<z.ZodString>;
}, z.core.$loose>], "type">;
type Matcher = z.infer<typeof MatcherSchema>;
declare const CheckSchema: z.ZodObject<{
    matcher: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
        type: z.ZodLiteral<"command_regex">;
        pattern: z.ZodString;
    }, z.core.$loose>, z.ZodObject<{
        type: z.ZodLiteral<"content_regex">;
        pattern: z.ZodString;
        file_glob: z.ZodOptional<z.ZodString>;
        exclude_glob: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>, z.ZodObject<{
        type: z.ZodLiteral<"file_glob">;
        pattern: z.ZodString;
        exclude_glob: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>], "type">>;
    script: z.ZodOptional<z.ZodString>;
    message: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
type Check = z.infer<typeof CheckSchema>;
declare const BindingOutputSchema: z.ZodObject<{
    target: z.ZodString;
    template: z.ZodOptional<z.ZodString>;
    inline_template: z.ZodOptional<z.ZodString>;
    source: z.ZodOptional<z.ZodString>;
    mode: z.ZodDefault<z.ZodEnum<{
        write: "write";
        patch: "patch";
    }>>;
    format: z.ZodOptional<z.ZodEnum<{
        json: "json";
        yaml: "yaml";
        bash: "bash";
        text: "text";
    }>>;
    patch_strategy: z.ZodOptional<z.ZodEnum<{
        deep_merge: "deep_merge";
        array_append: "array_append";
        section_append: "section_append";
    }>>;
    array_merge_key: z.ZodOptional<z.ZodString>;
    group_by: z.ZodOptional<z.ZodString>;
    executable: z.ZodOptional<z.ZodBoolean>;
    skip_empty: z.ZodOptional<z.ZodBoolean>;
}, z.core.$loose>;
type BindingOutput = z.infer<typeof BindingOutputSchema>;
declare const ReportingSchema: z.ZodObject<{
    commands: z.ZodRecord<z.ZodString, z.ZodString>;
    fail_open: z.ZodDefault<z.ZodBoolean>;
    timeout_ms: z.ZodDefault<z.ZodNumber>;
}, z.core.$loose>;
type Reporting = z.infer<typeof ReportingSchema>;
declare const BindingRenderTargetSchema: z.ZodObject<{
    template: z.ZodOptional<z.ZodString>;
    inline_template: z.ZodOptional<z.ZodString>;
    context: z.ZodEnum<{
        workflow: "workflow";
        agent: "agent";
        task: "task";
        artifact: "artifact";
        tool: "tool";
        validation: "validation";
        handoff_type: "handoff_type";
        policy: "policy";
        guardrail: "guardrail";
        guardrail_policy: "guardrail_policy";
        system: "system";
        navigation_index: "navigation_index";
    }>;
    output: z.ZodString;
    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
    skip_empty: z.ZodOptional<z.ZodBoolean>;
    executable: z.ZodOptional<z.ZodBoolean>;
}, z.core.$loose>;
type BindingRenderTarget = z.infer<typeof BindingRenderTargetSchema>;
/**
 * A single observability span declaration within an event_mapping rule.
 * `axis` identifies the signal axis (e.g. "trace", "metric", "log").
 * `lifecycle` is the lifecycle phase ("start" | "end" | "point", etc.).
 * `each` is an optional iteration expression (template string).
 * `attributes` are template-string key/value pairs rendered at runtime.
 */
declare const EventMappingSpanSchema: z.ZodObject<{
    axis: z.ZodString;
    name: z.ZodString;
    lifecycle: z.ZodString;
    condition: z.ZodOptional<z.ZodString>;
    each: z.ZodOptional<z.ZodString>;
    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, z.core.$loose>;
type EventMappingSpan = z.infer<typeof EventMappingSpanSchema>;
/**
 * A causal link between two spans within an event_mapping rule.
 * `type` is the link kind (e.g. "follows_from", "child_of").
 */
declare const EventMappingLinkSchema: z.ZodObject<{
    type: z.ZodString;
    from: z.ZodString;
    to: z.ZodString;
    condition: z.ZodOptional<z.ZodString>;
    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, z.core.$loose>;
type EventMappingLink = z.infer<typeof EventMappingLinkSchema>;
/**
 * Rule associated with a single hook event name.
 */
declare const EventMappingRuleSchema: z.ZodObject<{
    spans: z.ZodOptional<z.ZodArray<z.ZodObject<{
        axis: z.ZodString;
        name: z.ZodString;
        lifecycle: z.ZodString;
        condition: z.ZodOptional<z.ZodString>;
        each: z.ZodOptional<z.ZodString>;
        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$loose>>>;
    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
        type: z.ZodString;
        from: z.ZodString;
        to: z.ZodString;
        condition: z.ZodOptional<z.ZodString>;
        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$loose>>>;
}, z.core.$loose>;
type EventMappingRule = z.infer<typeof EventMappingRuleSchema>;
declare const SoftwareBindingSchema: z.ZodObject<{
    software: z.ZodString;
    version: z.ZodLiteral<1>;
    extends: z.ZodOptional<z.ZodString>;
    guardrail_impl: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        checks: z.ZodArray<z.ZodObject<{
            matcher: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                type: z.ZodLiteral<"command_regex">;
                pattern: z.ZodString;
            }, z.core.$loose>, z.ZodObject<{
                type: z.ZodLiteral<"content_regex">;
                pattern: z.ZodString;
                file_glob: z.ZodOptional<z.ZodString>;
                exclude_glob: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>, z.ZodObject<{
                type: z.ZodLiteral<"file_glob">;
                pattern: z.ZodString;
                exclude_glob: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>], "type">>;
            script: z.ZodOptional<z.ZodString>;
            message: z.ZodOptional<z.ZodString>;
        }, z.core.$loose>>;
    }, z.core.$strip>>>;
    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        target: z.ZodString;
        template: z.ZodOptional<z.ZodString>;
        inline_template: z.ZodOptional<z.ZodString>;
        source: z.ZodOptional<z.ZodString>;
        mode: z.ZodDefault<z.ZodEnum<{
            write: "write";
            patch: "patch";
        }>>;
        format: z.ZodOptional<z.ZodEnum<{
            json: "json";
            yaml: "yaml";
            bash: "bash";
            text: "text";
        }>>;
        patch_strategy: z.ZodOptional<z.ZodEnum<{
            deep_merge: "deep_merge";
            array_append: "array_append";
            section_append: "section_append";
        }>>;
        array_merge_key: z.ZodOptional<z.ZodString>;
        group_by: z.ZodOptional<z.ZodString>;
        executable: z.ZodOptional<z.ZodBoolean>;
        skip_empty: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$loose>>>;
    renders: z.ZodOptional<z.ZodArray<z.ZodObject<{
        template: z.ZodOptional<z.ZodString>;
        inline_template: z.ZodOptional<z.ZodString>;
        context: z.ZodEnum<{
            workflow: "workflow";
            agent: "agent";
            task: "task";
            artifact: "artifact";
            tool: "tool";
            validation: "validation";
            handoff_type: "handoff_type";
            policy: "policy";
            guardrail: "guardrail";
            guardrail_policy: "guardrail_policy";
            system: "system";
            navigation_index: "navigation_index";
        }>;
        output: z.ZodString;
        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
        skip_empty: z.ZodOptional<z.ZodBoolean>;
        executable: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$loose>>>;
    reporting: z.ZodOptional<z.ZodObject<{
        commands: z.ZodRecord<z.ZodString, z.ZodString>;
        fail_open: z.ZodDefault<z.ZodBoolean>;
        timeout_ms: z.ZodDefault<z.ZodNumber>;
    }, z.core.$loose>>;
    event_mapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        spans: z.ZodOptional<z.ZodArray<z.ZodObject<{
            axis: z.ZodString;
            name: z.ZodString;
            lifecycle: z.ZodString;
            condition: z.ZodOptional<z.ZodString>;
            each: z.ZodOptional<z.ZodString>;
            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.core.$loose>>>;
        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
            type: z.ZodString;
            from: z.ZodString;
            to: z.ZodString;
            condition: z.ZodOptional<z.ZodString>;
            attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, z.core.$loose>>>;
    }, z.core.$loose>>>;
}, z.core.$loose>;
type SoftwareBinding = z.infer<typeof SoftwareBindingSchema>;

declare const CONTEXT_TYPES: readonly ["agent", "task", "artifact", "tool", "validation", "handoff_type", "workflow", "policy", "guardrail", "guardrail_policy", "system", "navigation_index"];
declare const ContextTypeSchema: z.ZodEnum<{
    workflow: "workflow";
    agent: "agent";
    task: "task";
    artifact: "artifact";
    tool: "tool";
    validation: "validation";
    handoff_type: "handoff_type";
    policy: "policy";
    guardrail: "guardrail";
    guardrail_policy: "guardrail_policy";
    system: "system";
    navigation_index: "navigation_index";
}>;
type ContextType = z.infer<typeof ContextTypeSchema>;
declare const ITERABLE_CONTEXT_TYPES: ("workflow" | "agent" | "task" | "artifact" | "tool" | "validation" | "handoff_type" | "policy" | "guardrail" | "guardrail_policy")[];

/**
 * Reusable schema components, following the OpenAPI `components` pattern.
 *
 * `schemas` is a map of named JSON Schema fragments that can be referenced
 * from anywhere in the document via `$ref: "#/components/schemas/<name>"`.
 */
declare const ComponentsSchema: z.ZodObject<{
    schemas: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
}, z.core.$loose>;
type Components = z.infer<typeof ComponentsSchema>;
declare const SCOPE_NODE_TYPES: readonly ["root", "system", "agent", "task", "execution_step", "artifact", "tool", "tool_command", "validation", "handoff_type", "workflow", "workflow_step", "policy", "guardrail", "guardrail_policy", "rule", "escalation_criterion", "prerequisite"];
type ScopeNodeType = (typeof SCOPE_NODE_TYPES)[number];
declare const ScopeNodeTypeSchema: z.ZodEnum<{
    workflow: "workflow";
    agent: "agent";
    task: "task";
    artifact: "artifact";
    tool: "tool";
    validation: "validation";
    handoff_type: "handoff_type";
    policy: "policy";
    guardrail: "guardrail";
    guardrail_policy: "guardrail_policy";
    system: "system";
    root: "root";
    execution_step: "execution_step";
    tool_command: "tool_command";
    workflow_step: "workflow_step";
    rule: "rule";
    escalation_criterion: "escalation_criterion";
    prerequisite: "prerequisite";
}>;
/**
 * Declaration of project-specific `x-*` extension fields.
 * Each key must start with `x-` and describes the expected type/shape
 * so that tooling can validate custom extensions in the future.
 */
declare const XExtensionDeclSchema: z.ZodObject<{
    type: z.ZodString;
    items: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    scope: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        workflow: "workflow";
        agent: "agent";
        task: "task";
        artifact: "artifact";
        tool: "tool";
        validation: "validation";
        handoff_type: "handoff_type";
        policy: "policy";
        guardrail: "guardrail";
        guardrail_policy: "guardrail_policy";
        system: "system";
        root: "root";
        execution_step: "execution_step";
        tool_command: "tool_command";
        workflow_step: "workflow_step";
        rule: "rule";
        escalation_criterion: "escalation_criterion";
        prerequisite: "prerequisite";
    }>>>;
    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    required: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
type XExtensionDecl = z.infer<typeof XExtensionDeclSchema>;
declare const DslSchema: z.ZodObject<{
    version: z.ZodLiteral<1>;
    extends: z.ZodOptional<z.ZodString>;
    system: z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        default_workflow_order: z.ZodArray<z.ZodString>;
        sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            content: z.ZodOptional<z.ZodString>;
            list: z.ZodOptional<z.ZodEnum<{
                agents: "agents";
                workflow: "workflow";
                validations: "validations";
                guardrails: "guardrails";
            }>>;
        }, z.core.$loose>>>;
        context_loading: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
        states: z.ZodDefault<z.ZodArray<z.ZodString>>;
    }, z.core.$loose>;
    agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        role_name: z.ZodString;
        purpose: z.ZodString;
        own_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
        can_read_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
        can_write_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
        can_execute_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
        can_perform_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
        can_invoke_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
        can_return_handoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
        dispatch_only: z.ZodOptional<z.ZodBoolean>;
        mode: z.ZodOptional<z.ZodEnum<{
            "read-only": "read-only";
            "read-write": "read-write";
        }>>;
        responsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodOptional<z.ZodString>;
            description: z.ZodString;
            severity: z.ZodEnum<{
                optional: "optional";
                mandatory: "mandatory";
                recommended: "recommended";
            }>;
            detection_method: z.ZodOptional<z.ZodString>;
            escalation: z.ZodOptional<z.ZodString>;
            ref: z.ZodOptional<z.ZodString>;
        }, z.core.$loose>>>;
        anti_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        escalation_criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
            condition: z.ZodString;
            action: z.ZodEnum<{
                stop_and_report: "stop_and_report";
                report_to_architect: "report_to_architect";
                wait_for_approval: "wait_for_approval";
            }>;
        }, z.core.$loose>>>;
        sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            content: z.ZodOptional<z.ZodString>;
            list: z.ZodOptional<z.ZodEnum<{
                agents: "agents";
                workflow: "workflow";
                validations: "validations";
                guardrails: "guardrails";
            }>>;
        }, z.core.$loose>>>;
        prerequisites: z.ZodOptional<z.ZodArray<z.ZodObject<{
            action: z.ZodEnum<{
                read: "read";
                execute: "execute";
            }>;
            target: z.ZodString;
            required: z.ZodBoolean;
        }, z.core.$loose>>>;
        guardrails: z.ZodOptional<z.ZodArray<z.ZodString>>;
        memory: z.ZodOptional<z.ZodObject<{
            resumable: z.ZodOptional<z.ZodBoolean>;
            ref_required: z.ZodOptional<z.ZodBoolean>;
            emits_memory_ref: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>>;
        effects: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$loose>>>;
    tasks: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        description: z.ZodString;
        target_agent: z.ZodString;
        allowed_from_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
        workflow: z.ZodString;
        input_artifacts: z.ZodArray<z.ZodString>;
        invocation_handoff: z.ZodString;
        result_handoff: z.ZodString;
        default_priority: z.ZodOptional<z.ZodString>;
        responsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
        execution_steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            action: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
            required: z.ZodOptional<z.ZodBoolean>;
            abort_on_failure: z.ZodOptional<z.ZodBoolean>;
            uses_tool: z.ZodOptional<z.ZodString>;
            produces_artifact: z.ZodOptional<z.ZodString>;
            reads_artifact: z.ZodOptional<z.ZodString>;
            validates_artifact: z.ZodOptional<z.ZodString>;
            validation_kind: z.ZodOptional<z.ZodEnum<{
                schema: "schema";
                mechanical: "mechanical";
                semantic: "semantic";
                approval: "approval";
                provenance: "provenance";
                traceability: "traceability";
                fidelity: "fidelity";
            }>>;
            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
            skip_condition: z.ZodOptional<z.ZodString>;
            wait_for_approval: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$loose>>>;
        completion_criteria: z.ZodOptional<z.ZodArray<z.ZodString>>;
        rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodOptional<z.ZodString>;
            description: z.ZodString;
            severity: z.ZodEnum<{
                optional: "optional";
                mandatory: "mandatory";
                recommended: "recommended";
            }>;
            detection_method: z.ZodOptional<z.ZodString>;
            escalation: z.ZodOptional<z.ZodString>;
            ref: z.ZodOptional<z.ZodString>;
        }, z.core.$loose>>>;
        anti_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        escalation_criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
            condition: z.ZodString;
            action: z.ZodEnum<{
                stop_and_report: "stop_and_report";
                report_to_architect: "report_to_architect";
                wait_for_approval: "wait_for_approval";
            }>;
        }, z.core.$loose>>>;
        sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            content: z.ZodOptional<z.ZodString>;
            list: z.ZodOptional<z.ZodEnum<{
                agents: "agents";
                workflow: "workflow";
                validations: "validations";
                guardrails: "guardrails";
            }>>;
        }, z.core.$loose>>>;
        validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
        guardrails: z.ZodOptional<z.ZodArray<z.ZodString>>;
        model_class: z.ZodOptional<z.ZodEnum<{
            fast: "fast";
            standard: "standard";
            thinking: "thinking";
        }>>;
        effects: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$loose>>>;
    artifacts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        type: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
        owner: z.ZodOptional<z.ZodString>;
        producers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        editors: z.ZodDefault<z.ZodArray<z.ZodString>>;
        consumers: z.ZodDefault<z.ZodArray<z.ZodString>>;
        states: z.ZodDefault<z.ZodArray<z.ZodString>>;
        required_validations: z.ZodDefault<z.ZodArray<z.ZodString>>;
        visibility: z.ZodOptional<z.ZodString>;
        classification: z.ZodOptional<z.ZodString>;
        guardrails: z.ZodOptional<z.ZodArray<z.ZodString>>;
        authority: z.ZodOptional<z.ZodEnum<{
            canonical: "canonical";
            derived: "derived";
            generated: "generated";
            control: "control";
        }>>;
        path_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        exclude_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
        manual_edit: z.ZodOptional<z.ZodEnum<{
            allowed: "allowed";
            discouraged: "discouraged";
            forbidden: "forbidden";
        }>>;
        change_control: z.ZodOptional<z.ZodEnum<{
            none: "none";
            "approval-required": "approval-required";
            "regeneration-required": "regeneration-required";
        }>>;
        derived_from: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
    }, z.core.$loose>>>;
    tools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        kind: z.ZodOptional<z.ZodString>;
        extends: z.ZodOptional<z.ZodString>;
        command: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        input_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
        output_artifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
        invokable_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
        cli_contract: z.ZodOptional<z.ZodString>;
        component_contract: z.ZodOptional<z.ZodString>;
        artifact_bindings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
        side_effects: z.ZodDefault<z.ZodArray<z.ZodString>>;
        commands: z.ZodDefault<z.ZodArray<z.ZodObject<{
            command: z.ZodString;
            category: z.ZodString;
            reads: z.ZodDefault<z.ZodArray<z.ZodString>>;
            writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
            purpose: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        guardrails: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$loose>>>;
    validations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        target_artifact: z.ZodString;
        kind: z.ZodEnum<{
            schema: "schema";
            mechanical: "mechanical";
            semantic: "semantic";
            approval: "approval";
            provenance: "provenance";
            traceability: "traceability";
            fidelity: "fidelity";
        }>;
        executor_type: z.ZodOptional<z.ZodEnum<{
            agent: "agent";
            tool: "tool";
        }>>;
        executor: z.ZodOptional<z.ZodString>;
        blocking: z.ZodBoolean;
        produces_evidence: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>>>;
    handoff_types: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        version: z.ZodNumber;
        description: z.ZodOptional<z.ZodString>;
        schema: z.ZodRecord<z.ZodString, z.ZodAny>;
        example: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        target_agent: z.ZodOptional<z.ZodString>;
        workflow_phase: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>>>;
    team_interface: z.ZodOptional<z.ZodObject<{
        version: z.ZodNumber;
        description: z.ZodOptional<z.ZodString>;
        accepts: z.ZodOptional<z.ZodObject<{
            workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
                internal_workflow: z.ZodOptional<z.ZodString>;
                input_handoff: z.ZodString;
                output_handoff: z.ZodString;
                description: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>>;
        }, z.core.$loose>>;
        exposes: z.ZodOptional<z.ZodObject<{
            artifacts: z.ZodArray<z.ZodString>;
        }, z.core.$loose>>;
        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$loose>>;
    imports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        interface: z.ZodString;
        version: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>>>;
    workflow: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        entry_conditions: z.ZodDefault<z.ZodArray<z.ZodString>>;
        trigger: z.ZodOptional<z.ZodString>;
        steps: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
            type: z.ZodLiteral<"delegate">;
            description: z.ZodOptional<z.ZodString>;
            task: z.ZodString;
            from_agent: z.ZodString;
            group: z.ZodOptional<z.ZodString>;
            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
            max_retries: z.ZodOptional<z.ZodNumber>;
            max_follow_ups: z.ZodOptional<z.ZodNumber>;
            retry: z.ZodOptional<z.ZodObject<{
                condition: z.ZodString;
                fix_task: z.ZodString;
                revalidate_task: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"gate">;
            description: z.ZodOptional<z.ZodString>;
            gate_kind: z.ZodString;
            group: z.ZodOptional<z.ZodString>;
            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"handoff">;
            description: z.ZodOptional<z.ZodString>;
            handoff_kind: z.ZodString;
            task: z.ZodOptional<z.ZodString>;
            from_agent: z.ZodOptional<z.ZodString>;
            group: z.ZodOptional<z.ZodString>;
            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
            retry: z.ZodOptional<z.ZodObject<{
                condition: z.ZodString;
                fix_task: z.ZodString;
                revalidate_task: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"validation">;
            description: z.ZodOptional<z.ZodString>;
            validation: z.ZodString;
            group: z.ZodOptional<z.ZodString>;
            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"decision">;
            description: z.ZodOptional<z.ZodString>;
            on: z.ZodOptional<z.ZodString>;
            routing_key: z.ZodOptional<z.ZodString>;
            branches: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
            group: z.ZodOptional<z.ZodString>;
            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"team_task">;
            description: z.ZodOptional<z.ZodString>;
            to_team: z.ZodString;
            workflow: z.ZodString;
            handoff: z.ZodString;
            expects: z.ZodString;
            group: z.ZodOptional<z.ZodString>;
            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$loose>, z.ZodObject<{
            type: z.ZodLiteral<"evaluate">;
            description: z.ZodOptional<z.ZodString>;
            task: z.ZodString;
            from_agent: z.ZodString;
            evaluator_agent: z.ZodOptional<z.ZodString>;
            loop_to: z.ZodString;
            max_iterations: z.ZodNumber;
            inject_as: z.ZodOptional<z.ZodString>;
            on_exhausted: z.ZodOptional<z.ZodEnum<{
                abort: "abort";
                fail_partial: "fail_partial";
                escalate: "escalate";
            }>>;
            group: z.ZodOptional<z.ZodString>;
            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$loose>], "type">>;
        sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            content: z.ZodOptional<z.ZodString>;
            list: z.ZodOptional<z.ZodEnum<{
                agents: "agents";
                workflow: "workflow";
                validations: "validations";
                guardrails: "guardrails";
            }>>;
        }, z.core.$loose>>>;
        external_participants: z.ZodDefault<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            kind: z.ZodEnum<{
                actor: "actor";
                participant: "participant";
            }>;
            label: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
    }, z.core.$loose>>>;
    policies: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        when: z.ZodObject<{
            artifact_type: z.ZodOptional<z.ZodString>;
            workflow: z.ZodOptional<z.ZodString>;
        }, z.core.$loose>;
        requires_validations: z.ZodOptional<z.ZodArray<z.ZodString>>;
        requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$loose>>>;
    guardrails: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        description: z.ZodString;
        scope: z.ZodObject<{
            agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
            tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
            artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
            workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$loose>;
        rationale: z.ZodOptional<z.ZodString>;
        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
        exemptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$loose>>>;
    guardrail_policies: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        rules: z.ZodArray<z.ZodObject<{
            guardrail: z.ZodString;
            severity: z.ZodEnum<{
                mandatory: "mandatory";
                info: "info";
                critical: "critical";
                warning: "warning";
            }>;
            action: z.ZodUnion<readonly [z.ZodEnum<{
                block: "block";
                warn: "warn";
                shadow: "shadow";
                info: "info";
            }>, z.ZodObject<{
                default: z.ZodEnum<{
                    block: "block";
                    warn: "warn";
                    shadow: "shadow";
                    info: "info";
                }>;
                when: z.ZodRecord<z.ZodString, z.ZodEnum<{
                    block: "block";
                    warn: "warn";
                    shadow: "shadow";
                    info: "info";
                }>>;
            }, z.core.$strip>]>;
            allow_override: z.ZodDefault<z.ZodBoolean>;
            override_requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
            escalation: z.ZodOptional<z.ZodObject<{
                target: z.ZodString;
                condition: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>>;
        }, z.core.$loose>>;
    }, z.core.$loose>>>;
    components: z.ZodDefault<z.ZodObject<{
        schemas: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
    }, z.core.$loose>>;
    extensions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        type: z.ZodString;
        items: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        scope: z.ZodOptional<z.ZodArray<z.ZodEnum<{
            workflow: "workflow";
            agent: "agent";
            task: "task";
            artifact: "artifact";
            tool: "tool";
            validation: "validation";
            handoff_type: "handoff_type";
            policy: "policy";
            guardrail: "guardrail";
            guardrail_policy: "guardrail_policy";
            system: "system";
            root: "root";
            execution_step: "execution_step";
            tool_command: "tool_command";
            workflow_step: "workflow_step";
            rule: "rule";
            escalation_criterion: "escalation_criterion";
            prerequisite: "prerequisite";
        }>>>;
        schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
        required: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>>;
    extensions_strict: z.ZodDefault<z.ZodBoolean>;
}, z.core.$loose>;
type Dsl = z.infer<typeof DslSchema>;

/**
 * Zod schema for a handoff type definition.
 *
 * `schema` holds a JSON Schema object describing the full message structure
 * for this handoff type. It may use `allOf` to compose shared fragments
 * (e.g., from `components.schemas`) with type-specific properties.
 *
 * Feature #134 — invocation-common structured fields:
 * `target_agent` and `workflow_phase` are optional structured metadata fields
 * that are rendered as `$tags` in the handoff payload envelope, enabling
 * downstream observability consumers to route/filter handoff events.
 */
declare const HandoffTypeSchema: z.ZodObject<{
    version: z.ZodNumber;
    description: z.ZodOptional<z.ZodString>;
    schema: z.ZodRecord<z.ZodString, z.ZodAny>;
    example: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    target_agent: z.ZodOptional<z.ZodString>;
    workflow_phase: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
type HandoffType = z.infer<typeof HandoffTypeSchema>;

declare const GuardrailScopeSchema: z.ZodObject<{
    agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
    tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
    artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
    workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$loose>;
type GuardrailScope = z.infer<typeof GuardrailScopeSchema>;
declare const GuardrailSchema: z.ZodObject<{
    description: z.ZodString;
    scope: z.ZodObject<{
        agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
        tasks: z.ZodOptional<z.ZodArray<z.ZodString>>;
        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
        artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
        workflows: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$loose>;
    rationale: z.ZodOptional<z.ZodString>;
    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
    exemptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$loose>;
type Guardrail = z.infer<typeof GuardrailSchema>;
declare const GuardrailPolicyRuleEscalationSchema: z.ZodObject<{
    target: z.ZodString;
    condition: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
type GuardrailPolicyRuleEscalation = z.infer<typeof GuardrailPolicyRuleEscalationSchema>;
declare const ActionEnum: z.ZodEnum<{
    block: "block";
    warn: "warn";
    shadow: "shadow";
    info: "info";
}>;
type ActionValue = z.infer<typeof ActionEnum>;
declare const ConditionalActionSchema: z.ZodObject<{
    default: z.ZodEnum<{
        block: "block";
        warn: "warn";
        shadow: "shadow";
        info: "info";
    }>;
    when: z.ZodRecord<z.ZodString, z.ZodEnum<{
        block: "block";
        warn: "warn";
        shadow: "shadow";
        info: "info";
    }>>;
}, z.core.$strip>;
type ConditionalAction = z.infer<typeof ConditionalActionSchema>;
declare const ActionSchema: z.ZodUnion<readonly [z.ZodEnum<{
    block: "block";
    warn: "warn";
    shadow: "shadow";
    info: "info";
}>, z.ZodObject<{
    default: z.ZodEnum<{
        block: "block";
        warn: "warn";
        shadow: "shadow";
        info: "info";
    }>;
    when: z.ZodRecord<z.ZodString, z.ZodEnum<{
        block: "block";
        warn: "warn";
        shadow: "shadow";
        info: "info";
    }>>;
}, z.core.$strip>]>;
type Action = z.infer<typeof ActionSchema>;
declare const GuardrailPolicyRuleSchema: z.ZodObject<{
    guardrail: z.ZodString;
    severity: z.ZodEnum<{
        mandatory: "mandatory";
        info: "info";
        critical: "critical";
        warning: "warning";
    }>;
    action: z.ZodUnion<readonly [z.ZodEnum<{
        block: "block";
        warn: "warn";
        shadow: "shadow";
        info: "info";
    }>, z.ZodObject<{
        default: z.ZodEnum<{
            block: "block";
            warn: "warn";
            shadow: "shadow";
            info: "info";
        }>;
        when: z.ZodRecord<z.ZodString, z.ZodEnum<{
            block: "block";
            warn: "warn";
            shadow: "shadow";
            info: "info";
        }>>;
    }, z.core.$strip>]>;
    allow_override: z.ZodDefault<z.ZodBoolean>;
    override_requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
    escalation: z.ZodOptional<z.ZodObject<{
        target: z.ZodString;
        condition: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>>;
}, z.core.$loose>;
type GuardrailPolicyRule = z.infer<typeof GuardrailPolicyRuleSchema>;
declare const GuardrailPolicySchema: z.ZodObject<{
    description: z.ZodOptional<z.ZodString>;
    rules: z.ZodArray<z.ZodObject<{
        guardrail: z.ZodString;
        severity: z.ZodEnum<{
            mandatory: "mandatory";
            info: "info";
            critical: "critical";
            warning: "warning";
        }>;
        action: z.ZodUnion<readonly [z.ZodEnum<{
            block: "block";
            warn: "warn";
            shadow: "shadow";
            info: "info";
        }>, z.ZodObject<{
            default: z.ZodEnum<{
                block: "block";
                warn: "warn";
                shadow: "shadow";
                info: "info";
            }>;
            when: z.ZodRecord<z.ZodString, z.ZodEnum<{
                block: "block";
                warn: "warn";
                shadow: "shadow";
                info: "info";
            }>>;
        }, z.core.$strip>]>;
        allow_override: z.ZodDefault<z.ZodBoolean>;
        override_requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
        escalation: z.ZodOptional<z.ZodObject<{
            target: z.ZodString;
            condition: z.ZodOptional<z.ZodString>;
        }, z.core.$loose>>;
    }, z.core.$loose>>;
}, z.core.$loose>;
type GuardrailPolicy = z.infer<typeof GuardrailPolicySchema>;

type AnyRecord$2 = Record<string, unknown>;
/**
 * Recursively merge `allOf` arrays in a JSON Schema.
 *
 * Each `allOf` sub-schema is itself resolved first (handling nested
 * `allOf`), then `properties`, `required`, and top-level scalars are
 * merged. After merging, nested property schemas that contain their
 * own `allOf` are also resolved so the output is fully flattened.
 */
declare function resolveAllOf(schema: AnyRecord$2): AnyRecord$2;

type AnyRecord$1 = Record<string, unknown>;
declare function resolveSchemaRefs(schema: AnyRecord$1, components?: Record<string, AnyRecord$1>): AnyRecord$1;

declare const AppendOperatorSchema: z.ZodObject<{
    $append: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>;
type AppendOperator = z.infer<typeof AppendOperatorSchema>;
declare const PrependOperatorSchema: z.ZodObject<{
    $prepend: z.ZodRecord<z.ZodString, z.ZodAny>;
}, z.core.$strip>;
type PrependOperator = z.infer<typeof PrependOperatorSchema>;
declare const InsertAfterOperatorSchema: z.ZodObject<{
    $insert_after: z.ZodObject<{
        after: z.ZodString;
        entries: z.ZodRecord<z.ZodString, z.ZodAny>;
    }, z.core.$strip>;
}, z.core.$strip>;
type InsertAfterOperator = z.infer<typeof InsertAfterOperatorSchema>;
declare const ReplaceOperatorSchema: z.ZodObject<{
    $replace: z.ZodAny;
}, z.core.$strip>;
type ReplaceOperator = z.infer<typeof ReplaceOperatorSchema>;
declare const RemoveOperatorSchema: z.ZodObject<{
    $remove: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        id: z.ZodString;
    }, z.core.$strip>]>>;
}, z.core.$strip>;
type RemoveOperator = z.infer<typeof RemoveOperatorSchema>;
type MergeableRecord<T> = Record<string, T> | {
    $append: Record<string, unknown>;
} | {
    $prepend: Record<string, unknown>;
} | {
    $insert_after: {
        after: string;
        entries: Record<string, unknown>;
    };
} | {
    $replace: unknown;
} | {
    $remove: (string | {
        id: string;
    })[];
};

declare const PolicyWhenSchema: z.ZodObject<{
    artifact_type: z.ZodOptional<z.ZodString>;
    workflow: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
type PolicyWhen = z.infer<typeof PolicyWhenSchema>;
declare const PolicySchema: z.ZodObject<{
    when: z.ZodObject<{
        artifact_type: z.ZodOptional<z.ZodString>;
        workflow: z.ZodOptional<z.ZodString>;
    }, z.core.$loose>;
    requires_validations: z.ZodOptional<z.ZodArray<z.ZodString>>;
    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$loose>;
type Policy = z.infer<typeof PolicySchema>;

declare const VersionLiteralSchema: z.ZodLiteral<1>;
type VersionLiteral = z.infer<typeof VersionLiteralSchema>;
declare const ExtendsSchema: z.ZodOptional<z.ZodString>;
type Extends = z.infer<typeof ExtendsSchema>;
declare const ContextLoadingSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
type ContextLoading = z.infer<typeof ContextLoadingSchema>;
declare const SystemSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    default_workflow_order: z.ZodArray<z.ZodString>;
    sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
        title: z.ZodString;
        content: z.ZodOptional<z.ZodString>;
        list: z.ZodOptional<z.ZodEnum<{
            agents: "agents";
            workflow: "workflow";
            validations: "validations";
            guardrails: "guardrails";
        }>>;
    }, z.core.$loose>>>;
    context_loading: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
    states: z.ZodDefault<z.ZodArray<z.ZodString>>;
}, z.core.$loose>;
type System = z.infer<typeof SystemSchema>;

declare const TeamImportSchema: z.ZodObject<{
    interface: z.ZodString;
    version: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
type TeamImport = z.infer<typeof TeamImportSchema>;

declare const TeamInterfaceAcceptWorkflowSchema: z.ZodObject<{
    internal_workflow: z.ZodOptional<z.ZodString>;
    input_handoff: z.ZodString;
    output_handoff: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
type TeamInterfaceAcceptWorkflow = z.infer<typeof TeamInterfaceAcceptWorkflowSchema>;
declare const TeamInterfaceSchema: z.ZodObject<{
    version: z.ZodNumber;
    description: z.ZodOptional<z.ZodString>;
    accepts: z.ZodOptional<z.ZodObject<{
        workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
            internal_workflow: z.ZodOptional<z.ZodString>;
            input_handoff: z.ZodString;
            output_handoff: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
        }, z.core.$loose>>;
    }, z.core.$loose>>;
    exposes: z.ZodOptional<z.ZodObject<{
        artifacts: z.ZodArray<z.ZodString>;
    }, z.core.$loose>>;
    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$loose>;
type TeamInterface = z.infer<typeof TeamInterfaceSchema>;

declare const ModelClassSchema: z.ZodEnum<{
    fast: "fast";
    standard: "standard";
    thinking: "thinking";
}>;
type ModelClass = z.infer<typeof ModelClassSchema>;
declare const ExecutionStepSchema: z.ZodObject<{
    id: z.ZodString;
    action: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    required: z.ZodOptional<z.ZodBoolean>;
    abort_on_failure: z.ZodOptional<z.ZodBoolean>;
    uses_tool: z.ZodOptional<z.ZodString>;
    produces_artifact: z.ZodOptional<z.ZodString>;
    reads_artifact: z.ZodOptional<z.ZodString>;
    validates_artifact: z.ZodOptional<z.ZodString>;
    validation_kind: z.ZodOptional<z.ZodEnum<{
        schema: "schema";
        mechanical: "mechanical";
        semantic: "semantic";
        approval: "approval";
        provenance: "provenance";
        traceability: "traceability";
        fidelity: "fidelity";
    }>>;
    depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
    skip_condition: z.ZodOptional<z.ZodString>;
    wait_for_approval: z.ZodOptional<z.ZodBoolean>;
}, z.core.$loose>;
type ExecutionStep = z.infer<typeof ExecutionStepSchema>;
declare const TaskSchema: z.ZodObject<{
    description: z.ZodString;
    target_agent: z.ZodString;
    allowed_from_agents: z.ZodDefault<z.ZodArray<z.ZodString>>;
    workflow: z.ZodString;
    input_artifacts: z.ZodArray<z.ZodString>;
    invocation_handoff: z.ZodString;
    result_handoff: z.ZodString;
    default_priority: z.ZodOptional<z.ZodString>;
    responsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
    execution_steps: z.ZodOptional<z.ZodArray<z.Z