import * as _aiready_core from '@aiready/core';
import { Issue, IssueType } from '@aiready/core';

declare const CONTRACT_ENFORCEMENT_PROVIDER: _aiready_core.ToolProvider;

type DefensivePattern = 'as-any' | 'as-unknown' | 'deep-optional-chain' | 'nullish-literal-default' | 'swallowed-error' | 'env-fallback' | 'unnecessary-guard' | 'any-parameter' | 'any-return' | 'sparse-type' | 'optional-parameter';
interface ContractEnforcementIssue extends Issue {
    type: IssueType.ContractGap;
    pattern: DefensivePattern;
    context: string;
}
interface PatternCounts {
    'as-any': number;
    'as-unknown': number;
    'deep-optional-chain': number;
    'nullish-literal-default': number;
    'swallowed-error': number;
    'env-fallback': number;
    'unnecessary-guard': number;
    'any-parameter': number;
    'any-return': number;
    'sparse-type': number;
    'optional-parameter': number;
}
declare const ZERO_COUNTS: PatternCounts;
interface ContractEnforcementOptions {
    rootDir: string;
    include?: string[];
    exclude?: string[];
    onProgress?: (processed: number, total: number, message: string) => void;
    minChainDepth?: number;
}
interface DetectionResult {
    issues: ContractEnforcementIssue[];
    counts: PatternCounts;
    totalLines: number;
}
interface ScoreResult {
    score: number;
    rating: string;
    dimensions: Record<string, number>;
    recommendations: string[];
}
interface ContractEnforcementReport {
    summary: {
        sourceFiles: number;
        totalDefensivePatterns: number;
        defensiveDensity: number;
        score: number;
        rating: string;
        dimensions: {
            typeEscapeHatchScore: number;
            fallbackCascadeScore: number;
            errorTransparencyScore: number;
            boundaryValidationScore: number;
        };
    };
    issues: ContractEnforcementIssue[];
    rawData: PatternCounts & {
        sourceFiles: number;
        totalLines: number;
    };
    recommendations: string[];
}

declare function analyzeContractEnforcement(options: ContractEnforcementOptions): Promise<ContractEnforcementReport>;

declare function calculateContractEnforcementScore(counts: PatternCounts, totalLines: number, _fileCount: number): ScoreResult;

export { CONTRACT_ENFORCEMENT_PROVIDER, type ContractEnforcementIssue, type ContractEnforcementOptions, type ContractEnforcementReport, type DefensivePattern, type DetectionResult, type PatternCounts, type ScoreResult, ZERO_COUNTS, analyzeContractEnforcement, calculateContractEnforcementScore };