import type { SignedDecisionLogEntry, SpendDecision } from '../types';
export type ReceiptTopology = 'linear' | 'fan_in' | 'fan_out' | 'diamond';
export type ReceiptCapabilityLevel = 'READ_ONLY' | 'TRANSACT' | 'ADMIN' | 'ORCHESTRATE';
export interface ReceiptDagNode {
    version: number;
    sequence: number;
    decision: Record<string, unknown>;
    workflowId: string | null;
    parents: string[];
    topology: ReceiptTopology;
    msgHash: string;
    trustScore: number;
    blocked: boolean;
    capability: ReceiptCapabilityLevel;
    entryHash: string;
    signature: string;
    signerFingerprint: string;
    builderCode?: string | null;
    timestamp: string;
    previousHash?: string;
}
export interface ReceiptDagEnvelope {
    nodes: ReceiptDagInput[];
    rootId: string;
    workflowId: string | null;
}
export type ReceiptDagInput = ReceiptDagNode | SignedDecisionLogEntry;
export interface ReceiptDagVerificationResult {
    valid: boolean;
    compositeTrust: number;
    depth: number;
    topologySummary: Record<ReceiptTopology, number>;
    reason?: string;
}
export interface CapabilityGateThresholds {
    READ_ONLY?: {
        minTrust?: number;
        minDepth?: number;
    };
    TRANSACT?: {
        minTrust?: number;
        minDepth?: number;
    };
    ADMIN?: {
        minTrust?: number;
        minDepth?: number;
    };
    ORCHESTRATE?: {
        minTrust?: number;
        minDepth?: number;
    };
}
export interface CapabilityGateResult {
    granted: boolean;
    requestedLevel: ReceiptCapabilityLevel;
    compositeTrust: number;
    depth: number;
    reason?: string;
}
export interface MerkleProofStep {
    siblingHash: string;
    position: 'left' | 'right';
}
export interface MerkleCompressionResult {
    compressed: boolean;
    root: string;
    nodeCount: number;
}
export declare function signDagNode(args: {
    sequence: number;
    decision: Record<string, unknown> | SpendDecision;
    privateKey: Uint8Array;
    publicKey: Uint8Array;
    parents?: Array<ReceiptDagNode | SignedDecisionLogEntry | string>;
    workflowId?: string | null;
    topology?: ReceiptTopology;
    trustScore?: number;
    blocked?: boolean;
    capability?: ReceiptCapabilityLevel;
    builderCode?: string | null;
    timestamp?: string;
    version?: number;
}): Promise<ReceiptDagNode>;
export declare function computeDagEntryHash(node: Omit<ReceiptDagNode, 'entryHash' | 'signature'> | Record<string, unknown>): string;
export declare function msgHashForDecision(decision: Record<string, unknown>): string;
export declare function deriveTrustScore(decision: Record<string, unknown>): number;
export declare function deriveCapability(decision: Record<string, unknown>): ReceiptCapabilityLevel;
export declare function verifyReceiptDag(nodes: ReceiptDagInput[] | ReceiptDagEnvelope, signerKeys: Record<string, string | Uint8Array> | string | Uint8Array): Promise<ReceiptDagVerificationResult>;
export declare function gateCapability(requestedLevel: ReceiptCapabilityLevel, dagVerificationResult: ReceiptDagVerificationResult, thresholds?: CapabilityGateThresholds): CapabilityGateResult;
export declare function merkleRoot(nodes: ReceiptDagInput[]): string;
export declare function compressReceiptDag(nodes: ReceiptDagInput[], threshold?: number): MerkleCompressionResult;
export declare function merkleInclusionProof(nodes: ReceiptDagInput[], node: ReceiptDagInput | string): MerkleProofStep[];
export declare function verifyInclusion(node: ReceiptDagInput | string, proof: MerkleProofStep[], root: string): boolean;
export declare function dagEnvelopeFromEntries(entries: SignedDecisionLogEntry[], workflowId?: string | null): ReceiptDagEnvelope;
//# sourceMappingURL=dag.d.ts.map