/**
 * Compliance Reporting Type Definitions
 *
 * Defines compliance frameworks, controls, assessments, and reporting types
 * for SOC 2 Type II, NIST 800-53, and other regulatory frameworks.
 *
 * @packageDocumentation
 */
import { z } from 'zod';
export declare const CONTROL_PRIORITIES: readonly ["P1", "P2", "P3"];
export type ControlPriority = (typeof CONTROL_PRIORITIES)[number];
export declare const controlPrioritySchema: z.ZodEnum<["P1", "P2", "P3"]>;
export declare const IMPLEMENTATION_STATUSES: readonly ["implemented", "partially-implemented", "planned", "not-applicable"];
export type ImplementationStatus = (typeof IMPLEMENTATION_STATUSES)[number];
export declare const implementationStatusSchema: z.ZodEnum<["implemented", "partially-implemented", "planned", "not-applicable"]>;
export declare const FINDING_SEVERITIES: readonly ["critical", "high", "medium", "low", "informational"];
export type FindingSeverity = (typeof FINDING_SEVERITIES)[number];
export declare const findingSeveritySchema: z.ZodEnum<["critical", "high", "medium", "low", "informational"]>;
export declare const EVIDENCE_TYPES: readonly ["log", "config", "screenshot", "document", "api-response", "test-result", "policy", "attestation"];
export type EvidenceType = (typeof EVIDENCE_TYPES)[number];
export declare const evidenceTypeSchema: z.ZodEnum<["log", "config", "screenshot", "document", "api-response", "test-result", "policy", "attestation"]>;
/**
 * Evidence supporting a compliance control
 */
export interface Evidence {
    /** Unique identifier for the evidence */
    id: string;
    /** Type of evidence */
    type: EvidenceType;
    /** Human-readable title */
    title: string;
    /** Description of what this evidence demonstrates */
    description: string;
    /** Source of the evidence (system, file path, API, etc.) */
    source: string;
    /** When the evidence was collected */
    collectedAt: Date;
    /** Hash of the evidence content for integrity */
    contentHash?: string;
    /** Reference URL or path */
    reference?: string;
    /** Raw content or summary */
    content?: string;
    /** Additional metadata */
    metadata?: Record<string, unknown>;
}
export declare const evidenceSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<["log", "config", "screenshot", "document", "api-response", "test-result", "policy", "attestation"]>;
    title: z.ZodString;
    description: z.ZodString;
    source: z.ZodString;
    collectedAt: z.ZodDate;
    contentHash: z.ZodOptional<z.ZodString>;
    reference: z.ZodOptional<z.ZodString>;
    content: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    id?: string;
    type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
    content?: string;
    title?: string;
    description?: string;
    source?: string;
    metadata?: Record<string, unknown>;
    reference?: string;
    collectedAt?: Date;
    contentHash?: string;
}, {
    id?: string;
    type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
    content?: string;
    title?: string;
    description?: string;
    source?: string;
    metadata?: Record<string, unknown>;
    reference?: string;
    collectedAt?: Date;
    contentHash?: string;
}>;
/**
 * A single compliance control requirement
 */
export interface ComplianceControl {
    /** Control identifier (e.g., 'CC6.1' for SOC 2, 'AC-2' for NIST) */
    id: string;
    /** Human-readable name */
    name: string;
    /** Detailed description of the control requirement */
    description: string;
    /** Control family/category */
    family: string;
    /** Implementation priority */
    priority: ControlPriority;
    /** Current implementation status */
    implementation: ImplementationStatus;
    /** Collected evidence for this control */
    evidence: Evidence[];
    /** Automated test function for continuous monitoring */
    automatedTest?: () => Promise<boolean>;
    /** Related controls from other frameworks */
    crossReferences?: string[];
    /** Control owner/responsible party */
    owner?: string;
    /** Last assessment date */
    lastAssessed?: Date;
    /** Notes from assessors */
    notes?: string;
}
export declare const complianceControlSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodString;
    family: z.ZodString;
    priority: z.ZodEnum<["P1", "P2", "P3"]>;
    implementation: z.ZodEnum<["implemented", "partially-implemented", "planned", "not-applicable"]>;
    evidence: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["log", "config", "screenshot", "document", "api-response", "test-result", "policy", "attestation"]>;
        title: z.ZodString;
        description: z.ZodString;
        source: z.ZodString;
        collectedAt: z.ZodDate;
        contentHash: z.ZodOptional<z.ZodString>;
        reference: z.ZodOptional<z.ZodString>;
        content: z.ZodOptional<z.ZodString>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        id?: string;
        type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
        content?: string;
        title?: string;
        description?: string;
        source?: string;
        metadata?: Record<string, unknown>;
        reference?: string;
        collectedAt?: Date;
        contentHash?: string;
    }, {
        id?: string;
        type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
        content?: string;
        title?: string;
        description?: string;
        source?: string;
        metadata?: Record<string, unknown>;
        reference?: string;
        collectedAt?: Date;
        contentHash?: string;
    }>, "many">;
    crossReferences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    owner: z.ZodOptional<z.ZodString>;
    lastAssessed: z.ZodOptional<z.ZodDate>;
    notes: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id?: string;
    name?: string;
    family?: string;
    description?: string;
    priority?: "P1" | "P2" | "P3";
    owner?: string;
    implementation?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
    notes?: string;
    evidence?: {
        id?: string;
        type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
        content?: string;
        title?: string;
        description?: string;
        source?: string;
        metadata?: Record<string, unknown>;
        reference?: string;
        collectedAt?: Date;
        contentHash?: string;
    }[];
    crossReferences?: string[];
    lastAssessed?: Date;
}, {
    id?: string;
    name?: string;
    family?: string;
    description?: string;
    priority?: "P1" | "P2" | "P3";
    owner?: string;
    implementation?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
    notes?: string;
    evidence?: {
        id?: string;
        type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
        content?: string;
        title?: string;
        description?: string;
        source?: string;
        metadata?: Record<string, unknown>;
        reference?: string;
        collectedAt?: Date;
        contentHash?: string;
    }[];
    crossReferences?: string[];
    lastAssessed?: Date;
}>;
/**
 * A compliance framework definition
 */
export interface ComplianceFramework {
    /** Unique framework identifier */
    id: string;
    /** Framework name (e.g., 'SOC 2 Type II') */
    name: string;
    /** Framework version */
    version: string;
    /** Framework description */
    description?: string;
    /** Controls defined in this framework */
    controls: ComplianceControl[];
    /** Framework effective date */
    effectiveDate?: Date;
    /** Regulatory body or standard organization */
    authority?: string;
}
export declare const complianceFrameworkSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    version: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    controls: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        description: z.ZodString;
        family: z.ZodString;
        priority: z.ZodEnum<["P1", "P2", "P3"]>;
        implementation: z.ZodEnum<["implemented", "partially-implemented", "planned", "not-applicable"]>;
        evidence: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            type: z.ZodEnum<["log", "config", "screenshot", "document", "api-response", "test-result", "policy", "attestation"]>;
            title: z.ZodString;
            description: z.ZodString;
            source: z.ZodString;
            collectedAt: z.ZodDate;
            contentHash: z.ZodOptional<z.ZodString>;
            reference: z.ZodOptional<z.ZodString>;
            content: z.ZodOptional<z.ZodString>;
            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }, {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }>, "many">;
        crossReferences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        owner: z.ZodOptional<z.ZodString>;
        lastAssessed: z.ZodOptional<z.ZodDate>;
        notes: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id?: string;
        name?: string;
        family?: string;
        description?: string;
        priority?: "P1" | "P2" | "P3";
        owner?: string;
        implementation?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
        notes?: string;
        evidence?: {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }[];
        crossReferences?: string[];
        lastAssessed?: Date;
    }, {
        id?: string;
        name?: string;
        family?: string;
        description?: string;
        priority?: "P1" | "P2" | "P3";
        owner?: string;
        implementation?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
        notes?: string;
        evidence?: {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }[];
        crossReferences?: string[];
        lastAssessed?: Date;
    }>, "many">;
    effectiveDate: z.ZodOptional<z.ZodDate>;
    authority: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id?: string;
    name?: string;
    version?: string;
    description?: string;
    controls?: {
        id?: string;
        name?: string;
        family?: string;
        description?: string;
        priority?: "P1" | "P2" | "P3";
        owner?: string;
        implementation?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
        notes?: string;
        evidence?: {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }[];
        crossReferences?: string[];
        lastAssessed?: Date;
    }[];
    effectiveDate?: Date;
    authority?: string;
}, {
    id?: string;
    name?: string;
    version?: string;
    description?: string;
    controls?: {
        id?: string;
        name?: string;
        family?: string;
        description?: string;
        priority?: "P1" | "P2" | "P3";
        owner?: string;
        implementation?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
        notes?: string;
        evidence?: {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }[];
        crossReferences?: string[];
        lastAssessed?: Date;
    }[];
    effectiveDate?: Date;
    authority?: string;
}>;
/**
 * Assessment result for a single control
 */
export interface ControlAssessment {
    /** Control ID being assessed */
    controlId: string;
    /** Control name */
    controlName: string;
    /** Assessment status */
    status: ImplementationStatus;
    /** Whether automated test passed (if applicable) */
    automatedTestPassed?: boolean;
    /** Assessment timestamp */
    assessedAt: Date;
    /** Evidence collected during assessment */
    evidence: Evidence[];
    /** Assessment notes */
    notes?: string;
    /** Gaps identified */
    gaps?: string[];
    /** Risk score (0-100) */
    riskScore?: number;
}
export declare const controlAssessmentSchema: z.ZodObject<{
    controlId: z.ZodString;
    controlName: z.ZodString;
    status: z.ZodEnum<["implemented", "partially-implemented", "planned", "not-applicable"]>;
    automatedTestPassed: z.ZodOptional<z.ZodBoolean>;
    assessedAt: z.ZodDate;
    evidence: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        type: z.ZodEnum<["log", "config", "screenshot", "document", "api-response", "test-result", "policy", "attestation"]>;
        title: z.ZodString;
        description: z.ZodString;
        source: z.ZodString;
        collectedAt: z.ZodDate;
        contentHash: z.ZodOptional<z.ZodString>;
        reference: z.ZodOptional<z.ZodString>;
        content: z.ZodOptional<z.ZodString>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        id?: string;
        type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
        content?: string;
        title?: string;
        description?: string;
        source?: string;
        metadata?: Record<string, unknown>;
        reference?: string;
        collectedAt?: Date;
        contentHash?: string;
    }, {
        id?: string;
        type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
        content?: string;
        title?: string;
        description?: string;
        source?: string;
        metadata?: Record<string, unknown>;
        reference?: string;
        collectedAt?: Date;
        contentHash?: string;
    }>, "many">;
    notes: z.ZodOptional<z.ZodString>;
    gaps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    riskScore: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    status?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
    notes?: string;
    riskScore?: number;
    assessedAt?: Date;
    evidence?: {
        id?: string;
        type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
        content?: string;
        title?: string;
        description?: string;
        source?: string;
        metadata?: Record<string, unknown>;
        reference?: string;
        collectedAt?: Date;
        contentHash?: string;
    }[];
    controlId?: string;
    controlName?: string;
    automatedTestPassed?: boolean;
    gaps?: string[];
}, {
    status?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
    notes?: string;
    riskScore?: number;
    assessedAt?: Date;
    evidence?: {
        id?: string;
        type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
        content?: string;
        title?: string;
        description?: string;
        source?: string;
        metadata?: Record<string, unknown>;
        reference?: string;
        collectedAt?: Date;
        contentHash?: string;
    }[];
    controlId?: string;
    controlName?: string;
    automatedTestPassed?: boolean;
    gaps?: string[];
}>;
/**
 * A compliance finding or deficiency
 */
export interface Finding {
    /** Unique finding identifier */
    id: string;
    /** Finding title */
    title: string;
    /** Detailed description */
    description: string;
    /** Severity level */
    severity: FindingSeverity;
    /** Related control IDs */
    relatedControls: string[];
    /** When the finding was identified */
    identifiedAt: Date;
    /** Current status */
    status: 'open' | 'in-progress' | 'remediated' | 'accepted';
    /** Remediation plan */
    remediationPlan?: string;
    /** Target remediation date */
    targetRemediationDate?: Date;
    /** Actual remediation date */
    remediatedAt?: Date;
    /** Risk if not remediated */
    riskDescription?: string;
    /** Assigned owner */
    owner?: string;
}
export declare const findingSchema: z.ZodObject<{
    id: z.ZodString;
    title: z.ZodString;
    description: z.ZodString;
    severity: z.ZodEnum<["critical", "high", "medium", "low", "informational"]>;
    relatedControls: z.ZodArray<z.ZodString, "many">;
    identifiedAt: z.ZodDate;
    status: z.ZodEnum<["open", "in-progress", "remediated", "accepted"]>;
    remediationPlan: z.ZodOptional<z.ZodString>;
    targetRemediationDate: z.ZodOptional<z.ZodDate>;
    remediatedAt: z.ZodOptional<z.ZodDate>;
    riskDescription: z.ZodOptional<z.ZodString>;
    owner: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id?: string;
    status?: "open" | "in-progress" | "remediated" | "accepted";
    title?: string;
    description?: string;
    severity?: "low" | "medium" | "high" | "critical" | "informational";
    owner?: string;
    relatedControls?: string[];
    identifiedAt?: Date;
    remediationPlan?: string;
    targetRemediationDate?: Date;
    remediatedAt?: Date;
    riskDescription?: string;
}, {
    id?: string;
    status?: "open" | "in-progress" | "remediated" | "accepted";
    title?: string;
    description?: string;
    severity?: "low" | "medium" | "high" | "critical" | "informational";
    owner?: string;
    relatedControls?: string[];
    identifiedAt?: Date;
    remediationPlan?: string;
    targetRemediationDate?: Date;
    remediatedAt?: Date;
    riskDescription?: string;
}>;
/**
 * Report summary statistics
 */
export interface ReportSummary {
    /** Total number of controls assessed */
    totalControls: number;
    /** Number of fully implemented controls */
    implemented: number;
    /** Number of partially implemented controls */
    partiallyImplemented: number;
    /** Number of planned controls */
    planned: number;
    /** Number of not applicable controls */
    notApplicable: number;
    /** Number of automated tests passed */
    automatedTestsPassed: number;
    /** Number of automated tests failed */
    automatedTestsFailed: number;
    /** Overall compliance percentage */
    compliancePercentage: number;
}
export declare const reportSummarySchema: z.ZodObject<{
    totalControls: z.ZodNumber;
    implemented: z.ZodNumber;
    partiallyImplemented: z.ZodNumber;
    planned: z.ZodNumber;
    notApplicable: z.ZodNumber;
    automatedTestsPassed: z.ZodNumber;
    automatedTestsFailed: z.ZodNumber;
    compliancePercentage: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    implemented?: number;
    planned?: number;
    totalControls?: number;
    partiallyImplemented?: number;
    notApplicable?: number;
    automatedTestsPassed?: number;
    automatedTestsFailed?: number;
    compliancePercentage?: number;
}, {
    implemented?: number;
    planned?: number;
    totalControls?: number;
    partiallyImplemented?: number;
    notApplicable?: number;
    automatedTestsPassed?: number;
    automatedTestsFailed?: number;
    compliancePercentage?: number;
}>;
/**
 * Complete compliance report
 */
export interface ComplianceReport {
    /** Report ID */
    id: string;
    /** Framework being reported on */
    framework: string;
    /** Framework version */
    frameworkVersion: string;
    /** When the report was generated */
    generatedAt: Date;
    /** Assessment period */
    period: {
        start: Date;
        end: Date;
    };
    /** Summary statistics */
    summary: ReportSummary;
    /** Individual control assessments */
    controls: ControlAssessment[];
    /** Findings identified */
    findings: Finding[];
    /** Recommendations for improvement */
    recommendations: string[];
    /** Report preparer */
    preparedBy?: string;
    /** Report reviewer */
    reviewedBy?: string;
    /** Additional metadata */
    metadata?: Record<string, unknown>;
}
export declare const complianceReportSchema: z.ZodObject<{
    id: z.ZodString;
    framework: z.ZodString;
    frameworkVersion: z.ZodString;
    generatedAt: z.ZodDate;
    period: z.ZodObject<{
        start: z.ZodDate;
        end: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        end?: Date;
        start?: Date;
    }, {
        end?: Date;
        start?: Date;
    }>;
    summary: z.ZodObject<{
        totalControls: z.ZodNumber;
        implemented: z.ZodNumber;
        partiallyImplemented: z.ZodNumber;
        planned: z.ZodNumber;
        notApplicable: z.ZodNumber;
        automatedTestsPassed: z.ZodNumber;
        automatedTestsFailed: z.ZodNumber;
        compliancePercentage: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        implemented?: number;
        planned?: number;
        totalControls?: number;
        partiallyImplemented?: number;
        notApplicable?: number;
        automatedTestsPassed?: number;
        automatedTestsFailed?: number;
        compliancePercentage?: number;
    }, {
        implemented?: number;
        planned?: number;
        totalControls?: number;
        partiallyImplemented?: number;
        notApplicable?: number;
        automatedTestsPassed?: number;
        automatedTestsFailed?: number;
        compliancePercentage?: number;
    }>;
    controls: z.ZodArray<z.ZodObject<{
        controlId: z.ZodString;
        controlName: z.ZodString;
        status: z.ZodEnum<["implemented", "partially-implemented", "planned", "not-applicable"]>;
        automatedTestPassed: z.ZodOptional<z.ZodBoolean>;
        assessedAt: z.ZodDate;
        evidence: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            type: z.ZodEnum<["log", "config", "screenshot", "document", "api-response", "test-result", "policy", "attestation"]>;
            title: z.ZodString;
            description: z.ZodString;
            source: z.ZodString;
            collectedAt: z.ZodDate;
            contentHash: z.ZodOptional<z.ZodString>;
            reference: z.ZodOptional<z.ZodString>;
            content: z.ZodOptional<z.ZodString>;
            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }, {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }>, "many">;
        notes: z.ZodOptional<z.ZodString>;
        gaps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        riskScore: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        status?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
        notes?: string;
        riskScore?: number;
        assessedAt?: Date;
        evidence?: {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }[];
        controlId?: string;
        controlName?: string;
        automatedTestPassed?: boolean;
        gaps?: string[];
    }, {
        status?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
        notes?: string;
        riskScore?: number;
        assessedAt?: Date;
        evidence?: {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }[];
        controlId?: string;
        controlName?: string;
        automatedTestPassed?: boolean;
        gaps?: string[];
    }>, "many">;
    findings: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        title: z.ZodString;
        description: z.ZodString;
        severity: z.ZodEnum<["critical", "high", "medium", "low", "informational"]>;
        relatedControls: z.ZodArray<z.ZodString, "many">;
        identifiedAt: z.ZodDate;
        status: z.ZodEnum<["open", "in-progress", "remediated", "accepted"]>;
        remediationPlan: z.ZodOptional<z.ZodString>;
        targetRemediationDate: z.ZodOptional<z.ZodDate>;
        remediatedAt: z.ZodOptional<z.ZodDate>;
        riskDescription: z.ZodOptional<z.ZodString>;
        owner: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id?: string;
        status?: "open" | "in-progress" | "remediated" | "accepted";
        title?: string;
        description?: string;
        severity?: "low" | "medium" | "high" | "critical" | "informational";
        owner?: string;
        relatedControls?: string[];
        identifiedAt?: Date;
        remediationPlan?: string;
        targetRemediationDate?: Date;
        remediatedAt?: Date;
        riskDescription?: string;
    }, {
        id?: string;
        status?: "open" | "in-progress" | "remediated" | "accepted";
        title?: string;
        description?: string;
        severity?: "low" | "medium" | "high" | "critical" | "informational";
        owner?: string;
        relatedControls?: string[];
        identifiedAt?: Date;
        remediationPlan?: string;
        targetRemediationDate?: Date;
        remediatedAt?: Date;
        riskDescription?: string;
    }>, "many">;
    recommendations: z.ZodArray<z.ZodString, "many">;
    preparedBy: z.ZodOptional<z.ZodString>;
    reviewedBy: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    id?: string;
    summary?: {
        implemented?: number;
        planned?: number;
        totalControls?: number;
        partiallyImplemented?: number;
        notApplicable?: number;
        automatedTestsPassed?: number;
        automatedTestsFailed?: number;
        compliancePercentage?: number;
    };
    period?: {
        end?: Date;
        start?: Date;
    };
    metadata?: Record<string, unknown>;
    reviewedBy?: string;
    findings?: {
        id?: string;
        status?: "open" | "in-progress" | "remediated" | "accepted";
        title?: string;
        description?: string;
        severity?: "low" | "medium" | "high" | "critical" | "informational";
        owner?: string;
        relatedControls?: string[];
        identifiedAt?: Date;
        remediationPlan?: string;
        targetRemediationDate?: Date;
        remediatedAt?: Date;
        riskDescription?: string;
    }[];
    generatedAt?: Date;
    recommendations?: string[];
    framework?: string;
    controls?: {
        status?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
        notes?: string;
        riskScore?: number;
        assessedAt?: Date;
        evidence?: {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }[];
        controlId?: string;
        controlName?: string;
        automatedTestPassed?: boolean;
        gaps?: string[];
    }[];
    preparedBy?: string;
    frameworkVersion?: string;
}, {
    id?: string;
    summary?: {
        implemented?: number;
        planned?: number;
        totalControls?: number;
        partiallyImplemented?: number;
        notApplicable?: number;
        automatedTestsPassed?: number;
        automatedTestsFailed?: number;
        compliancePercentage?: number;
    };
    period?: {
        end?: Date;
        start?: Date;
    };
    metadata?: Record<string, unknown>;
    reviewedBy?: string;
    findings?: {
        id?: string;
        status?: "open" | "in-progress" | "remediated" | "accepted";
        title?: string;
        description?: string;
        severity?: "low" | "medium" | "high" | "critical" | "informational";
        owner?: string;
        relatedControls?: string[];
        identifiedAt?: Date;
        remediationPlan?: string;
        targetRemediationDate?: Date;
        remediatedAt?: Date;
        riskDescription?: string;
    }[];
    generatedAt?: Date;
    recommendations?: string[];
    framework?: string;
    controls?: {
        status?: "implemented" | "partially-implemented" | "planned" | "not-applicable";
        notes?: string;
        riskScore?: number;
        assessedAt?: Date;
        evidence?: {
            id?: string;
            type?: "attestation" | "config" | "log" | "policy" | "screenshot" | "document" | "api-response" | "test-result";
            content?: string;
            title?: string;
            description?: string;
            source?: string;
            metadata?: Record<string, unknown>;
            reference?: string;
            collectedAt?: Date;
            contentHash?: string;
        }[];
        controlId?: string;
        controlName?: string;
        automatedTestPassed?: boolean;
        gaps?: string[];
    }[];
    preparedBy?: string;
    frameworkVersion?: string;
}>;
/**
 * Monitoring status for a control
 */
export interface MonitoringStatus {
    /** Control ID */
    controlId: string;
    /** Whether monitoring is enabled */
    enabled: boolean;
    /** Last check timestamp */
    lastCheck?: Date;
    /** Last check result */
    lastResult?: boolean;
    /** Check frequency in seconds */
    checkFrequency: number;
    /** Consecutive failures */
    consecutiveFailures: number;
    /** Alert threshold for failures */
    alertThreshold: number;
    /** Whether alert has been triggered */
    alertTriggered: boolean;
}
export declare const monitoringStatusSchema: z.ZodObject<{
    controlId: z.ZodString;
    enabled: z.ZodBoolean;
    lastCheck: z.ZodOptional<z.ZodDate>;
    lastResult: z.ZodOptional<z.ZodBoolean>;
    checkFrequency: z.ZodNumber;
    consecutiveFailures: z.ZodNumber;
    alertThreshold: z.ZodNumber;
    alertTriggered: z.ZodBoolean;
}, "strip", z.ZodTypeAny, {
    enabled?: boolean;
    alertThreshold?: number;
    lastCheck?: Date;
    controlId?: string;
    lastResult?: boolean;
    checkFrequency?: number;
    consecutiveFailures?: number;
    alertTriggered?: boolean;
}, {
    enabled?: boolean;
    alertThreshold?: number;
    lastCheck?: Date;
    controlId?: string;
    lastResult?: boolean;
    checkFrequency?: number;
    consecutiveFailures?: number;
    alertTriggered?: boolean;
}>;
/**
 * Mapping between controls in different frameworks
 */
export interface ControlMapping {
    /** Source framework ID */
    sourceFramework: string;
    /** Source control ID */
    sourceControlId: string;
    /** Target framework ID */
    targetFramework: string;
    /** Target control IDs */
    targetControlIds: string[];
    /** Mapping strength (exact, partial, related) */
    mappingType: 'exact' | 'partial' | 'related';
    /** Notes about the mapping */
    notes?: string;
}
export declare const controlMappingSchema: z.ZodObject<{
    sourceFramework: z.ZodString;
    sourceControlId: z.ZodString;
    targetFramework: z.ZodString;
    targetControlIds: z.ZodArray<z.ZodString, "many">;
    mappingType: z.ZodEnum<["exact", "partial", "related"]>;
    notes: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    notes?: string;
    sourceFramework?: string;
    sourceControlId?: string;
    targetFramework?: string;
    targetControlIds?: string[];
    mappingType?: "exact" | "partial" | "related";
}, {
    notes?: string;
    sourceFramework?: string;
    sourceControlId?: string;
    targetFramework?: string;
    targetControlIds?: string[];
    mappingType?: "exact" | "partial" | "related";
}>;
/**
 * Options for running an assessment
 */
export interface AssessmentOptions {
    /** Framework to assess */
    frameworkId: string;
    /** Assessment period start */
    periodStart?: Date;
    /** Assessment period end */
    periodEnd?: Date;
    /** Run automated tests */
    runAutomatedTests?: boolean;
    /** Collect fresh evidence */
    collectEvidence?: boolean;
    /** Control IDs to assess (if empty, assess all) */
    controlIds?: string[];
    /** Include findings from previous assessments */
    includePreviousFindings?: boolean;
}
export declare const assessmentOptionsSchema: z.ZodObject<{
    frameworkId: z.ZodString;
    periodStart: z.ZodOptional<z.ZodDate>;
    periodEnd: z.ZodOptional<z.ZodDate>;
    runAutomatedTests: z.ZodOptional<z.ZodBoolean>;
    collectEvidence: z.ZodOptional<z.ZodBoolean>;
    controlIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    includePreviousFindings: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    periodStart?: Date;
    periodEnd?: Date;
    frameworkId?: string;
    runAutomatedTests?: boolean;
    collectEvidence?: boolean;
    controlIds?: string[];
    includePreviousFindings?: boolean;
}, {
    periodStart?: Date;
    periodEnd?: Date;
    frameworkId?: string;
    runAutomatedTests?: boolean;
    collectEvidence?: boolean;
    controlIds?: string[];
    includePreviousFindings?: boolean;
}>;
/**
 * Configuration for the compliance engine
 */
export interface ComplianceEngineConfig {
    /** Enabled frameworks */
    enabledFrameworks: string[];
    /** Monitoring configuration */
    monitoring: {
        enabled: boolean;
        defaultCheckFrequency: number;
        defaultAlertThreshold: number;
    };
    /** Evidence collection configuration */
    evidence: {
        retentionDays: number;
        autoCollect: boolean;
        hashAlgorithm: 'sha256' | 'sha384' | 'sha512';
    };
    /** Reporting configuration */
    reporting: {
        defaultFormat: 'json' | 'pdf' | 'html';
        includeRawEvidence: boolean;
    };
}
export declare const complianceEngineConfigSchema: z.ZodObject<{
    enabledFrameworks: z.ZodArray<z.ZodString, "many">;
    monitoring: z.ZodObject<{
        enabled: z.ZodBoolean;
        defaultCheckFrequency: z.ZodNumber;
        defaultAlertThreshold: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        enabled?: boolean;
        defaultCheckFrequency?: number;
        defaultAlertThreshold?: number;
    }, {
        enabled?: boolean;
        defaultCheckFrequency?: number;
        defaultAlertThreshold?: number;
    }>;
    evidence: z.ZodObject<{
        retentionDays: z.ZodNumber;
        autoCollect: z.ZodBoolean;
        hashAlgorithm: z.ZodEnum<["sha256", "sha384", "sha512"]>;
    }, "strip", z.ZodTypeAny, {
        retentionDays?: number;
        hashAlgorithm?: "sha256" | "sha384" | "sha512";
        autoCollect?: boolean;
    }, {
        retentionDays?: number;
        hashAlgorithm?: "sha256" | "sha384" | "sha512";
        autoCollect?: boolean;
    }>;
    reporting: z.ZodObject<{
        defaultFormat: z.ZodEnum<["json", "pdf", "html"]>;
        includeRawEvidence: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        defaultFormat?: "json" | "html" | "pdf";
        includeRawEvidence?: boolean;
    }, {
        defaultFormat?: "json" | "html" | "pdf";
        includeRawEvidence?: boolean;
    }>;
}, "strip", z.ZodTypeAny, {
    evidence?: {
        retentionDays?: number;
        hashAlgorithm?: "sha256" | "sha384" | "sha512";
        autoCollect?: boolean;
    };
    monitoring?: {
        enabled?: boolean;
        defaultCheckFrequency?: number;
        defaultAlertThreshold?: number;
    };
    reporting?: {
        defaultFormat?: "json" | "html" | "pdf";
        includeRawEvidence?: boolean;
    };
    enabledFrameworks?: string[];
}, {
    evidence?: {
        retentionDays?: number;
        hashAlgorithm?: "sha256" | "sha384" | "sha512";
        autoCollect?: boolean;
    };
    monitoring?: {
        enabled?: boolean;
        defaultCheckFrequency?: number;
        defaultAlertThreshold?: number;
    };
    reporting?: {
        defaultFormat?: "json" | "html" | "pdf";
        includeRawEvidence?: boolean;
    };
    enabledFrameworks?: string[];
}>;
export declare const DEFAULT_COMPLIANCE_ENGINE_CONFIG: ComplianceEngineConfig;
//# sourceMappingURL=types.d.ts.map