import type { FedRAMPControl, ControlOrigination } from './controls.js';
import type { SystemComponent, DataFlow, SystemInterconnection, ExternalService, NetworkZone } from './boundary.js';
import type { ImplementationStatus } from '../types.js';
/**
 * SSP section types
 */
export declare const SSP_SECTIONS: readonly ["system-information", "system-environment", "system-description", "data-flow", "ports-protocols-services", "interconnections", "laws-regulations", "control-summary", "control-implementation"];
export type SSPSection = (typeof SSP_SECTIONS)[number];
/**
 * System information for SSP
 */
export interface SystemInformation {
    /** System name */
    systemName: string;
    /** System identifier */
    systemIdentifier: string;
    /** System type */
    systemType: 'major-application' | 'general-support-system';
    /** System categorization */
    securityCategorization: 'low' | 'moderate' | 'high';
    /** Organization name */
    organizationName: string;
    /** System owner */
    systemOwner: {
        name: string;
        title: string;
        organization: string;
        email: string;
        phone: string;
    };
    /** Authorizing official */
    authorizingOfficial: {
        name: string;
        title: string;
        organization: string;
        email: string;
        phone: string;
    };
    /** ISSO */
    isso: {
        name: string;
        title: string;
        organization: string;
        email: string;
        phone: string;
    };
    /** System description */
    systemDescription: string;
    /** System purpose */
    systemPurpose: string;
    /** System function */
    systemFunction: string;
    /** Authorization date */
    authorizationDate?: Date;
    /** Authorization expiration */
    authorizationExpiration?: Date;
    /** FedRAMP authorization type */
    authorizationType: 'agency' | 'jab';
    /** Leveraged authorizations */
    leveragedAuthorizations?: Array<{
        systemName: string;
        serviceProvider: string;
        fedrampPackageId: string;
        authorizationDate: Date;
        servicesUsed: string[];
    }>;
}
/**
 * User type for SSP
 */
export interface SSPUserType {
    /** User type name */
    name: string;
    /** Description */
    description: string;
    /** Privilege level */
    privilegeLevel: 'privileged' | 'non-privileged';
    /** Sensitivity level */
    sensitivityLevel: 'public-trust' | 'moderate-risk' | 'high-risk' | 'national-security';
    /** Authorization required */
    authorizationRequired: string;
    /** MFA required */
    mfaRequired: boolean;
    /** Internal/external */
    userLocation: 'internal' | 'external' | 'both';
}
/**
 * Control implementation statement
 */
export interface ControlImplementationStatement {
    /** Control ID */
    controlId: string;
    /** Control name */
    controlName: string;
    /** Implementation status */
    implementationStatus: ImplementationStatus;
    /** Control origination */
    origination: ControlOrigination;
    /** Responsible roles */
    responsibleRoles: string[];
    /** Implementation description (main narrative) */
    implementationDescription: string;
    /** Implementation parts (for multi-part controls) */
    implementationParts?: Array<{
        partId: string;
        description: string;
    }>;
    /** Parameter values */
    parameters?: Array<{
        parameterId: string;
        value: string;
    }>;
    /** Customer responsibility statement (if applicable) */
    customerResponsibilityStatement?: string;
    /** Related documents */
    relatedDocuments?: string[];
    /** Control enhancements */
    enhancements?: Array<{
        enhancementId: string;
        implementationDescription: string;
        implementationStatus: ImplementationStatus;
    }>;
}
/**
 * SSP export format
 */
export declare const EXPORT_FORMATS: readonly ["json", "xml", "docx", "oscal"];
export type ExportFormat = (typeof EXPORT_FORMATS)[number];
/**
 * SSP generation configuration
 */
export interface SSPGeneratorConfig {
    /** Template version */
    templateVersion: string;
    /** Include appendices */
    includeAppendices: boolean;
    /** Include diagrams metadata */
    includeDiagrams: boolean;
    /** Default export format */
    defaultExportFormat: ExportFormat;
}
/**
 * Complete SSP document
 */
export interface SystemSecurityPlan {
    /** SSP metadata */
    metadata: {
        version: string;
        generatedDate: Date;
        lastModified: Date;
        preparedBy: string;
        templateVersion: string;
    };
    /** System information */
    systemInformation: SystemInformation;
    /** User types */
    userTypes: SSPUserType[];
    /** System environment */
    systemEnvironment: {
        components: SystemComponent[];
        networkZones: NetworkZone[];
        dataFlows: DataFlow[];
        interconnections: SystemInterconnection[];
        externalServices: ExternalService[];
    };
    /** Ports, protocols, and services */
    portsProtocolsServices: Array<{
        port: number;
        protocol: string;
        service: string;
        purpose: string;
        usedBy: string[];
    }>;
    /** Control implementation statements */
    controlImplementations: ControlImplementationStatement[];
    /** Control summary */
    controlSummary: {
        totalControls: number;
        implemented: number;
        partiallyImplemented: number;
        planned: number;
        notApplicable: number;
        byFamily: Array<{
            family: string;
            total: number;
            implemented: number;
        }>;
    };
    /** Applicable laws and regulations */
    lawsAndRegulations: string[];
    /** Attachments/appendices references */
    attachments: Array<{
        name: string;
        description: string;
        reference: string;
    }>;
}
/**
 * FedRAMP SSP Generator Service
 */
export declare class SSPGeneratorService {
    private config;
    constructor(config: SSPGeneratorConfig);
    /**
     * Generate complete SSP document
     */
    generateSSP(systemInfo: SystemInformation, controls: FedRAMPControl[], components: SystemComponent[], networkZones: NetworkZone[], dataFlows: DataFlow[], interconnections: SystemInterconnection[], externalServices: ExternalService[], userTypes: SSPUserType[], preparedBy: string): SystemSecurityPlan;
    /**
     * Generate control implementation statement
     */
    generateControlStatement(control: FedRAMPControl): ControlImplementationStatement;
    /**
     * Generate customer responsibility statement
     */
    private generateCustomerResponsibility;
    /**
     * Calculate control summary statistics
     */
    private calculateControlSummary;
    /**
     * Extract ports, protocols, and services from data flows
     */
    private extractPortsProtocolsServices;
    /**
     * Infer service name from port number
     */
    private inferServiceFromPort;
    /**
     * Get default applicable laws and regulations
     */
    private getDefaultLawsAndRegulations;
    /**
     * Generate standard attachments list
     */
    private generateAttachmentsList;
    /**
     * Export SSP to JSON format
     */
    exportToJSON(ssp: SystemSecurityPlan): string;
    /**
     * Export SSP to OSCAL JSON format
     */
    exportToOSCAL(ssp: SystemSecurityPlan): OSCALSystemSecurityPlan;
    /**
     * Export control implementation section
     */
    exportControlImplementationSection(ssp: SystemSecurityPlan): string;
    /**
     * Generate SSP summary report
     */
    generateSummaryReport(ssp: SystemSecurityPlan): SSPSummaryReport;
    /**
     * Calculate SSP readiness score
     */
    private calculateReadinessScore;
    private generateUUID;
    private getProfileHref;
    private extractRoles;
    private extractParties;
}
export interface SSPSummaryReport {
    generatedDate: Date;
    systemName: string;
    securityCategorization: 'low' | 'moderate' | 'high';
    authorizationType: 'agency' | 'jab';
    controlSummary: SystemSecurityPlan['controlSummary'];
    implementationGaps: Array<{
        controlId: string;
        controlName: string;
        status: ImplementationStatus;
    }>;
    sharedControlsCount: number;
    componentCount: number;
    interconnectionCount: number;
    externalServiceCount: number;
    leveragedAuthorizationsCount: number;
    readinessScore: number;
}
/**
 * OSCAL System Security Plan format
 */
export interface OSCALSystemSecurityPlan {
    'system-security-plan': {
        uuid: string;
        metadata: {
            title: string;
            'last-modified': string;
            version: string;
            'oscal-version': string;
            roles: Array<{
                id: string;
                title: string;
            }>;
            parties: Array<{
                uuid: string;
                type: string;
                name: string;
            }>;
        };
        'import-profile': {
            href: string;
        };
        'system-characteristics': {
            'system-name': string;
            description: string;
            'system-ids': Array<{
                'identifier-type': string;
                id: string;
            }>;
            'security-sensitivity-level': string;
            'system-information': {
                'information-types': Array<{
                    title: string;
                    description: string;
                    categorizations: Array<{
                        system: string;
                        'information-type-ids': string[];
                    }>;
                }>;
            };
            'authorization-boundary': {
                description: string;
            };
        };
        'system-implementation': {
            users: Array<{
                uuid: string;
                title: string;
                description: string;
                'role-ids': string[];
            }>;
            components: Array<{
                uuid: string;
                type: string;
                title: string;
                description: string;
                status: {
                    state: string;
                };
            }>;
        };
        'control-implementation': {
            description: string;
            'implemented-requirements': Array<{
                uuid: string;
                'control-id': string;
                statements: Array<{
                    'statement-id': string;
                    uuid: string;
                    description: string;
                }>;
            }>;
        };
    };
}
export default SSPGeneratorService;
//# sourceMappingURL=ssp-generator.d.ts.map