import { z } from 'zod';

declare const RuleSeveritySchema: z.ZodEnum<["info", "warn", "error"]>;
type RuleSeverity = z.infer<typeof RuleSeveritySchema>;
declare const RuleScopeSchema: z.ZodEnum<["changed", "all"]>;
type RuleScope = z.infer<typeof RuleScopeSchema>;
declare const LevelSchema: z.ZodEnum<["basic", "standard", "strict"]>;
type Level = z.infer<typeof LevelSchema>;
declare const PresetSchema: z.ZodEnum<["node-api", "nextjs-app", "python-api", "cli-tool", "library", "monorepo"]>;
type Preset = z.infer<typeof PresetSchema>;
declare const RuleConfigSchema: z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
    severity: z.ZodOptional<z.ZodEnum<["info", "warn", "error"]>>;
    autofix: z.ZodOptional<z.ZodBoolean>;
    blocking: z.ZodOptional<z.ZodBoolean>;
    scope: z.ZodOptional<z.ZodEnum<["changed", "all"]>>;
    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    options?: Record<string, unknown> | undefined;
    severity?: "info" | "warn" | "error" | undefined;
    autofix?: boolean | undefined;
    blocking?: boolean | undefined;
    scope?: "changed" | "all" | undefined;
}, {
    options?: Record<string, unknown> | undefined;
    enabled?: boolean | undefined;
    severity?: "info" | "warn" | "error" | undefined;
    autofix?: boolean | undefined;
    blocking?: boolean | undefined;
    scope?: "changed" | "all" | undefined;
}>;
type RuleConfig = z.infer<typeof RuleConfigSchema>;
declare const VibeGuardConfigSchema: z.ZodObject<{
    preset: z.ZodOptional<z.ZodEnum<["node-api", "nextjs-app", "python-api", "cli-tool", "library", "monorepo"]>>;
    level: z.ZodDefault<z.ZodEnum<["basic", "standard", "strict"]>>;
    rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        severity: z.ZodOptional<z.ZodEnum<["info", "warn", "error"]>>;
        autofix: z.ZodOptional<z.ZodBoolean>;
        blocking: z.ZodOptional<z.ZodBoolean>;
        scope: z.ZodOptional<z.ZodEnum<["changed", "all"]>>;
        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        options?: Record<string, unknown> | undefined;
        severity?: "info" | "warn" | "error" | undefined;
        autofix?: boolean | undefined;
        blocking?: boolean | undefined;
        scope?: "changed" | "all" | undefined;
    }, {
        options?: Record<string, unknown> | undefined;
        enabled?: boolean | undefined;
        severity?: "info" | "warn" | "error" | undefined;
        autofix?: boolean | undefined;
        blocking?: boolean | undefined;
        scope?: "changed" | "all" | undefined;
    }>]>>>;
    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    ci: z.ZodOptional<z.ZodObject<{
        failOn: z.ZodDefault<z.ZodEnum<["info", "warn", "error"]>>;
        reportFormat: z.ZodDefault<z.ZodEnum<["console", "json", "sarif"]>>;
    }, "strip", z.ZodTypeAny, {
        failOn: "info" | "warn" | "error";
        reportFormat: "console" | "json" | "sarif";
    }, {
        failOn?: "info" | "warn" | "error" | undefined;
        reportFormat?: "console" | "json" | "sarif" | undefined;
    }>>;
    tools: z.ZodOptional<z.ZodObject<{
        eslint: z.ZodDefault<z.ZodBoolean>;
        semgrep: z.ZodDefault<z.ZodBoolean>;
        gitleaks: z.ZodDefault<z.ZodBoolean>;
        osvScanner: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        eslint: boolean;
        semgrep: boolean;
        gitleaks: boolean;
        osvScanner: boolean;
    }, {
        eslint?: boolean | undefined;
        semgrep?: boolean | undefined;
        gitleaks?: boolean | undefined;
        osvScanner?: boolean | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    level: "basic" | "standard" | "strict";
    preset?: "node-api" | "nextjs-app" | "python-api" | "cli-tool" | "library" | "monorepo" | undefined;
    rules?: Record<string, boolean | {
        enabled: boolean;
        options?: Record<string, unknown> | undefined;
        severity?: "info" | "warn" | "error" | undefined;
        autofix?: boolean | undefined;
        blocking?: boolean | undefined;
        scope?: "changed" | "all" | undefined;
    }> | undefined;
    include?: string[] | undefined;
    exclude?: string[] | undefined;
    ci?: {
        failOn: "info" | "warn" | "error";
        reportFormat: "console" | "json" | "sarif";
    } | undefined;
    tools?: {
        eslint: boolean;
        semgrep: boolean;
        gitleaks: boolean;
        osvScanner: boolean;
    } | undefined;
}, {
    preset?: "node-api" | "nextjs-app" | "python-api" | "cli-tool" | "library" | "monorepo" | undefined;
    level?: "basic" | "standard" | "strict" | undefined;
    rules?: Record<string, boolean | {
        options?: Record<string, unknown> | undefined;
        enabled?: boolean | undefined;
        severity?: "info" | "warn" | "error" | undefined;
        autofix?: boolean | undefined;
        blocking?: boolean | undefined;
        scope?: "changed" | "all" | undefined;
    }> | undefined;
    include?: string[] | undefined;
    exclude?: string[] | undefined;
    ci?: {
        failOn?: "info" | "warn" | "error" | undefined;
        reportFormat?: "console" | "json" | "sarif" | undefined;
    } | undefined;
    tools?: {
        eslint?: boolean | undefined;
        semgrep?: boolean | undefined;
        gitleaks?: boolean | undefined;
        osvScanner?: boolean | undefined;
    } | undefined;
}>;
type VibeGuardConfig = z.infer<typeof VibeGuardConfigSchema>;
interface RuleDefinition {
    id: string;
    name: string;
    description: string;
    category: RuleCategory;
    severity: RuleSeverity;
    autofix: boolean;
    blocking: boolean;
    scope: RuleScope;
    tool: ToolType;
    docs: string;
    rationale: string;
    fix: string;
    examples?: {
        bad?: string;
        good?: string;
    };
    levels: {
        basic: boolean;
        standard: boolean;
        strict: boolean;
    };
}
type RuleCategory = 'secrets' | 'deps' | 'security' | 'auth' | 'api' | 'sql' | 'tests' | 'logging' | 'code' | 'config';
type ToolType = 'eslint' | 'semgrep' | 'gitleaks' | 'osv-scanner' | 'vitest' | 'jest' | 'custom' | 'builtin';
interface CheckResult {
    ruleId: string;
    severity: RuleSeverity;
    message: string;
    file?: string;
    line?: number;
    column?: number;
    endLine?: number;
    endColumn?: number;
    fix?: {
        description: string;
        replacement?: string;
    };
}
interface CheckReport {
    timestamp: string;
    duration: number;
    preset?: Preset;
    level: Level;
    summary: {
        total: number;
        errors: number;
        warnings: number;
        infos: number;
        fixed: number;
    };
    score: number;
    results: CheckResult[];
    tools: {
        name: string;
        version?: string;
        duration: number;
        results: number;
    }[];
}

declare const rules: RuleDefinition[];
declare const ruleMap: Map<string, RuleDefinition>;
declare function getRuleById(id: string): RuleDefinition | undefined;
declare function getRulesByCategory(category: string): RuleDefinition[];
declare function getRulesByLevel(level: 'basic' | 'standard' | 'strict'): RuleDefinition[];
declare function getRulesByTool(tool: string): RuleDefinition[];

interface PresetConfig {
    name: Preset;
    description: string;
    rules: Record<Level, string[]>;
    tools: string[];
    eslintExtends: string[];
    semgrepRules: string[];
}

declare const presets: Record<Preset, PresetConfig>;
declare function getPreset(name: Preset): PresetConfig;
declare function listPresets(): Preset[];

interface LoadedConfig {
    config: VibeGuardConfig;
    filepath: string;
    isEmpty: boolean;
}
declare function loadConfig(cwd?: string): Promise<LoadedConfig | null>;
declare function loadConfigFromFile(filepath: string): Promise<LoadedConfig>;
declare function getDefaultConfig(): VibeGuardConfig;

interface ResolvedRule {
    definition: RuleDefinition;
    severity: RuleSeverity;
    enabled: boolean;
    blocking: boolean;
    autofix: boolean;
}
declare function resolveRules(config: VibeGuardConfig): ResolvedRule[];
declare function groupRulesByTool(resolvedRules: ResolvedRule[]): Map<string, ResolvedRule[]>;
declare function calculateScore(results: CheckResult[]): number;
declare function shouldFail(results: CheckResult[], failOn: RuleSeverity): boolean;

interface DetectedStack {
    preset: Preset;
    confidence: number;
    language: 'typescript' | 'javascript' | 'python' | 'unknown';
    framework?: string;
    packageManager?: 'npm' | 'yarn' | 'pnpm' | 'bun';
    hasTests: boolean;
    hasTypeScript: boolean;
    hasCi: boolean;
    issues: string[];
}
declare function detectStack(cwd: string): Promise<DetectedStack>;

interface BaselineEntry {
    ruleId: string;
    file?: string;
    line?: number;
    fingerprint: string;
    message: string;
    createdAt: string;
}
interface Baseline {
    version: string;
    createdAt: string;
    updatedAt: string;
    entries: BaselineEntry[];
}
declare function createFingerprint(result: CheckResult): string;
declare function loadBaseline(cwd: string, path?: string): Promise<Baseline | null>;
declare function saveBaseline(cwd: string, baseline: Baseline, path?: string): Promise<void>;
declare function createBaseline(results: CheckResult[]): Baseline;
declare function filterNewIssues(results: CheckResult[], baseline: Baseline | null): CheckResult[];
declare function getBaselinedIssues(results: CheckResult[], baseline: Baseline | null): CheckResult[];
interface BaselineStats {
    total: number;
    new: number;
    baselined: number;
    fixed: number;
}
declare function getBaselineStats(results: CheckResult[], baseline: Baseline | null): BaselineStats;
declare function updateBaseline(baseline: Baseline, results: CheckResult[]): Baseline;

interface ChangedFile {
    path: string;
    status: 'added' | 'modified' | 'deleted' | 'renamed';
}
declare function getChangedFiles(cwd: string, base?: string): Promise<ChangedFile[]>;
declare function getUncommittedChanges(cwd: string): Promise<ChangedFile[]>;
declare function getStagedFiles(cwd: string): Promise<ChangedFile[]>;
declare function filterResultsByFiles(results: Array<{
    file?: string;
}>, changedFiles: ChangedFile[]): typeof results;

interface ToolRunner {
    name: string;
    isInstalled(): Promise<boolean>;
    getVersion(): Promise<string | null>;
    run(cwd: string, files?: string[]): Promise<CheckResult[]>;
}
declare function checkCommand(command: string): Promise<boolean>;
declare function runCommand(command: string, args: string[], cwd: string): Promise<{
    stdout: string;
    stderr: string;
    exitCode: number;
}>;
declare function parseSeverity(level: string): RuleSeverity;

declare const gitleaksRunner: ToolRunner;

declare const semgrepRunner: ToolRunner;

declare const osvScannerRunner: ToolRunner;

declare function runBuiltinChecks(cwd: string, ruleIds: string[]): Promise<CheckResult[]>;

export { type Baseline, type BaselineEntry, type BaselineStats, type ChangedFile, type CheckReport, type CheckResult, type DetectedStack, type Level, LevelSchema, type LoadedConfig, type Preset, type PresetConfig, PresetSchema, type ResolvedRule, type RuleCategory, type RuleConfig, RuleConfigSchema, type RuleDefinition, type RuleScope, RuleScopeSchema, type RuleSeverity, RuleSeveritySchema, type ToolRunner, type ToolType, type VibeGuardConfig, VibeGuardConfigSchema, calculateScore, checkCommand, createBaseline, createFingerprint, detectStack, filterNewIssues, filterResultsByFiles, getBaselineStats, getBaselinedIssues, getChangedFiles, getDefaultConfig, getPreset, getRuleById, getRulesByCategory, getRulesByLevel, getRulesByTool, getStagedFiles, getUncommittedChanges, gitleaksRunner, groupRulesByTool, listPresets, loadBaseline, loadConfig, loadConfigFromFile, osvScannerRunner, parseSeverity, presets, resolveRules, ruleMap, rules, runBuiltinChecks, runCommand, saveBaseline, semgrepRunner, shouldFail, updateBaseline };