/**
 * Type Definitions for agentics-cli
 *
 * SPARC Architecture Reference:
 * - All types defined here are used across modules
 * - Types are interface-based for loose coupling
 * - No business logic in type definitions
 */
export interface BaseReference {
    id: string;
    type: ReferenceType;
    repository: string;
    created_at: string;
    checksum: string;
}
export type ReferenceType = 'ManifestReference' | 'PlanReference' | 'SimulationReference' | 'SimulationOutputReference' | 'RoiReportReference' | 'IntentReference' | 'ExportReference' | 'DiligencePackageReference';
export interface PlanReference extends BaseReference {
    type: 'PlanReference';
    repository: 'agentics-simulation-planner';
    manifest_ref?: ManifestReference;
}
export interface ManifestReference extends BaseReference {
    type: 'ManifestReference';
    repository: 'agentics-org-manifests';
}
export interface SimulationReference extends BaseReference {
    type: 'SimulationReference';
    repository: 'agentics-simulation-runner';
    plan_ref: PlanReference;
    iteration_count?: number;
}
export interface SimulationOutputReference extends BaseReference {
    type: 'SimulationOutputReference';
    repository: 'agentics-simulation-engine';
    sim_ref: SimulationReference;
    output_type: SimulationOutputType;
    artifact_location: string;
}
export type SimulationOutputType = 'metrics' | 'logs' | 'state' | 'events' | 'summary' | 'full';
export interface RoiReportReference extends BaseReference {
    type: 'RoiReportReference';
    repository: 'enterprise-roi-engine';
    sim_ref: SimulationReference;
    report_type: RoiReportType;
    artifact_location: string;
}
export type RoiReportType = 'executive-summary' | 'cfo-grade' | 'technical-deep-dive' | 'compliance-audit';
export interface IntentReference extends BaseReference {
    type: 'IntentReference';
    repository: 'agentics-deployment-intent';
    sim_ref: SimulationReference;
    status: IntentStatus;
}
export type IntentStatus = 'pending' | 'approved' | 'rejected';
export interface ExportReference extends BaseReference {
    type: 'ExportReference';
    repository: 'agentics-deployment-exporters';
    intent_ref: IntentReference;
    format: ExportFormat;
    artifact_location: string;
}
export type ExportFormat = 'terraform' | 'pulumi' | 'cloudformation' | 'kubernetes' | 'helm' | 'json' | 'yaml';
export interface DiligencePackageReference extends BaseReference {
    type: 'DiligencePackageReference';
    repository: 'diligence-artifacts';
    source_refs: BaseReference[];
    frameworks: ComplianceFramework[];
    package_location: string;
}
export type ComplianceFramework = 'SOC2' | 'HIPAA' | 'GDPR' | 'PCI-DSS' | 'ISO27001' | 'FedRAMP' | 'NIST';
export interface CommandObject {
    command: string;
    subcommand?: string;
    flags: Record<string, boolean>;
    options: Record<string, string>;
    positionalArgs: string[];
}
/**
 * Input that can be either structured JSON or natural language description.
 * Natural language inputs are forwarded unchanged to downstream services.
 */
export type FlexibleInput<T> = T | NaturalLanguageInput;
export interface NaturalLanguageInput {
    type: 'natural-language';
    description: string;
}
/**
 * Check if input is natural language (not valid JSON)
 */
export declare function isNaturalLanguageInput(value: string): boolean;
/**
 * Parse input that can be either JSON or natural language.
 * Returns parsed JSON if valid, otherwise returns NaturalLanguageInput wrapper.
 */
export declare function parseFlexibleInput<T>(value: string): FlexibleInput<T>;
/**
 * Check if a FlexibleInput is a NaturalLanguageInput
 */
export declare function isNaturalLanguage<T>(input: FlexibleInput<T>): input is NaturalLanguageInput;
/**
 * ADR-PIPELINE-096 D1 — fleet dispatch depth.
 *   - `lite`: capability-graph routes a focused 5-15 agent subset (default for CI / quick).
 *   - `standard`: capability-graph + sector-cross-cutting supplements (~25 agents).
 *   - `consultancy`: full 109-agent fleet across all 27 domains + ruvector simulation.
 *     This is the McKinsey/Accenture-grade depth and is the default for
 *     interactive `agentics ask` (CLI sets it explicitly).
 */
export type FleetDepth = 'lite' | 'standard' | 'consultancy';
export interface CommandOptions {
    timeout?: number;
    trace_id?: string;
    format?: OutputFormat;
    verbose?: boolean;
    /** ADR-096 D1 — fleet dispatch depth. Defaults to `lite` when omitted to
     *  preserve backwards compatibility with non-`ask` callers. The `ask`
     *  command CLI parser sets this to `consultancy` unless the user passes
     *  `--depth=lite|standard` explicitly. */
    depth?: FleetDepth;
}
export interface OrchestrationResult {
    stages: StageResult[];
    artifacts: ArtifactReference[];
    timing: TimingInfo;
    success: boolean;
}
export interface StageResult {
    name: string;
    status: StageStatus;
    response: unknown;
    error?: ErrorInfo;
    timing: number;
}
export type StageStatus = 'pending' | 'running' | 'complete' | 'failed';
export interface ArtifactReference {
    id: string;
    type: string;
    location: string;
    checksum?: string;
    metadata?: Record<string, string>;
}
export interface TimingInfo {
    total: number;
    breakdown: Record<string, number>;
    started_at: string;
    completed_at: string;
}
export interface AdapterRequest {
    endpoint: string;
    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
    headers: Record<string, string>;
    body?: unknown;
    timeout?: number;
}
export interface AdapterResponse {
    status: number;
    headers: Record<string, string>;
    body: unknown;
    timing: number;
}
export interface HealthStatus {
    healthy: boolean;
    latency: number;
    version?: string;
}
export interface EndpointConfig {
    baseUrl: string;
    version: string;
    timeout: number;
}
export interface ErrorInfo {
    code: string;
    category: ErrorCategory;
    message: string;
    details?: Record<string, unknown>;
    stack?: string;
    timestamp: string;
    module: string;
    correlationId?: string;
}
export type ErrorCategory = 'INPUT_ERROR' | 'NETWORK_ERROR' | 'DOWNSTREAM_ERROR' | 'INTERNAL_ERROR' | 'CONFIG_ERROR' | 'AUTH_ERROR';
export interface ContractViolation {
    service: string;
    expected_contract: string;
    actual_response: unknown;
    violation_type: ViolationType;
}
export type ViolationType = 'schema_mismatch' | 'missing_field' | 'type_error' | 'missing_contract';
export interface AuditEntry {
    id: string;
    version: string;
    command: string;
    inputs_hash: string;
    inputs_redacted: unknown;
    outputs: BaseReference | null;
    dependencies: string[];
    timestamp: string;
    duration_ms: number;
    status: 'SUCCESS' | 'FAILED';
    error_code?: string;
    error_message?: string;
    trace_id: string;
    parent_id?: string;
    checksum: string;
}
export interface DownstreamCall {
    service: string;
    method: string;
    timestamp: string;
    duration_ms: number;
    success: boolean;
}
/**
 * Tracking file written to ~/.agentics/agents/<id>.json
 * while a Task agent is running. File existence = agent alive.
 */
export interface ActiveAgent {
    type: string;
    prompt_snippet: string;
    started_at: string;
}
/**
 * Tracking file written to ~/.agentics/calls/<id>.json
 * while an HTTP call is in-flight. File existence = call active.
 */
export interface ActiveDownstreamCall {
    service: string;
    endpoint: string;
    method: string;
    started_at: string;
    correlation_id?: string;
}
export type OutputFormat = 'json' | 'yaml' | 'table' | 'text' | 'csv';
export interface OutputOptions {
    format: OutputFormat;
    pretty?: boolean;
    colorize?: boolean;
    destination?: 'stdout' | 'stderr' | string;
    includeStack?: boolean;
}
export interface CLIConfig {
    endpoints: EndpointRegistry;
    timeout: number;
    trace_id?: string;
    auth_token?: string;
    log_level: LogLevel;
}
export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
export interface EndpointRegistry {
    'agentics-org-manifests': EndpointConfig;
    'agentics-simulation-planner': EndpointConfig;
    'agentics-simulation-runner': EndpointConfig;
    'agentics-simulation-engine': EndpointConfig;
    'agentics-results-index': EndpointConfig;
    'enterprise-roi-engine': EndpointConfig;
    'agentics-deployment-intent': EndpointConfig;
    'agentics-deployment-exporters': EndpointConfig;
    'diligence-artifacts': EndpointConfig;
    'agentics-usage-ledger': EndpointConfig;
    'ruvector-service': EndpointConfig;
    'test-bench-agents': EndpointConfig;
    'observatory-agents': EndpointConfig;
    'shield-agents': EndpointConfig;
    'sentinel-agents': EndpointConfig;
    'memory-graph-agents': EndpointConfig;
    'latency-lens-agents': EndpointConfig;
    'forge-agents': EndpointConfig;
    'edge-agents': EndpointConfig;
    'auto-optimizer-agents': EndpointConfig;
    'incident-manager-agents': EndpointConfig;
    'orchestrator-agents': EndpointConfig;
    'costops-agents': EndpointConfig;
    'governance-dashboard-agents': EndpointConfig;
    'policy-engine-agents': EndpointConfig;
    'registry-agents': EndpointConfig;
    'marketplace-agents': EndpointConfig;
    'analytics-hub-agents': EndpointConfig;
    'config-manager-agents': EndpointConfig;
    'schema-registry-agents': EndpointConfig;
    'connector-hub-agents': EndpointConfig;
    'copilot-agents': EndpointConfig;
    'simulator-agents': EndpointConfig;
    'benchmark-exchange-agents': EndpointConfig;
    'inference-gateway-agents': EndpointConfig;
    'data-vault-agents': EndpointConfig;
    'research-lab-agents': EndpointConfig;
    'platform-agents': EndpointConfig;
}
export declare const EXIT_CODES: {
    readonly SUCCESS: 0;
    readonly GENERAL_ERROR: 1;
    readonly MISUSE: 2;
    readonly USAGE_ERROR: 64;
    readonly DATA_FORMAT_ERROR: 65;
    readonly CANNOT_OPEN_INPUT: 66;
    readonly SERVICE_UNAVAILABLE: 69;
    readonly INTERNAL_ERROR: 70;
    readonly IO_ERROR: 74;
    readonly TEMPORARY_FAILURE: 75;
    readonly PERMISSION_DENIED: 77;
    readonly CONFIG_ERROR: 78;
    readonly ARG_VALIDATION_ERROR: 100;
    readonly CONFIG_VALIDATION_ERROR: 110;
    readonly NETWORK_ERROR: 120;
    readonly AUTH_ERROR: 130;
    readonly SERVICE_ERROR: 140;
    readonly RUVECTOR_ACCEPTANCE_FAILED: 141;
    readonly META_SIMULATION_ROUTING_FAILED: 142;
    readonly INTERNAL_CLI_ERROR: 150;
};
export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];
export interface AuthSession {
    session_id: string;
    verification_url: string;
    user_code: string;
    expires_at: string;
    interval: number;
}
export interface AuthCredentials {
    api_key: string;
    created_at: string;
    expires_at?: string;
    email?: string;
    user_id?: string;
    payment_status?: 'paid' | 'free' | 'unknown';
    anthropic_api_key?: string;
}
export interface AuthTokenResponse {
    api_key: string;
    expires_at?: string;
    user_id?: string;
}
export type AuthSessionStatus = 'pending' | 'authorized' | 'expired' | 'denied';
export type OrgRole = 'owner' | 'admin' | 'member';
export interface UserIdentity {
    user_id: string;
    display_name: string;
    created_at: string;
}
export interface OrgIdentity {
    org_id: string;
    org_name: string;
    created_at: string;
}
export interface IdentityContext {
    user: UserIdentity;
    org: OrgIdentity;
    role: OrgRole;
    resolved_at: string;
}
export interface Attribution {
    created_by: string;
    org_id: string;
}
/**
 * Artifact categories persisted into Ruvector (ADR-004, Domain 1).
 * Every artifact is an inert proposal produced by a simulation.
 */
export type ArtifactCategory = 'simulation' | 'plan' | 'risk_assessment' | 'cost_projection' | 'integration_mapping' | 'erp_proposal' | 'decision' | 'deployment';
/**
 * Lineage record linking an artifact to its parent simulation (ADR-004, Domain 2).
 * Stored in Ruvector as first-class data, not inferred from timestamps.
 *
 * Invariant 3: No integration proposal exists without traceability to
 * a simulation, a plan, and a decision context.
 */
export interface LineageRecord {
    /** Unique lineage record ID */
    id: string;
    /** The artifact this lineage entry describes */
    artifact_id: string;
    /** The category of the artifact */
    artifact_category: ArtifactCategory;
    /** The simulation that produced this artifact (Invariant 2) */
    simulation_id: string;
    /** The plan this artifact belongs to (if applicable) */
    plan_id?: string;
    /** The natural language input that seeded synthesis */
    decision_context: string;
    /** Identity attribution (user_id, org_id) */
    attribution: Attribution;
    /** Governance metadata: which gate pipeline version was applied */
    governance: {
        gate_pipeline_version: string;
        synthesis_classification: string;
    };
    /** Immutable creation timestamp */
    created_at: string;
}
/**
 * Simulation memory footprint persisted in Ruvector (ADR-004, Invariant 1).
 * A simulation that exists only in memory is not a simulation —
 * it is an untracked computation.
 */
export interface SimulationMemoryRecord {
    /** Simulation identifier */
    id: string;
    type: 'simulation';
    /** Natural language input that seeded synthesis */
    intent: string;
    /** Ruvector-contract field: same as intent, required by ruvector-service */
    intent_description: string;
    /** Simulation status lifecycle */
    status: 'created' | 'running' | 'completed' | 'failed';
    /** Simulation result data (when completed) */
    result?: unknown;
    /** Identity attribution */
    attribution: Attribution;
    /** IDs of artifacts this simulation has produced */
    artifact_ids: string[];
    /** Immutable creation timestamp */
    created_at: string;
    /** Last updated timestamp */
    updated_at: string;
    /** Data integrity checksum */
    checksum: string;
}
/**
 * Integration proposal derived from a simulation (ADR-004, Domain 3).
 * Proposals describe what would change in an enterprise system.
 * They are never created outside of the simulation lifecycle.
 */
export interface IntegrationProposal {
    /** Proposal identifier */
    id: string;
    type: 'integration_proposal';
    /** The integration system affected (e.g. 'sap', 'salesforce') */
    integration_name: string;
    /** What changes would be required */
    proposed_changes: string;
    /** Risks introduced by this change */
    risks: string[];
    /** Dependencies on other proposals or artifacts */
    dependencies: string[];
    /** Simulation that produced this proposal (Invariant 2) */
    simulation_id: string;
    /** Plan this proposal belongs to */
    plan_id?: string;
    /** Identity attribution */
    attribution: Attribution;
    /** Immutable creation timestamp */
    created_at: string;
}
/**
 * ERP Surface mapping derived from a simulation (ADR-004, Domain 4).
 * Describes how enterprise-wide processes would be affected.
 * ERP Surface never initiates simulations — it receives proposals.
 */
export interface ErpSurfaceMapping {
    /** Mapping identifier */
    id: string;
    type: 'erp_mapping';
    /** ERP system type */
    erp_type: string;
    /** Entity type affected */
    entity_type: string;
    /** Proposed changes to the enterprise model */
    proposed_implementation: unknown;
    /** Simulation that produced this mapping (Invariant 2) */
    simulation_id: string;
    /** Integration proposals this mapping depends on */
    integration_proposal_ids: string[];
    /** Identity attribution */
    attribution: Attribution;
    /** Immutable creation timestamp */
    created_at: string;
}
/** A span in the execution graph, rooted at ruvector-service */
export interface ExecutionSpan {
    span_id: string;
    parent_span_id: string | null;
    service: string;
    operation: string;
    status: 'started' | 'completed' | 'failed';
    started_at: string;
    completed_at?: string;
    duration_ms?: number;
    children: ExecutionSpan[];
    metadata?: Record<string, unknown>;
}
/** Complete ruvector-rooted execution graph for CLI output */
export interface RuvectorRootedGraph {
    graph_id: string;
    root: ExecutionSpan;
    total_spans: number;
    created_at: string;
}
/** Result of ruvector acceptance (blocking) */
export interface RuvectorAcceptanceResult {
    accepted: boolean;
    ruvector_span_id: string;
    graph: RuvectorRootedGraph;
    timing_ms: number;
}
/** Downstream span descriptor for graph construction */
export interface DownstreamSpanDescriptor {
    service: string;
    operation: string;
    status: 'completed' | 'failed';
    started_at: string;
    completed_at: string;
    duration_ms: number;
    children?: DownstreamSpanDescriptor[];
}
//# sourceMappingURL=index.d.ts.map