import { verifyReceiptDag, type ReceiptCapabilityLevel, type ReceiptDagEnvelope, type ReceiptDagNode } from './receipts/dag';
export type OperatingPackVertical = 'law';
export type OperatingPackActionKind = 'intake' | 'conflict_check' | 'document_summary' | 'billing_reconciliation' | 'client_update_draft' | 'send_client_email' | 'trust_account_action';
export interface OperatingPackSigningKeys {
    privateKey: Uint8Array;
    publicKey: Uint8Array;
}
export interface OperatingPackReviewerCascadeOptions {
    enabled?: boolean;
    drafterModel?: string;
    reviewerModel?: string;
    triggerThreshold?: number;
    drafterMaxCostCents?: number;
    reviewerMaxCostCents?: number;
}
export interface OperatingPackOptions {
    vertical: OperatingPackVertical;
    workflowId: string;
    signingKeys: OperatingPackSigningKeys;
    approvedCapabilities?: ReceiptCapabilityLevel[];
    reviewerCascade?: OperatingPackReviewerCascadeOptions;
    maxWorkflowCostCents?: number;
}
export interface OperatingPackAction {
    actionId: string;
    kind: OperatingPackActionKind;
    capability?: ReceiptCapabilityLevel;
    highRisk?: boolean;
    highRiskClassifierScore?: number;
    keywordRisk?: boolean;
    modelIds?: string[];
    tokenCounts?: {
        inputTokens?: number;
        outputTokens?: number;
    };
    totalCostCents?: number;
    metadata?: Record<string, unknown>;
    reviewerVerdict?: 'drafter_only' | 'review_required' | 'approved' | 'rejected';
}
export interface OperatingPackGuardResult {
    allowed: boolean;
    reason: string;
    node: ReceiptDagNode;
    dag: ReceiptDagEnvelope;
    reviewerCascadeTriggered: boolean;
    spentCents: number;
}
export interface OperatingPackSkillTemplate {
    slug: string;
    title: string;
    capability: ReceiptCapabilityLevel;
    reviewerCascade: boolean;
    markdown: string;
}
export interface OperatingPackDefinition {
    vertical: OperatingPackVertical;
    title: string;
    counselReviewPending: boolean;
    agentsMd: string;
    skills: Record<string, OperatingPackSkillTemplate>;
    sourceOfTruth: string;
    checklist: string[];
    capabilityTable: Array<{
        capability: ReceiptCapabilityLevel;
        use: string;
        blockedExamples: string[];
    }>;
}
export declare const LAW_OPERATING_PACK: OperatingPackDefinition;
export declare function createOperatingPackEnvelope(opts: OperatingPackOptions): OperatingPackEnvelope;
export declare class OperatingPackEnvelope {
    private readonly opts;
    private readonly nodes;
    private readonly approvedCapabilities;
    private spentCents;
    constructor(opts: OperatingPackOptions);
    getPack(): OperatingPackDefinition;
    guardAction(input: OperatingPackAction): Promise<OperatingPackGuardResult>;
    getReceiptDag(): ReceiptDagEnvelope;
    verifyDag(publicKeyHex?: string): Promise<Awaited<ReturnType<typeof verifyReceiptDag>>>;
    outboundPayloads(): Record<string, unknown>[];
    signerFingerprint(): string;
    private hasCapability;
    private signActionNode;
}
export declare function assertOperatingPackMetadataOnly(value: unknown, path?: string): void;
export declare function operatingPackSignerFingerprint(opts: OperatingPackOptions): string | null;
//# sourceMappingURL=operating-pack.d.ts.map