import * as _sinclair_typebox from '@sinclair/typebox';
import { Static } from '@sinclair/typebox';

declare const AuthConfig: _sinclair_typebox.TObject<{
    provider: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"env">, _sinclair_typebox.TLiteral<"local">, _sinclair_typebox.TLiteral<"oidc">]>;
    env: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        user_var: _sinclair_typebox.TString;
        role_var: _sinclair_typebox.TString;
        org_unit_var: _sinclair_typebox.TString;
    }>>;
    local: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        users_file: _sinclair_typebox.TString;
    }>>;
}>;
type AuthConfigType = Static<typeof AuthConfig>;
declare const DependencyGuardianConfig$1: _sinclair_typebox.TObject<{
    enabled: _sinclair_typebox.TBoolean;
    checks: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        existence: _sinclair_typebox.TBoolean;
        reputation: _sinclair_typebox.TBoolean;
        typosquatting: _sinclair_typebox.TBoolean;
        install_scripts: _sinclair_typebox.TBoolean;
        vulnerabilities: _sinclair_typebox.TBoolean;
    }>>;
    risk_thresholds: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        min_age_days: _sinclair_typebox.TNumber;
        min_weekly_downloads: _sinclair_typebox.TNumber;
    }>>;
    on_risk: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"escalate">, _sinclair_typebox.TLiteral<"block">, _sinclair_typebox.TLiteral<"audit">]>>;
    allowlist: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
    blocklist: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
    blocklist_patterns: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
    custom_registry_bypass: _sinclair_typebox.TBoolean;
}>;
type DependencyGuardianConfigType = Static<typeof DependencyGuardianConfig$1>;
declare const GovernanceConfigSchema: _sinclair_typebox.TObject<{
    auth: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        provider: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"env">, _sinclair_typebox.TLiteral<"local">, _sinclair_typebox.TLiteral<"oidc">]>;
        env: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            user_var: _sinclair_typebox.TString;
            role_var: _sinclair_typebox.TString;
            org_unit_var: _sinclair_typebox.TString;
        }>>;
        local: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            users_file: _sinclair_typebox.TString;
        }>>;
    }>>;
    policy: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        engine: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"yaml">, _sinclair_typebox.TLiteral<"oso">]>;
        yaml: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            rules_file: _sinclair_typebox.TString;
        }>>;
        oso: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            polar_files: _sinclair_typebox.TArray<_sinclair_typebox.TString>;
        }>>;
    }>>;
    templates: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        directory: _sinclair_typebox.TString;
        default: _sinclair_typebox.TString;
    }>>;
    hitl: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        default_mode: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"autonomous">, _sinclair_typebox.TLiteral<"supervised">, _sinclair_typebox.TLiteral<"dry_run">]>;
        approval_channel: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"cli">, _sinclair_typebox.TLiteral<"webhook">]>;
        timeout_seconds: _sinclair_typebox.TNumber;
        webhook: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            url: _sinclair_typebox.TString;
        }>>;
    }>>;
    audit: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        sinks: _sinclair_typebox.TArray<_sinclair_typebox.TUnion<[_sinclair_typebox.TObject<{
            type: _sinclair_typebox.TLiteral<"jsonl">;
            path: _sinclair_typebox.TString;
        }>, _sinclair_typebox.TObject<{
            type: _sinclair_typebox.TLiteral<"webhook">;
            url: _sinclair_typebox.TString;
        }>, _sinclair_typebox.TObject<{
            type: _sinclair_typebox.TLiteral<"postgres">;
            connection: _sinclair_typebox.TString;
        }>]>>;
    }>>;
    dlp: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        enabled: _sinclair_typebox.TBoolean;
        mode: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"audit">, _sinclair_typebox.TLiteral<"mask">, _sinclair_typebox.TLiteral<"block">]>>;
        on_input: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"audit">, _sinclair_typebox.TLiteral<"mask">, _sinclair_typebox.TLiteral<"block">]>>;
        on_output: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"audit">, _sinclair_typebox.TLiteral<"mask">, _sinclair_typebox.TLiteral<"block">]>>;
        masking: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            strategy: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"partial">, _sinclair_typebox.TLiteral<"full">, _sinclair_typebox.TLiteral<"hash">]>;
            show_chars: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
            placeholder: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
        }>>;
        severity_threshold: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"low">, _sinclair_typebox.TLiteral<"medium">, _sinclair_typebox.TLiteral<"high">, _sinclair_typebox.TLiteral<"critical">]>>;
        built_in: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            secrets: _sinclair_typebox.TBoolean;
            pii: _sinclair_typebox.TBoolean;
        }>>;
        custom_patterns: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TObject<{
            name: _sinclair_typebox.TString;
            pattern: _sinclair_typebox.TString;
            severity: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"low">, _sinclair_typebox.TLiteral<"medium">, _sinclair_typebox.TLiteral<"high">, _sinclair_typebox.TLiteral<"critical">]>;
            action: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"audit">, _sinclair_typebox.TLiteral<"mask">, _sinclair_typebox.TLiteral<"block">]>>;
        }>>>;
        allowlist: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TObject<{
            pattern: _sinclair_typebox.TString;
        }>>>;
        role_overrides: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TObject<{
            enabled: _sinclair_typebox.TOptional<_sinclair_typebox.TBoolean>;
            mode: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"audit">, _sinclair_typebox.TLiteral<"mask">, _sinclair_typebox.TLiteral<"block">]>>;
            on_input: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"audit">, _sinclair_typebox.TLiteral<"mask">, _sinclair_typebox.TLiteral<"block">]>>;
            on_output: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"audit">, _sinclair_typebox.TLiteral<"mask">, _sinclair_typebox.TLiteral<"block">]>>;
        }>>>;
    }>>;
    dependency_guardian: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
        enabled: _sinclair_typebox.TBoolean;
        checks: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            existence: _sinclair_typebox.TBoolean;
            reputation: _sinclair_typebox.TBoolean;
            typosquatting: _sinclair_typebox.TBoolean;
            install_scripts: _sinclair_typebox.TBoolean;
            vulnerabilities: _sinclair_typebox.TBoolean;
        }>>;
        risk_thresholds: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            min_age_days: _sinclair_typebox.TNumber;
            min_weekly_downloads: _sinclair_typebox.TNumber;
        }>>;
        on_risk: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"escalate">, _sinclair_typebox.TLiteral<"block">, _sinclair_typebox.TLiteral<"audit">]>>;
        allowlist: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
        blocklist: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
        blocklist_patterns: _sinclair_typebox.TOptional<_sinclair_typebox.TArray<_sinclair_typebox.TString>>;
        custom_registry_bypass: _sinclair_typebox.TBoolean;
    }>>;
    org_units: _sinclair_typebox.TOptional<_sinclair_typebox.TRecord<_sinclair_typebox.TString, _sinclair_typebox.TObject<{
        hitl: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            default_mode: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"autonomous">, _sinclair_typebox.TLiteral<"supervised">, _sinclair_typebox.TLiteral<"dry_run">]>>;
            approval_channel: _sinclair_typebox.TOptional<_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"cli">, _sinclair_typebox.TLiteral<"webhook">]>>;
            timeout_seconds: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
            webhook: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
                url: _sinclair_typebox.TString;
            }>>;
        }>>;
        policy: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
            extra_polar: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
            extra_rules: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
        }>>;
    }>>>;
}>;
type GovernanceConfig = Static<typeof GovernanceConfigSchema>;

declare function loadConfig(): {
    config: GovernanceConfig;
    source: string;
};
declare class ConfigValidationError extends Error {
    constructor(path: string, errors: Array<{
        path: string;
        message: string;
    }>);
}

type PolicyDecision = 'allow' | 'deny' | 'needs_approval';
type PathOperation = 'read' | 'write';
type ExecutionMode = 'autonomous' | 'supervised' | 'dry_run';
interface BashOverrides {
    additionalBlocked?: RegExp[];
    additionalAllowed?: RegExp[];
}
interface PolicyEngine {
    evaluateTool(role: string, tool: string): PolicyDecision;
    evaluatePath(role: string, orgUnit: string, operation: PathOperation, path: string): PolicyDecision;
    requiresApproval(role: string, tool: string): boolean;
    getExecutionMode(role: string): ExecutionMode;
    getTemplateName(role: string): string;
    getBashOverrides(role: string): BashOverrides;
    getTokenBudget(role: string): number;
}

interface YamlRole {
    allowed_tools: string[];
    blocked_tools: string[];
    prompt_template: string;
    execution_mode: ExecutionMode;
    human_approval: {
        required_for: string[];
        auto_approve?: string[];
    };
    token_budget_daily: number;
    allowed_paths: string[];
    blocked_paths: string[];
    bash_overrides?: {
        additional_blocked?: string[];
        additional_allowed?: string[];
    };
}
interface YamlRules {
    roles: Record<string, YamlRole>;
}
declare class YamlPolicyEngine implements PolicyEngine {
    private rules;
    constructor(rulesFilePathOrRules: string | YamlRules);
    private getRole;
    evaluateTool(role: string, tool: string): PolicyDecision;
    evaluatePath(role: string, _orgUnit: string, _operation: PathOperation, path: string): PolicyDecision;
    requiresApproval(role: string, tool: string): boolean;
    getExecutionMode(role: string): ExecutionMode;
    getTemplateName(role: string): string;
    getBashOverrides(role: string): BashOverrides;
    getTokenBudget(role: string): number;
}

interface PolicyConfig {
    engine?: 'yaml' | 'oso';
    yaml?: {
        rules_file?: string;
    };
    oso?: {
        polar_files?: string[];
    };
}
declare function createPolicyEngine(config?: PolicyConfig): Promise<PolicyEngine>;

interface ResolvedIdentity {
    userId: string;
    role: string;
    orgUnit: string;
    source: string;
}
interface IdentityProvider {
    name: string;
    resolve(): Promise<ResolvedIdentity | null>;
}

declare class EnvIdentityProvider implements IdentityProvider {
    private userVar;
    private roleVar;
    private orgUnitVar;
    name: string;
    constructor(userVar?: string, roleVar?: string, orgUnitVar?: string);
    resolve(): Promise<ResolvedIdentity | null>;
}

declare class LocalIdentityProvider implements IdentityProvider {
    name: string;
    private users;
    constructor(usersFilePath: string);
    resolve(): Promise<ResolvedIdentity | null>;
}

declare class IdentityChain {
    private providers;
    constructor(providers: IdentityProvider[]);
    resolve(): Promise<ResolvedIdentity>;
}
declare function createIdentityChain(config?: AuthConfigType): IdentityChain;

interface RoleBinding {
    userId: string;
    role: string;
    orgUnit: string;
    config?: Record<string, unknown>;
}
interface Relation {
    subject: string;
    predicate: string;
    object: string;
}
interface FactStore {
    getRoles(userId: string): Promise<RoleBinding[]>;
    getAllRoleBindings(): Promise<RoleBinding[]>;
    getRelations(subject: string, predicate: string): Promise<Relation[]>;
}

interface YamlUserEntry {
    role: string;
    org_unit?: string;
    config?: Record<string, unknown>;
}
type YamlUsersFile = Record<string, YamlUserEntry>;
declare class YamlFactStore implements FactStore {
    private bindings;
    constructor(usersFilePath: string);
    constructor(data: YamlUsersFile);
    private parseUsers;
    getRoles(userId: string): Promise<RoleBinding[]>;
    getAllRoleBindings(): Promise<RoleBinding[]>;
    getRelations(_subject: string, _predicate: string): Promise<Relation[]>;
}

declare class OsoMemoryFactStore implements FactStore {
    private bindings;
    private relations;
    addRoleBinding(binding: RoleBinding): void;
    addRelation(relation: Relation): void;
    getRoles(userId: string): Promise<RoleBinding[]>;
    getAllRoleBindings(): Promise<RoleBinding[]>;
    getRelations(subject: string, predicate: string): Promise<Relation[]>;
}

type BashClassification = 'safe' | 'dangerous' | 'needs_review';
declare class BashClassifier {
    private safePatterns;
    private dangerousPatterns;
    constructor(overrides?: BashOverrides);
    classify(command: string): BashClassification;
    private classifySingle;
    private splitCommand;
}

declare const SAFE_PATTERNS: RegExp[];
declare const DANGEROUS_PATTERNS: RegExp[];

type DlpSeverity = 'low' | 'medium' | 'high' | 'critical';
type DlpCategory = 'secret' | 'pii' | 'custom';
interface DlpPatternDef {
    name: string;
    pattern: RegExp;
    severity: DlpSeverity;
    category: DlpCategory;
}
declare const SECRET_PATTERNS: DlpPatternDef[];
declare const PII_PATTERNS: DlpPatternDef[];

type DlpAction = 'audit' | 'mask' | 'block';
interface DlpMatch {
    patternName: string;
    category: DlpCategory;
    severity: DlpSeverity;
    start: number;
    end: number;
    matched: string;
}
interface DlpScanResult {
    hasMatches: boolean;
    matches: DlpMatch[];
}
interface DlpCustomPattern {
    name: string;
    pattern: string;
    severity: DlpSeverity;
    action?: DlpAction;
}
interface DlpAllowlistEntry {
    pattern: string;
}
interface DlpScannerConfig {
    enabled: boolean;
    mode: DlpAction;
    on_input?: DlpAction;
    on_output?: DlpAction;
    severity_threshold: DlpSeverity;
    built_in: {
        secrets: boolean;
        pii: boolean;
    };
    custom_patterns: DlpCustomPattern[];
    allowlist: DlpAllowlistEntry[];
    pattern_overrides: Map<string, DlpAction>;
}
declare class DlpScanner {
    private patterns;
    private allowlistRegexps;
    private severityThreshold;
    private config;
    constructor(config: DlpScannerConfig);
    scan(text: string): DlpScanResult;
    getAction(direction: 'input' | 'output'): DlpAction;
    getPatternAction(match: DlpMatch, direction: 'input' | 'output'): DlpAction;
    private isAllowlisted;
}
declare function compareSeverity(a: DlpSeverity, b: DlpSeverity): number;

interface MaskingConfig {
    strategy: 'partial' | 'full' | 'hash';
    show_chars: number;
    placeholder: string;
}
declare class DlpMasker {
    private config;
    constructor(config?: Partial<MaskingConfig>);
    maskValue(value: string): string;
    maskText(text: string, matches: DlpMatch[]): string;
}

/**
 * Extracts package names from shell install commands.
 *
 * Supports npm, yarn, pnpm, pip, and cargo.
 */
type Ecosystem = 'npm' | 'pypi' | 'crates.io';
type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'pip' | 'cargo';
interface ParsedPackage {
    name: string;
    version?: string;
    ecosystem: Ecosystem;
}
interface ParsedInstall {
    manager: PackageManager;
    packages: ParsedPackage[];
    flags: string[];
    raw: string;
    isLockfileInstall: boolean;
    usesCustomRegistry: boolean;
}
/**
 * Attempt to parse an install command and extract package names.
 * Returns undefined if the command is not a recognized install command.
 */
declare function parseInstallCommand(command: string): ParsedInstall | undefined;

/**
 * Registry clients for npm and PyPI.
 *
 * Uses built-in fetch() (Node 22+). Zero dependencies.
 * All endpoints are free and require no authentication.
 */

interface RegistryMetadata {
    name: string;
    ecosystem: Ecosystem;
    exists: boolean;
    createdAt?: Date;
    modifiedAt?: Date;
    latestVersion?: string;
    weeklyDownloads?: number;
    maintainerCount?: number;
    hasRepository: boolean;
    hasReadme: boolean;
    hasInstallScripts: boolean;
    description?: string;
    license?: string;
}
declare function fetchRegistryMetadata(name: string, ecosystem: Ecosystem): Promise<RegistryMetadata>;

/**
 * OSV.dev vulnerability database integration.
 *
 * Free, no auth, supports all major ecosystems.
 * https://osv.dev
 */

interface VulnEntry {
    id: string;
    summary: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    fixedIn?: string;
    aliases: string[];
}
interface VulnerabilityResult {
    package: string;
    ecosystem: Ecosystem;
    vulnerabilities: VulnEntry[];
    error?: string;
}
/**
 * Query OSV.dev for vulnerabilities affecting a single package.
 */
declare function queryVulnerabilities(name: string, ecosystem: Ecosystem, version?: string): Promise<VulnerabilityResult>;
/**
 * Batch query OSV.dev for multiple packages at once.
 */
declare function queryVulnerabilitiesBatch(packages: Array<{
    name: string;
    ecosystem: Ecosystem;
    version?: string;
}>): Promise<VulnerabilityResult[]>;

/**
 * Levenshtein distance and typosquat detection.
 *
 * Single-row Wagner-Fischer: O(n*m) time, O(min(n,m)) space.
 * Zero dependencies.
 */
declare function levenshteinDistance(a: string, b: string): number;
declare function normalizedSimilarity(a: string, b: string): number;
interface TyposquatMatch {
    target: string;
    distance: number;
    similarity: number;
}
/**
 * Check a package name against a corpus of known-good names.
 * Returns the closest match if it looks like a typosquat.
 */
declare function detectTyposquat(name: string, corpus: string[]): TyposquatMatch | undefined;

/**
 * Risk scoring engine for dependency validation.
 *
 * Computes a risk report for a single package based on registry metadata,
 * vulnerability data, and typosquat analysis.
 */

type RiskSeverity = 'info' | 'low' | 'medium' | 'high' | 'critical';
type RiskRecommendation = 'allow' | 'escalate' | 'block';
interface RiskSignal {
    name: string;
    severity: RiskSeverity;
    detail: string;
}
interface RiskReport {
    package: string;
    ecosystem: string;
    overallRisk: RiskSeverity;
    signals: RiskSignal[];
    vulnerabilities: VulnEntry[];
    recommendation: RiskRecommendation;
    metadata: RegistryMetadata;
}

/**
 * Dependency Guardian — orchestrator module.
 *
 * Parses install commands, runs all checks, and returns a risk report.
 */

interface DependencyGuardianConfig {
    enabled: boolean;
    checks: {
        existence: boolean;
        reputation: boolean;
        typosquatting: boolean;
        install_scripts: boolean;
        vulnerabilities: boolean;
    };
    risk_thresholds: {
        min_age_days: number;
        min_weekly_downloads: number;
    };
    on_risk: 'escalate' | 'block' | 'audit';
    allowlist: string[];
    blocklist: string[];
    blocklist_patterns: string[];
    custom_registry_bypass: boolean;
}
interface GuardianResult {
    command: string;
    packages: RiskReport[];
    overallRecommendation: RiskRecommendation;
    summary: string;
    auditMetadata: Record<string, unknown>;
    skipped: boolean;
    skipReason?: string;
}
/**
 * Evaluate an install command and return a risk report for all packages.
 */
declare function evaluateInstall(command: string, config?: DependencyGuardianConfig): Promise<GuardianResult>;

/**
 * Tracks tool invocation count as a proxy for token budget.
 * The budget value represents max invocations per session; -1 means unlimited.
 */
declare class BudgetTracker {
    private _used;
    private readonly _budget;
    constructor(budget: number);
    /** Returns false if consuming would exceed the budget. On success, increments the counter. */
    consume(amount?: number): boolean;
    remaining(): number;
    used(): number;
    isUnlimited(): boolean;
}

/**
 * Watches a governance config file for changes and triggers a validated reload.
 * Uses fs.watch() with a 500ms debounce to avoid rapid reloads.
 */
declare class ConfigWatcher {
    private watcher;
    private debounceTimer;
    private readonly configPath;
    private readonly onChange;
    private readonly onError?;
    constructor(configPath: string, onChange: (config: GovernanceConfig) => void, onError?: (error: Error) => void);
    start(): void;
    stop(): void;
    private handleChange;
    private reload;
}

interface TemplateSelectorConfig {
    directory?: string;
    default?: string;
}
declare class TemplateSelector {
    private userDirectory;
    private bundledDirectory;
    constructor(config?: TemplateSelectorConfig);
    /**
     * Resolve a template name to an absolute file path.
     * User templates take precedence over bundled templates.
     */
    resolve(templateName: string): string;
}

/**
 * Render a template string by substituting {{variable}} placeholders
 * with the corresponding values from the variables map.
 *
 * - String values replace the placeholder directly.
 * - Array values are joined with newlines.
 * - Unresolved variables (no matching key) are left as-is.
 */
declare function render(templateContent: string, variables: Record<string, string | string[]>): string;

interface AuditSink {
    write(record: Record<string, unknown>): Promise<void>;
    flush(): Promise<void>;
}

type AuditEventType = 'session_start' | 'session_end' | 'tool_allowed' | 'tool_denied' | 'tool_dry_run' | 'tool_result' | 'bash_denied' | 'path_denied' | 'approval_requested' | 'approval_granted' | 'approval_denied' | 'budget_exceeded' | 'config_reloaded' | 'dlp_blocked' | 'dlp_detected' | 'dlp_masked' | 'config_tampered' | 'dep_allowed' | 'dep_blocked' | 'dep_escalated' | 'dep_approved' | 'dep_rejected';
interface AuditRecord {
    id: string;
    timestamp: string;
    sessionId: string;
    event: AuditEventType;
    userId: string;
    role: string;
    orgUnit: string;
    tool?: string;
    input?: Record<string, unknown>;
    decision?: string;
    reason?: string;
    duration?: number;
    metadata?: Record<string, unknown>;
}

interface AuditSinkConfig {
    type: 'jsonl' | 'webhook' | 'postgres';
    path?: string;
    url?: string;
    connection?: string;
}
interface AuditConfig {
    sinks: AuditSinkConfig[];
}
declare class AuditLogger {
    private sinks;
    private counts;
    constructor(config?: AuditConfig);
    log(record: Omit<AuditRecord, 'id' | 'timestamp'>): Promise<void>;
    flush(): Promise<void>;
    getSummary(): Map<AuditEventType, number>;
}

declare class JsonlAuditSink implements AuditSink {
    private path;
    private buffer;
    private readonly flushThreshold;
    constructor(path: string);
    write(record: Record<string, unknown>): Promise<void>;
    flush(): Promise<void>;
}

declare class WebhookAuditSink implements AuditSink {
    private url;
    private buffer;
    private readonly flushThreshold;
    constructor(url: string);
    write(record: Record<string, unknown>): Promise<void>;
    flush(): Promise<void>;
    private send;
}

interface GovernanceToolCall {
    toolName: string;
    input: Record<string, unknown>;
}
interface ApprovalResult {
    approved: boolean;
    reason?: string;
    approver: string;
    duration: number;
}
interface ApprovalFlow {
    requestApproval(toolCall: GovernanceToolCall, context: {
        userId: string;
        role: string;
        orgUnit: string;
    }): Promise<ApprovalResult>;
}
interface ConfirmUI {
    confirm(title: string, message: string, opts?: {
        timeout?: number;
    }): Promise<boolean>;
}
interface HitlConfig {
    default_mode: 'autonomous' | 'supervised' | 'dry_run';
    approval_channel: 'cli' | 'webhook';
    timeout_seconds: number;
    webhook?: {
        url: string;
    };
}
declare function createApprovalFlow(config: HitlConfig, ui?: ConfirmUI): ApprovalFlow;

declare class CliApprover implements ApprovalFlow {
    private ui;
    private timeoutSeconds;
    constructor(ui: ConfirmUI, timeoutSeconds?: number);
    requestApproval(toolCall: GovernanceToolCall, context: {
        userId: string;
        role: string;
        orgUnit: string;
    }): Promise<ApprovalResult>;
}

declare class WebhookApprover implements ApprovalFlow {
    private url;
    private timeoutMs;
    constructor(url: string, timeoutSeconds?: number);
    requestApproval(toolCall: GovernanceToolCall, context: {
        userId: string;
        role: string;
        orgUnit: string;
    }): Promise<ApprovalResult>;
}

interface WizardServerOptions {
    workingDirectory: string;
    existingConfig?: GovernanceConfig;
    onComplete: (files: {
        path: string;
        content: string;
    }[]) => void;
    onError: (error: Error) => void;
}
declare function startWizardServer(options: WizardServerOptions): Promise<{
    port: number;
    close: () => void;
}>;

export { type ApprovalFlow, type ApprovalResult, type AuditEventType, AuditLogger, type AuditRecord, type AuditSink, type BashClassification, BashClassifier, type BashOverrides, BudgetTracker, CliApprover, ConfigValidationError, ConfigWatcher, type ConfirmUI, DANGEROUS_PATTERNS, PII_PATTERNS as DLP_PII_PATTERNS, SECRET_PATTERNS as DLP_SECRET_PATTERNS, type DependencyGuardianConfig, type DependencyGuardianConfigType, type DlpAction, type DlpAllowlistEntry, type DlpCategory, type DlpCustomPattern, DlpMasker, type DlpMatch, type DlpPatternDef, type DlpScanResult, DlpScanner, type DlpScannerConfig, type DlpSeverity, EnvIdentityProvider, type ExecutionMode, type FactStore, type GovernanceConfig, type GovernanceToolCall, type GuardianResult, type HitlConfig, IdentityChain, type IdentityProvider, JsonlAuditSink, LocalIdentityProvider, type MaskingConfig, OsoMemoryFactStore, type ParsedInstall, type ParsedPackage, type PathOperation, type PolicyDecision, type PolicyEngine, type RegistryMetadata, type Relation, type ResolvedIdentity, type RoleBinding, SAFE_PATTERNS, TemplateSelector, type TemplateSelectorConfig, type VulnEntry, type VulnerabilityResult, WebhookApprover, WebhookAuditSink, type WizardServerOptions, YamlFactStore, YamlPolicyEngine, type YamlRole, type YamlRules, compareSeverity, createApprovalFlow, createIdentityChain, createPolicyEngine, detectTyposquat, evaluateInstall, fetchRegistryMetadata, levenshteinDistance, loadConfig, normalizedSimilarity, parseInstallCommand, queryVulnerabilities, queryVulnerabilitiesBatch, render as renderTemplate, startWizardServer };