/**
 * Three-Dimensional Trust Score (W3.4 of F-NEW-PRODUCT-AGENT-VISIBILITY-CLUSTER-2026-05-12).
 *
 * Extends the existing two-dimensional rollup math (in packages/trust-api/src/
 * scoring/rollup.ts) to a three-dimensional model that includes the new
 * agent_build_structure dimension from W1.8.
 *
 * Thomas Layer 0 2026-05-12: "we should also have agent build structure as a
 * criteria" on the trust score.
 *
 * Architecturally, the three dimensions are:
 *   agent_activity        — runtime behavioral signals (existing)
 *   operator_activity     — human review / approval / override signals (existing)
 *   agent_build_structure — scan-time OWASP / capability / hook coverage (NEW, W1.8)
 *
 * Each dimension contributes equally to the composite at v1; the rollup
 * carries the dimension values + composite so a downstream consumer can
 * re-weight if they prefer (e.g. a regulator that weights operator activity
 * higher, or a credit-scoring partner that weights build structure higher
 * for under-tested fleets).
 *
 * Pure math — same input -> same output for auditor reproducibility.
 *
 * @connexum/ai-governance  F-NEW-PRODUCT-TRUST-SCORE-DUAL-SIGNAL (extended to 3 dims)
 */
export interface TrustScoreDimensions {
    scope_adherence: number;
    policy_compliance: number;
    anomaly_rate: number;
    incident_history: number;
    behavioral_consistency: number;
    composite: number;
}
export interface OperatorScoreDimensions {
    out_of_scope_ingestion: number;
    scope_violation_by_team: number;
    scope_violation_by_data_class: number;
    human_override_frequency: number;
    composite: number;
}
export interface AgentBuildStructureDimensions {
    owasp_agentic_score: number;
    hook_coverage_count: number;
    declared_capability_class_count: number;
    has_human_in_loop: boolean;
    plugin_integrity_verified: boolean;
    proxy_routed: boolean;
    composite: number;
}
export interface AgentTwoDimensionalScore {
    agent_activity: TrustScoreDimensions;
    operator_activity: OperatorScoreDimensions;
    composite: number;
}
export interface AgentThreeDimensionalScore {
    agent_activity: TrustScoreDimensions;
    operator_activity: OperatorScoreDimensions;
    agent_build_structure: AgentBuildStructureDimensions;
    composite: number;
}
export type TrustScoreRollupScope = {
    kind: 'practice';
    practice_id: string;
} | {
    kind: 'location';
    location_id: string;
} | {
    kind: 'org';
    org_id: string;
};
declare function fractionTrue(values: readonly boolean[]): number;
/**
 * Compose a three-dimensional score from the underlying dimension shapes.
 *
 * Composite weighting (Thomas Layer 0 clarification 2026-05-13):
 *   "The human vertical only comes into play if the agent uses it. If it
 *    doesn't, it's still weighted on the first two: the agent's build and
 *    the agent's runtime."
 *
 *   - When `agent_build_structure.has_human_in_loop === true` the agent
 *     declares it uses human review, so operator_activity counts in the
 *     composite. Composite = mean(agent_activity, operator_activity,
 *     agent_build_structure).
 *   - When `agent_build_structure.has_human_in_loop === false` the agent
 *     does not use humans-in-loop; including a zero (or any) operator
 *     composite would punish the agent for a dimension that is structurally
 *     not applicable. Composite = mean(agent_activity, agent_build_structure).
 *
 * The operator_activity payload is still carried in the returned score for
 * downstream consumers; only its participation in the composite varies.
 */
export declare function composeThreeDimensionalScore(input: {
    agent_activity: AgentTwoDimensionalScore['agent_activity'];
    operator_activity: AgentTwoDimensionalScore['operator_activity'];
    agent_build_structure: AgentBuildStructureDimensions;
}): AgentThreeDimensionalScore;
export interface ThreeDimAggregationInput {
    agent_id: string;
    score: AgentThreeDimensionalScore;
}
export interface ThreeDimRollup {
    scope: TrustScoreRollupScope;
    member_agent_count: number;
    member_agent_ids: readonly string[];
    agent_activity: AgentThreeDimensionalScore['agent_activity'];
    operator_activity: AgentThreeDimensionalScore['operator_activity'];
    agent_build_structure: AgentBuildStructureDimensions;
    composite: number;
    confidence: 'low' | 'medium' | 'high';
    computed_at: string;
}
/**
 * Roll up a set of three-dimensional scores. Aggregation per dimension:
 *   - Numeric fields: count-weighted mean (round to integer).
 *   - Boolean fields (has_human_in_loop / plugin_integrity_verified /
 *     proxy_routed): majority-true (>= 50% of members).
 *   - composite: mean of member composites.
 */
export declare function aggregateThreeDimensionalScores(scope: TrustScoreRollupScope, members: readonly ThreeDimAggregationInput[], computedAt: string): ThreeDimRollup;
export declare const _aggregationFractionTrue: typeof fractionTrue;
export {};
//# sourceMappingURL=trust-score-three-dim.d.ts.map