export interface DecisionRecordRef {
    collection: string;
    record_id: string;
}
export interface DecisionPrincipal {
    subject: {
        kind: 'human' | 'service' | 'workload' | 'agent' | 'connection' | 'worker';
        id: string;
    };
    tenant_id: string;
    application_id: string;
    capability?: string;
}
export interface DecisionTransportAuthorization {
    allowed_fields?: string[];
    principal?: DecisionPrincipal;
}
export interface WeightedOption {
    value: string;
    probability: number;
}
export type DecisionDefinition = {
    kind: 'binary';
    predicate: string;
} | {
    kind: 'choice';
    question: string;
    options: string[];
} | {
    kind: 'score';
    question: string;
    levels: string[];
};
export type DecisionResult = {
    kind: 'binary';
    decision: boolean;
    option_mass: number;
    supporting_fields?: string[];
} | {
    kind: 'choice';
    selected: string;
    options: WeightedOption[];
    option_mass: number;
    supporting_fields?: string[];
} | {
    kind: 'score';
    selected: string;
    levels: WeightedOption[];
    option_mass: number;
    supporting_fields?: string[];
};
export interface DecisionRuntimeMetadata {
    runtime: string;
    model?: string;
    model_revision?: string;
    prompt_revision?: string;
    execution_method?: DecisionExecutionMethod;
    decision_schema_revision?: string;
}
export type DecisionExecutionMethod = 'logit' | 'structured' | 'generated' | 'head';
export interface DecisionRuntimeCapabilities {
    binary: boolean;
    choice: boolean;
    score: boolean;
    batch: boolean;
    probability_distribution: boolean;
    execution_methods: DecisionExecutionMethod[];
}
export interface DecisionRuntime {
    metadata(): DecisionRuntimeMetadata;
    capabilities(): DecisionRuntimeCapabilities;
    execute(request: DecisionRequest): Promise<DecisionResult>;
    executeBatch(batch: DecisionBatch): Promise<DecisionBatchEvaluation[]>;
}
export type DecisionRequest = {
    kind: 'binary';
    predicate: string;
    context: Record<string, unknown>;
} | {
    kind: 'choice';
    question: string;
    options: string[];
    context: Record<string, unknown>;
} | {
    kind: 'score';
    question: string;
    levels: string[];
    context: Record<string, unknown>;
};
export type DecisionTransportRuntime = {
    kind: 'deterministic';
    metadata: DecisionRuntimeMetadata;
    responses: Record<string, DecisionResult>;
} | {
    kind: 'recording';
    metadata: DecisionRuntimeMetadata;
    result: DecisionResult;
};
export interface DecisionOptions {
    fields?: string[];
    application_id?: string;
    decision_collection?: string;
    schema_version?: string;
}
export interface DecisionEvidenceField {
    field: string;
    value: unknown;
}
export interface DecisionEvidence {
    decision_id: string;
    kind: 'binary' | 'choice' | 'score';
    input: DecisionDefinition;
    result: DecisionResult;
    supporting_context: DecisionEvidenceField[];
    runtime: DecisionRuntimeMetadata;
    state: {
        collection: string;
        record_id: string;
        record_version?: number;
        reference: string;
        relevant_state_version: string;
        withheld_fields: string[];
    };
}
export interface DecisionEvaluation {
    result: DecisionResult;
    cached: boolean;
    evidence: DecisionEvidence[];
    provenance: {
        runtime: string;
        model?: string;
        model_revision?: string;
        prompt_revision?: string;
        context_hash: string;
        relevant_state_version: string;
        cache_key: string;
        source: string;
        evaluated_at: number;
        served_at: number;
    };
}
export interface DecisionTransportExecutionRequest {
    target?: DecisionRecordRef;
    context?: Record<string, unknown>;
    definition: DecisionDefinition;
    options?: DecisionOptions;
    authorization?: DecisionTransportAuthorization;
    runtime: DecisionTransportRuntime;
}
export interface DecisionTransportExecutionResponse {
    evaluation: DecisionEvaluation;
    runtime_requests: DecisionRequest[];
}
export interface DecisionBatchDecision {
    id: string;
    definition: DecisionDefinition;
    context?: Record<string, unknown>;
}
export interface DecisionBatch {
    context?: Record<string, unknown>;
    decisions: DecisionBatchDecision[];
}
export interface DecisionBatchEvaluation {
    id: string;
    result: DecisionResult;
}
//# sourceMappingURL=semantic-decision.d.ts.map