@tantainnovative/ndpr-toolkit 3.4.1 → 3.5.0

package/dist/index.d.ts

@@ -1,43 +1,4428 @@
-export { C as ConsentAnalyticsEvent, a as ConsentBanner, b as ConsentBannerClassNames } from './ConsentBanner-VqIPophc.js';
-export { C as ConsentManager, a as ConsentManagerClassNames } from './ConsentManager-CQ2IZtUU.js';
-export { C as ConsentStorage, a as ConsentStorageClassNames, r as resolveClass } from './styling-BaoQtV06.js';
-export { C as ConsentOption, a as ConsentSettings, b as ConsentStorageOptions, L as LawfulBasisType } from './consent-CmVzqZUk.js';
-export { D as DSRFormSubmission, a as DSRRequestForm, b as DSRRequestFormClassNames } from './DSRRequestForm-D8rPTNmU.js';
-export { D as DSRDashboard, a as DSRDashboardClassNames, b as DSRTracker, c as DSRTrackerClassNames } from './DSRTracker-Bl__d4df.js';
-export { D as DSRRequest, a as DSRStatus, b as DSRType, R as RequestStatus, c as RequestType } from './dsr-yKbqX531.js';
-export { D as DPIAQuestionnaire, a as DPIAQuestionnaireClassNames } from './DPIAQuestionnaire-VXBoWFMC.js';
-export { D as DPIAReport, a as DPIAReportClassNames, S as StepIndicator, b as StepIndicatorClassNames } from './StepIndicator-CgrlokSV.js';
-export { D as DPIAQuestion, a as DPIAResult, b as DPIARisk, c as DPIASection } from './dpia-c9GiiOq0.js';
-export { B as BreachFormSubmission, a as BreachReportForm, b as BreachReportFormClassNames } from './BreachReportForm-DpRrBoxU.js';
-export { B as BreachNotificationManager, a as BreachNotificationManagerClassNames, b as BreachRiskAssessment, c as BreachRiskAssessmentClassNames, R as RegulatoryReportGenerator, d as RegulatoryReportGeneratorClassNames } from './RegulatoryReportGenerator-BUYgzTTT.js';
-export { B as BreachCategory, a as BreachReport, N as NotificationRequirement, R as RegulatoryNotification, b as RiskAssessment } from './breach-Eu9byel8.js';
-export { P as PolicyExporter, a as PolicyExporterClassNames, b as PolicyGenerator, c as PolicyGeneratorClassNames, d as PolicyPreview, e as PolicyPreviewClassNames } from './PolicyExporter-BnvuFncj.js';
-export { O as OrganizationInfo, P as PolicySection, a as PolicyTemplate, b as PolicyVariable, c as PrivacyPolicy } from './privacy-Ca6te9Ir.js';
-export { N as NDPRConfig, a as NDPRProvider, u as useNDPRConfig } from './NDPRProvider-DYFb8xEl.js';
-export { C as ConsentAuditEntry, a as appendAuditEntry, c as createAuditEntry, g as getAuditLog, v as validateConsent, b as validateConsentOptions } from './consent-audit-DhbfMR0n.js';
-export { f as formatDSRRequest } from './dsr-CIx5sd7e.js';
-export { a as assessDPIARisk } from './dpia-D82hUrJe.js';
-export { c as calculateBreachSeverity } from './breach-CzXqSsaY.js';
-export { D as DEFAULT_POLICY_SECTIONS, a as DEFAULT_POLICY_VARIABLES, c as createBusinessPolicyTemplate, g as generatePolicyText } from './policy-templates-DhLwq4R-.js';
-export { s as sanitizeInput } from './sanitize-CxxwKxAx.js';
-export { u as useConsent } from './useConsent-dOcELSfX.js';
-export { u as useDSR } from './useDSR-wH4H6hSM.js';
-export { u as useDPIA } from './useDPIA-CTqbNbww.js';
-export { u as useBreach } from './useBreach-DkVXvtJK.js';
-export { u as useDefaultPrivacyPolicy, a as usePrivacyPolicy } from './useDefaultPrivacyPolicy-DkOqMg2e.js';
-export { L as LawfulBasisTracker, a as LawfulBasisTrackerClassNames } from './LawfulBasisTracker-Cg30NbDA.js';
-export { L as LawfulBasis, a as LawfulBasisSummary, b as LegitimateInterestAssessment, P as ProcessingActivity, S as SensitiveDataCondition } from './lawful-basis-Cv1VmDLn.js';
-export { L as LawfulBasisComplianceGap, a as LawfulBasisValidationResult, b as assessComplianceGaps, g as generateLawfulBasisSummary, c as getLawfulBasisDescription, v as validateProcessingActivity } from './lawful-basis-BEyI0kGg.js';
-export { u as useLawfulBasis } from './useLawfulBasis-DFTmu1ca.js';
-export { C as CrossBorderTransferManager, a as CrossBorderTransferManagerClassNames } from './CrossBorderTransferManager-D5Lc0e46.js';
-export { A as AdequacyStatus, C as CrossBorderSummary, a as CrossBorderTransfer, T as TransferImpactAssessment, b as TransferMechanism } from './cross-border-UyT00llA.js';
-export { T as TransferRiskResult, a as TransferValidationResult, b as assessTransferRisk, g as getTransferMechanismDescription, i as isNDPCApprovalRequired, v as validateTransfer } from './cross-border-Dy-U9Hu6.js';
-export { u as useCrossBorderTransfer } from './useCrossBorderTransfer-DvSq06lv.js';
-export { R as ROPAManager, a as ROPAManagerClassNames } from './ROPAManager-qxTrXLkD.js';
-export { P as ProcessingRecord, R as ROPASummary, a as RecordOfProcessingActivities } from './ropa-BDTM06tr.js';
-export { R as ROPAComplianceGap, a as ROPAValidationResult, e as exportROPAToCSV, g as generateROPASummary, i as identifyComplianceGaps, v as validateProcessingRecord } from './ropa-CyynscU6.js';
-export { U as UseROPAOptions, a as UseROPAReturn, u as useROPA } from './useROPA-BSSU1rfx.js';
-export { N as NDPRDashboard, a as NDPRDashboardClassNames, b as NDPRDashboardProps } from './NDPRDashboard-DDWNd2Ah.js';
-export { C as ComplianceInput, a as ComplianceRating, b as ComplianceReport, E as EffortLevel, M as ModuleScore, R as Recommendation, c as RecommendationPriority, d as RegulatoryReference, g as getComplianceScore } from './compliance-score-racQe_E_.js';
-import 'react';
-import './types-DK2CoKOC.js';
+import { ErrorInfo } from 'react';
+import React__default from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * Adequacy status of a destination country
+ */
+export declare type AdequacyStatus = 'adequate' | 'inadequate' | 'pending_review' | 'unknown';
+
+/**
+ * Appends a single audit entry to the consent audit log in localStorage.
+ * The log is append-only; existing entries are never modified.
+ *
+ * @param entry     - The audit entry to append
+ * @param storageKey - Base storage key (the audit key is derived as `${storageKey}_audit`)
+ */
+export declare function appendAuditEntry(entry: ConsentAuditEntry, storageKey?: string): void;
+
+/**
+ * Analyzes all processing activities and returns compliance gaps including
+ * missing DPO approval, overdue reviews, undocumented justifications,
+ * missing LIA for legitimate interests, and other documentation issues.
+ *
+ * @param activities Array of processing activities to analyze
+ * @returns Array of identified compliance gaps
+ */
+export declare function assessComplianceGaps(activities: ProcessingActivity[]): LawfulBasisComplianceGap[];
+
+/**
+ * Assesses the risk level of a DPIA based on the identified risks
+ * @param dpiaResult The DPIA result containing risks to assess
+ * @returns Assessment result with overall risk level and recommendations
+ */
+export declare function assessDPIARisk(dpiaResult: DPIAResult): {
+    overallRiskLevel: 'low' | 'medium' | 'high' | 'critical';
+    requiresConsultation: boolean;
+    canProceed: boolean;
+    recommendations: string[];
+};
+
+/**
+ * Performs a basic risk assessment of a cross-border transfer based on adequacy status,
+ * transfer mechanism, and data sensitivity.
+ *
+ * @param transfer The cross-border transfer to assess
+ * @returns Risk assessment result with score, factors, and recommendations
+ */
+export declare function assessTransferRisk(transfer: CrossBorderTransfer): TransferRiskResult;
+
+/**
+ * Breach notification types aligned with NDPA 2023 Section 40
+ * Data controllers must notify the NDPC within 72 hours of becoming aware of a breach
+ * Data subjects must be notified without undue delay when breach is likely to result in high risk
+ */
+/**
+ * Represents a data breach category
+ */
+export declare interface BreachCategory {
+    /** Unique identifier for the category */
+    id: string;
+    /** Display name for the category */
+    name: string;
+    /** Description of this breach category */
+    description: string;
+    /** Default severity level for this category */
+    defaultSeverity: 'low' | 'medium' | 'high' | 'critical';
+}
+
+declare type BreachCompositeState = {
+    reports: BreachReport[];
+    assessments: RiskAssessment[];
+    notifications: RegulatoryNotification[];
+};
+
+/**
+ * Represents the data submitted by the breach report form.
+ */
+export declare interface BreachFormSubmission {
+    /** Title/summary of the breach */
+    title: string;
+    /** Detailed description of the breach */
+    description: string;
+    /** Breach category identifier */
+    category: string;
+    /** Timestamp (ms) when the breach was discovered */
+    discoveredAt: number;
+    /** Timestamp (ms) when the breach occurred (if known) */
+    occurredAt?: number;
+    /** Timestamp (ms) when the form was submitted */
+    reportedAt: number;
+    /** Person reporting the breach */
+    reporter: {
+        name: string;
+        email: string;
+        department: string;
+        phone?: string;
+    };
+    /** Systems or applications affected by the breach */
+    affectedSystems: string[];
+    /** Types of data involved in the breach */
+    dataTypes: string[];
+    /** Estimated number of affected data subjects */
+    estimatedAffectedSubjects?: number;
+    /** Current status of the breach */
+    status: 'ongoing' | 'contained' | 'resolved';
+    /** Initial actions taken to address the breach */
+    initialActions?: string;
+    /** File attachments included with the report */
+    attachments: Array<{
+        name: string;
+        type: string;
+        size: number;
+        file: File;
+    }>;
+}
+
+/**
+ * Breach notification management component. Implements NDPA Section 40 requirements for
+ * managing breach notifications, tracking 72-hour NDPC reporting deadlines, and coordinating
+ * data subject notifications.
+ */
+export declare const BreachNotificationManager: React__default.FC<BreachNotificationManagerProps>;
+
+export declare interface BreachNotificationManagerClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    breachList?: string;
+    breachItem?: string;
+    statusBadge?: string;
+    timeline?: string;
+    timelineStep?: string;
+    detailPanel?: string;
+}
+
+declare interface BreachNotificationManagerProps {
+    /**
+     * List of breach reports to manage
+     */
+    breachReports: BreachReport[];
+    /**
+     * List of risk assessments
+     */
+    riskAssessments: RiskAssessment[];
+    /**
+     * List of regulatory notifications
+     */
+    regulatoryNotifications: RegulatoryNotification[];
+    /**
+     * Callback function called when a breach is selected
+     */
+    onSelectBreach?: (breachId: string) => void;
+    /**
+     * Callback function called when a risk assessment is requested
+     */
+    onRequestAssessment?: (breachId: string) => void;
+    /**
+     * Callback function called when a notification is requested
+     */
+    onRequestNotification?: (breachId: string) => void;
+    /**
+     * Title displayed on the manager
+     * @default "Breach Notification Manager"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the manager
+     * @default "Manage data breach notifications and track compliance with NDPA Section 40 requirements."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the manager
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Override class names for individual elements
+     */
+    classNames?: BreachNotificationManagerClassNames;
+    /**
+     * Remove all default styles, only applying classNames overrides
+     */
+    unstyled?: boolean;
+    /**
+     * Whether to show the breach details
+     * @default true
+     */
+    showBreachDetails?: boolean;
+    /**
+     * Whether to show the notification timeline
+     * @default true
+     */
+    showNotificationTimeline?: boolean;
+    /**
+     * Whether to show the deadline alerts
+     * @default true
+     */
+    showDeadlineAlerts?: boolean;
+}
+
+/**
+ * Represents a data breach report
+ */
+export declare interface BreachReport {
+    /** Unique identifier for the breach report */
+    id: string;
+    /** Title/summary of the breach */
+    title: string;
+    /** Detailed description of the breach */
+    description: string;
+    /** Category of the breach */
+    category: string;
+    /** Timestamp when the breach was discovered */
+    discoveredAt: number;
+    /** Timestamp when the breach occurred (if known) */
+    occurredAt?: number;
+    /** Timestamp when the breach was reported internally */
+    reportedAt: number;
+    /** Person who reported the breach */
+    reporter: {
+        name: string;
+        email: string;
+        department: string;
+        phone?: string;
+    };
+    /** Systems or data affected by the breach */
+    affectedSystems: string[];
+    /** Types of data involved in the breach */
+    dataTypes: string[];
+    /** Whether sensitive personal data is involved (NDPA Section 27) */
+    involvesSensitiveData?: boolean;
+    /** Estimated number of data subjects affected */
+    estimatedAffectedSubjects?: number;
+    /** Whether the breach is ongoing or contained */
+    status: 'ongoing' | 'contained' | 'resolved';
+    /** Initial actions taken to address the breach */
+    initialActions?: string;
+    /** Attachments related to the breach */
+    attachments?: Array<{
+        id: string;
+        name: string;
+        type: string;
+        url: string;
+        addedAt: number;
+    }>;
+}
+
+/**
+ * Breach report form component. Implements NDPA Section 40 breach notification requirements,
+ * enabling organizations to document and report data breaches within the mandated 72-hour window.
+ */
+export declare const BreachReportForm: React__default.FC<BreachReportFormProps>;
+
+export declare interface BreachReportFormClassNames {
+    root?: string;
+    title?: string;
+    form?: string;
+    fieldGroup?: string;
+    label?: string;
+    input?: string;
+    select?: string;
+    textarea?: string;
+    submitButton?: string;
+    /** Alias for submitButton */
+    primaryButton?: string;
+    notice?: string;
+    /** Custom class applied when isSubmitting is true (e.g. a loading overlay) */
+    loadingOverlay?: string;
+}
+
+declare interface BreachReportFormProps {
+    /**
+     * Available breach categories
+     */
+    categories: BreachCategory[];
+    /**
+     * Callback function called when form is submitted
+     */
+    onSubmit: (data: BreachFormSubmission) => void;
+    /**
+     * Callback function called when form validation fails
+     */
+    onValidationError?: (errors: Record<string, string>) => void;
+    /**
+     * Title displayed on the form
+     * @default "Report a Data Breach"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the form
+     * @default "Use this form to report a suspected or confirmed data breach in accordance with NDPA Section 40. All fields marked with * are required."
+     */
+    formDescription?: string;
+    /**
+     * Text for the submit button
+     * @default "Submit Report"
+     */
+    submitButtonText?: string;
+    /**
+     * Custom CSS class for the form
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the submit button
+     */
+    buttonClassName?: string;
+    /**
+     * Override class names for individual elements
+     */
+    classNames?: BreachReportFormClassNames;
+    /**
+     * Remove all default styles, only applying classNames overrides
+     */
+    unstyled?: boolean;
+    /**
+     * Whether the form is currently submitting.
+     * When true, the submit button is disabled and shows "Submitting..." text.
+     */
+    isSubmitting?: boolean;
+    /**
+     * Whether to show a confirmation message after submission
+     * @default true
+     */
+    showConfirmation?: boolean;
+    /**
+     * Confirmation message to display after submission
+     * @default "Your breach report has been submitted successfully. The data protection team has been notified."
+     */
+    confirmationMessage?: string;
+    /**
+     * Whether to allow file attachments
+     * @default true
+     */
+    allowAttachments?: boolean;
+    /**
+     * Maximum number of attachments allowed
+     * @default 5
+     */
+    maxAttachments?: number;
+    /**
+     * Maximum file size for attachments (in bytes)
+     * @default 5242880 (5MB)
+     */
+    maxFileSize?: number;
+    /**
+     * Allowed file types for attachments
+     * @default ['.pdf', '.jpg', '.jpeg', '.png', '.doc', '.docx', '.xls', '.xlsx', '.txt']
+     */
+    allowedFileTypes?: string[];
+    /**
+     * Default values to pre-fill form fields.
+     * Useful for editing existing breach reports or pre-populating known data.
+     */
+    defaultValues?: Partial<BreachFormSubmission>;
+    /**
+     * Callback fired when the form is reset via the Reset button.
+     * To fully remount the component (clearing all internal state),
+     * change the `key` prop from the parent.
+     */
+    onReset?: () => void;
+}
+
+/**
+ * Breach risk assessment component. Implements NDPA Section 40 requirements for assessing
+ * breach severity and determining whether NDPC notification is required within 72 hours.
+ */
+export declare const BreachRiskAssessment: React__default.FC<BreachRiskAssessmentProps>;
+
+export declare interface BreachRiskAssessmentClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    slider?: string;
+    riskBadge?: string;
+    riskScore?: string;
+    notificationStatus?: string;
+    submitButton?: string;
+    /** Alias for submitButton */
+    primaryButton?: string;
+}
+
+declare interface BreachRiskAssessmentProps {
+    /**
+     * The breach data to assess
+     */
+    breachData: BreachReport;
+    /**
+     * Initial assessment data (if editing an existing assessment)
+     */
+    initialAssessment?: Partial<RiskAssessment>;
+    /**
+     * Callback function called when assessment is completed
+     */
+    onComplete: (assessment: RiskAssessment) => void;
+    /**
+     * Title displayed on the assessment form
+     * @default "Breach Risk Assessment"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the assessment form
+     * @default "Assess the risk level of this data breach to determine notification requirements under NDPA Section 40."
+     */
+    description?: string;
+    /**
+     * Text for the submit button
+     * @default "Complete Assessment"
+     */
+    submitButtonText?: string;
+    /**
+     * Custom CSS class for the form
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the submit button
+     */
+    buttonClassName?: string;
+    /**
+     * Override class names for individual elements
+     */
+    classNames?: BreachRiskAssessmentClassNames;
+    /**
+     * Remove all default styles, only applying classNames overrides
+     */
+    unstyled?: boolean;
+    /**
+     * Whether to show the breach summary
+     * @default true
+     */
+    showBreachSummary?: boolean;
+    /**
+     * Whether to show notification requirements after assessment
+     * @default true
+     */
+    showNotificationRequirements?: boolean;
+}
+
+/**
+ * Calculates the severity of a data breach based on various factors
+ * @param report The breach report
+ * @param assessment The risk assessment (if available)
+ * @returns The calculated severity and notification requirements
+ */
+export declare function calculateBreachSeverity(report: BreachReport, assessment?: RiskAssessment): {
+    severityLevel: 'low' | 'medium' | 'high' | 'critical';
+    notificationRequired: boolean;
+    urgentNotificationRequired: boolean;
+    timeframeHours: number;
+    justification: string;
+};
+
+export declare interface ComplianceInput {
+    consent: {
+        hasConsentMechanism: boolean;
+        hasPurposeSpecification: boolean;
+        hasWithdrawalMechanism: boolean;
+        hasMinorProtection: boolean;
+        consentRecordsRetained: boolean;
+    };
+    dsr: {
+        hasRequestMechanism: boolean;
+        supportsAccess: boolean;
+        supportsRectification: boolean;
+        supportsErasure: boolean;
+        supportsPortability: boolean;
+        supportsObjection: boolean;
+        /** Expected max response time in days (>30 counts as a gap) */
+        responseTimelineDays: number;
+    };
+    dpia: {
+        conductedForHighRisk: boolean;
+        documentedRisks: boolean;
+        mitigationMeasures: boolean;
+    };
+    breach: {
+        hasNotificationProcess: boolean;
+        notifiesWithin72Hours: boolean;
+        hasRiskAssessment: boolean;
+        hasRecordKeeping: boolean;
+    };
+    policy: {
+        hasPrivacyPolicy: boolean;
+        isPubliclyAccessible: boolean;
+        /** ISO date string (YYYY-MM-DD); >13 months old counts as a gap */
+        lastUpdated: string;
+        coversAllSections: boolean;
+    };
+    lawfulBasis: {
+        documentedForAllProcessing: boolean;
+        hasLegitimateInterestAssessment: boolean;
+    };
+    crossBorder: {
+        hasTransferMechanisms: boolean;
+        adequacyAssessed: boolean;
+        ndpcApprovalObtained: boolean;
+    };
+    ropa: {
+        maintained: boolean;
+        includesAllProcessing: boolean;
+        /** ISO date string (YYYY-MM-DD); >6 months since review counts as a gap */
+        lastReviewed: string;
+    };
+}
+
+/**
+ * Compliance Score Engine
+ *
+ * Evaluates an organisation's NDPA compliance posture across eight modules and
+ * returns a scored, rated report with per-module breakdowns and sorted
+ * recommendations.
+ *
+ * Pure utility — zero React dependency.
+ */
+export declare type ComplianceRating = 'excellent' | 'good' | 'needs-work' | 'critical';
+
+export declare interface ComplianceReport {
+    /** Overall compliance score, 0–100 */
+    score: number;
+    /** Rating bucket */
+    rating: ComplianceRating;
+    /** Per-module breakdown keyed by module name */
+    modules: Record<string, ModuleScore>;
+    /** Recommendations sorted by priority (critical first) */
+    recommendations: Recommendation[];
+    /** Top-level regulatory references */
+    regulatoryReferences: RegulatoryReference[];
+    /** ISO date of when the report was generated */
+    generatedAt: string;
+}
+
+export declare interface ConsentAnalyticsEvent {
+    action: 'shown' | 'accepted_all' | 'rejected_all' | 'customized' | 'dismissed';
+    timestamp: number;
+    version: string;
+    categories?: Record<string, boolean>;
+}
+
+/**
+ * Represents a single entry in the consent audit trail.
+ * Each entry captures what happened, when, and the full consent state
+ * at that point in time, satisfying NDPA recordkeeping requirements.
+ */
+export declare interface ConsentAuditEntry {
+    /** The type of consent action that occurred */
+    action: 'consent_given' | 'consent_withdrawn' | 'consent_updated' | 'consent_expired';
+    /** Unix timestamp (ms) when the action occurred */
+    timestamp: number;
+    /** Version of the consent form at the time of the action */
+    version: string;
+    /** Full snapshot of consent category states */
+    categories: Record<string, boolean>;
+    /** How consent was collected (e.g. "banner", "customize", "api") */
+    method: string;
+    /** Browser user-agent string for forensic traceability */
+    userAgent?: string;
+}
+
+/**
+ * Consent banner component. Implements NDPA Sections 25-26 consent requirements
+ * for obtaining and managing data subject consent.
+ */
+export declare const ConsentBanner: React__default.FC<ConsentBannerProps>;
+
+export declare interface ConsentBannerClassNames {
+    root?: string;
+    container?: string;
+    title?: string;
+    description?: string;
+    optionsList?: string;
+    optionItem?: string;
+    optionCheckbox?: string;
+    optionLabel?: string;
+    optionDescription?: string;
+    buttonGroup?: string;
+    acceptButton?: string;
+    rejectButton?: string;
+    customizeButton?: string;
+    saveButton?: string;
+    customizePanel?: string;
+    selectAllButton?: string;
+    /** Alias for acceptButton */
+    primaryButton?: string;
+    /** Alias for rejectButton */
+    secondaryButton?: string;
+}
+
+declare interface ConsentBannerProps {
+    /**
+     * Array of consent options to display
+     */
+    options: ConsentOption[];
+    /**
+     * Callback function called when user saves their consent choices
+     */
+    onSave: (settings: ConsentSettings) => void;
+    /**
+     * Title displayed on the banner
+     * @default "We Value Your Privacy"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the banner
+     * @default "We use cookies and similar technologies to provide our services and enhance your experience. Your consent is collected in accordance with NDPA Sections 25-26."
+     */
+    description?: string;
+    /**
+     * Text for the accept all button
+     * @default "Accept All"
+     */
+    acceptAllButtonText?: string;
+    /**
+     * Text for the reject all button
+     * @default "Reject All"
+     */
+    rejectAllButtonText?: string;
+    /**
+     * Text for the customize button
+     * @default "Customize"
+     */
+    customizeButtonText?: string;
+    /**
+     * Text for the save button
+     * @default "Save Preferences"
+     */
+    saveButtonText?: string;
+    /**
+     * Position of the banner.
+     * 'top', 'bottom', and 'center' render via a portal to document.body
+     * with fixed positioning so the banner overlays the page.
+     * 'inline' renders in the normal DOM tree without a portal.
+     * @default "bottom"
+     */
+    position?: 'top' | 'bottom' | 'center' | 'inline';
+    /**
+     * Visual treatment.
+     * - 'bar'   (default): full-width strip pinned to the edge.
+     * - 'card'  : bounded floating card with rounded corners and a margin
+     *             from the screen edges. Pairs well with `position="bottom"`.
+     * - 'modal' : centered card with a backdrop overlay. Forces center
+     *             placement regardless of `position`.
+     * @default "bar"
+     */
+    variant?: 'bar' | 'card' | 'modal';
+    /**
+     * z-index applied to the fixed-position banner.
+     * Ignored when position is 'inline'.
+     * @default 9999
+     */
+    zIndex?: number;
+    /**
+     * Version of the consent form
+     * @default "1.0"
+     */
+    version?: string;
+    /**
+     * Whether to show the banner
+     * If not provided, the banner will be shown if no consent has been saved
+     */
+    show?: boolean;
+    /**
+     * Storage key for consent settings
+     * @default "ndpr_consent"
+     */
+    storageKey?: string;
+    /**
+     * Whether the banner manages its own localStorage persistence.
+     * Set to false when an external storage mechanism (e.g., ConsentStorage)
+     * is responsible for persisting consent settings under the same key.
+     * This avoids race conditions where two writers target the same storage key.
+     * @default true
+     */
+    manageStorage?: boolean;
+    /**
+     * Custom CSS class for the banner
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Custom CSS class for the primary button
+     */
+    primaryButtonClassName?: string;
+    /**
+     * Custom CSS class for the secondary button
+     */
+    secondaryButtonClassName?: string;
+    /**
+     * Object of CSS class overrides keyed by semantic section name.
+     * Takes priority over buttonClassName / primaryButtonClassName / secondaryButtonClassName.
+     */
+    classNames?: ConsentBannerClassNames;
+    /**
+     * When true, all default Tailwind classes are removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+    /**
+     * Optional analytics callback fired on each user interaction.
+     * Called when the banner is shown, accepted, rejected, customized, or dismissed.
+     */
+    onAnalytics?: (event: ConsentAnalyticsEvent) => void;
+}
+
+/**
+ * Consent management component. Implements NDPA Sections 25-26 consent requirements,
+ * allowing data subjects to review and update their consent preferences.
+ */
+export declare const ConsentManager: React__default.FC<ConsentManagerProps>;
+
+export declare interface ConsentManagerClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    description?: string;
+    optionsList?: string;
+    optionItem?: string;
+    toggle?: string;
+    saveButton?: string;
+    resetButton?: string;
+    /** Alias for saveButton */
+    primaryButton?: string;
+    /** Alias for resetButton */
+    secondaryButton?: string;
+}
+
+declare interface ConsentManagerProps {
+    /**
+     * Array of consent options to display
+     */
+    options: ConsentOption[];
+    /**
+     * Current consent settings
+     */
+    settings?: ConsentSettings;
+    /**
+     * Callback function called when user saves their consent choices
+     */
+    onSave: (settings: ConsentSettings) => void;
+    /**
+     * Title displayed in the manager
+     * @default "Manage Your Privacy Settings"
+     */
+    title?: string;
+    /**
+     * Description text displayed in the manager
+     * @default "Update your consent preferences at any time. Required cookies cannot be disabled as they are necessary for the website to function. Consent management is provided in accordance with NDPA Sections 25-26."
+     */
+    description?: string;
+    /**
+     * Text for the save button
+     * @default "Save Preferences"
+     */
+    saveButtonText?: string;
+    /**
+     * Text for the reset button
+     * @default "Reset to Defaults"
+     */
+    resetButtonText?: string;
+    /**
+     * Version of the consent form
+     * @default "1.0"
+     */
+    version?: string;
+    /**
+     * Custom CSS class for the manager
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Custom CSS class for the primary button
+     */
+    primaryButtonClassName?: string;
+    /**
+     * Custom CSS class for the secondary button
+     */
+    secondaryButtonClassName?: string;
+    /**
+     * Object of CSS class overrides keyed by semantic section name.
+     * Takes priority over buttonClassName / primaryButtonClassName / secondaryButtonClassName.
+     */
+    classNames?: ConsentManagerClassNames;
+    /**
+     * When true, all default Tailwind classes are removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+    /**
+     * Whether to show a success message after saving
+     * @default true
+     */
+    showSuccessMessage?: boolean;
+    /**
+     * Success message to display after saving
+     * @default "Your preferences have been saved."
+     */
+    successMessage?: string;
+    /**
+     * Duration to show the success message (in milliseconds)
+     * @default 3000
+     */
+    successMessageDuration?: number;
+}
+
+/**
+ * Consent types aligned with NDPA 2023 Section 25-26
+ * Consent must be freely given, specific, informed, and unambiguous
+ */
+/**
+ * Represents a consent option that can be presented to users
+ */
+export declare interface ConsentOption {
+    /** Unique identifier for the consent option */
+    id: string;
+    /** Display label for the consent option */
+    label: string;
+    /** Detailed description of what this consent option covers */
+    description: string;
+    /** Whether this consent option is required (cannot be declined) */
+    required: boolean;
+    /**
+     * The specific purpose for which data will be processed
+     * NDPA Section 25(2) requires consent to be specific to each purpose
+     */
+    purpose: string;
+    /**
+     * Default state of the consent option
+     * @default false
+     */
+    defaultValue?: boolean;
+    /**
+     * Categories of personal data covered by this consent option
+     */
+    dataCategories?: string[];
+}
+
+/**
+ * Represents the user's consent settings
+ */
+export declare interface ConsentSettings {
+    /** Map of consent option IDs to boolean values indicating consent status */
+    consents: Record<string, boolean>;
+    /** Timestamp when consent was last updated */
+    timestamp: number;
+    /** Version of the consent form that was accepted */
+    version: string;
+    /** Method used to collect consent (e.g., "banner", "settings", "api") */
+    method: string;
+    /** Whether the user has actively made a choice (as opposed to default settings) */
+    hasInteracted: boolean;
+    /**
+     * The lawful basis under which processing is conducted
+     * Required by NDPA Section 25(1)
+     */
+    lawfulBasis?: LawfulBasisType;
+}
+
+export declare const ConsentStorage: ({ settings, storageOptions, onLoad, onSave, autoSave, autoLoad, classNames, unstyled, children }: ConsentStorageProps) => React__default.ReactElement | null;
+
+export declare interface ConsentStorageClassNames {
+    root?: string;
+}
+
+/**
+ * Represents the storage mechanism for consent settings
+ */
+export declare interface ConsentStorageOptions {
+    /**
+     * Storage key for consent settings
+     * @default "ndpr_consent"
+     */
+    storageKey?: string;
+    /**
+     * Storage type to use
+     * @default "localStorage"
+     */
+    storageType?: 'localStorage' | 'sessionStorage' | 'cookie';
+    /**
+     * Cookie options (only used when storageType is "cookie")
+     */
+    cookieOptions?: {
+        /** Domain for the cookie */
+        domain?: string;
+        /**
+         * Path for the cookie
+         * @default "/"
+         */
+        path?: string;
+        /**
+         * Expiration days for the cookie
+         * @default 365
+         */
+        expires?: number;
+        /**
+         * Whether the cookie should be secure
+         * @default true
+         */
+        secure?: boolean;
+        /**
+         * SameSite attribute for the cookie
+         * @default "Lax"
+         */
+        sameSite?: 'Strict' | 'Lax' | 'None';
+    };
+}
+
+declare interface ConsentStorageProps {
+    /**
+     * Current consent settings
+     */
+    settings: ConsentSettings;
+    /**
+     * Storage options for consent settings
+     */
+    storageOptions?: ConsentStorageOptions;
+    /**
+     * Callback function called when settings are loaded from storage
+     */
+    onLoad?: (settings: ConsentSettings | null) => void;
+    /**
+     * Callback function called when settings are saved to storage
+     */
+    onSave?: (settings: ConsentSettings) => void;
+    /**
+     * Whether to automatically save settings to storage
+     * @default true
+     */
+    autoSave?: boolean;
+    /**
+     * Whether to automatically load settings from storage on mount
+     * @default true
+     */
+    autoLoad?: boolean;
+    /**
+     * Object of CSS class overrides keyed by semantic section name.
+     */
+    classNames?: ConsentStorageClassNames;
+    /**
+     * When true, all default classes are removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+    /**
+     * Children to render
+     * Can be either React nodes or a render prop function that receives storage methods
+     */
+    children?: React__default.ReactNode | ((props: {
+        loadSettings: () => ConsentSettings | null;
+        saveSettings: (settings: ConsentSettings) => void;
+        clearSettings: () => void;
+        loaded: boolean;
+    }) => React__default.ReactNode);
+}
+
+/**
+ * Creates a new audit entry from consent settings. If `previousSettings` is
+ * provided, the action is automatically determined by comparing old and new
+ * states. Otherwise `action` defaults to `'consent_given'`.
+ */
+export declare function createAuditEntry(settings: ConsentSettings, previousSettings?: ConsentSettings | null, actionOverride?: ConsentAuditEntry['action']): ConsentAuditEntry;
+
+/**
+ * Creates a complete business privacy policy template with default
+ * NDPA-compliant sections and variables.
+ *
+ * @returns An object containing the default sections and variables.
+ */
+export declare function createBusinessPolicyTemplate(): {
+    sections: PolicySection[];
+    variables: PolicyVariable[];
+};
+
+/**
+ * Summary of cross-border transfer compliance
+ */
+export declare interface CrossBorderSummary {
+    /** Total number of active transfers */
+    totalActiveTransfers: number;
+    /** Breakdown by transfer mechanism */
+    byMechanism: Record<TransferMechanism, number>;
+    /** Breakdown by adequacy status */
+    byAdequacy: Record<AdequacyStatus, number>;
+    /** Transfers pending NDPC approval */
+    pendingApproval: CrossBorderTransfer[];
+    /** Transfers due for review */
+    dueForReview: CrossBorderTransfer[];
+    /** Transfers missing TIA */
+    missingTIA: CrossBorderTransfer[];
+    /** High-risk transfers */
+    highRiskTransfers: CrossBorderTransfer[];
+    /** Last updated timestamp */
+    lastUpdated: number;
+}
+
+/**
+ * Represents a cross-border data transfer record
+ */
+export declare interface CrossBorderTransfer {
+    /** Unique identifier */
+    id: string;
+    /** Destination country or territory */
+    destinationCountry: string;
+    /** ISO country code */
+    destinationCountryCode?: string;
+    /** Adequacy status of the destination */
+    adequacyStatus: AdequacyStatus;
+    /** The transfer mechanism being relied upon */
+    transferMechanism: TransferMechanism;
+    /** Categories of personal data being transferred */
+    dataCategories: string[];
+    /** Whether sensitive personal data is included */
+    includesSensitiveData: boolean;
+    /** Estimated number of data subjects whose data is transferred */
+    estimatedDataSubjects?: number;
+    /** Name of the recipient organization */
+    recipientOrganization: string;
+    /** Contact details of the recipient */
+    recipientContact: {
+        name: string;
+        email: string;
+        phone?: string;
+        address?: string;
+    };
+    /** Purpose of the data transfer */
+    purpose: string;
+    /** Safeguards in place to protect the data */
+    safeguards: string[];
+    /** Risk assessment summary */
+    riskAssessment: string;
+    /** Risk level of the transfer */
+    riskLevel: 'low' | 'medium' | 'high';
+    /** NDPC approval details (required for some transfer mechanisms) */
+    ndpcApproval?: {
+        required: boolean;
+        applied: boolean;
+        approved?: boolean;
+        referenceNumber?: string;
+        appliedAt?: number;
+        approvedAt?: number;
+    };
+    /** Whether a Transfer Impact Assessment has been conducted */
+    tiaCompleted: boolean;
+    /** Reference to the TIA document */
+    tiaReference?: string;
+    /** Frequency of the transfer */
+    frequency: 'one_time' | 'periodic' | 'continuous';
+    /** Start date of the transfer */
+    startDate: number;
+    /** End date of the transfer (if applicable) */
+    endDate?: number;
+    /** Status of the transfer */
+    status: 'active' | 'suspended' | 'terminated' | 'pending_approval';
+    /** Timestamp when the record was created */
+    createdAt: number;
+    /** Timestamp when the record was last updated */
+    updatedAt: number;
+    /** Next review date */
+    reviewDate?: number;
+}
+
+/**
+ * Cross-border data transfer management component. Implements NDPA Sections 41-45 requirements
+ * for managing international data transfers, including adequacy decisions, standard contractual
+ * clauses, and NDPC authorization.
+ */
+export declare const CrossBorderTransferManager: React__default.FC<CrossBorderTransferManagerProps>;
+
+export declare interface CrossBorderTransferManagerClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    summary?: string;
+    summaryCard?: string;
+    transferList?: string;
+    transferItem?: string;
+    form?: string;
+    input?: string;
+    select?: string;
+    submitButton?: string;
+    /** Alias for submitButton */
+    primaryButton?: string;
+    riskBadge?: string;
+    statusBadge?: string;
+    detailPanel?: string;
+    approvalStatus?: string;
+}
+
+declare interface CrossBorderTransferManagerProps {
+    /**
+     * List of cross-border transfers to display
+     */
+    transfers: CrossBorderTransfer[];
+    /**
+     * Callback when a new transfer is added
+     */
+    onAddTransfer?: (transfer: Omit<CrossBorderTransfer, 'id' | 'createdAt' | 'updatedAt'>) => void;
+    /**
+     * Callback when a transfer is updated
+     */
+    onUpdateTransfer?: (id: string, updates: Partial<CrossBorderTransfer>) => void;
+    /**
+     * Callback when a transfer is removed
+     */
+    onRemoveTransfer?: (id: string) => void;
+    /**
+     * Compliance summary data
+     */
+    summary?: CrossBorderSummary;
+    /**
+     * Title displayed on the manager
+     * @default "Cross-Border Data Transfer Manager"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the manager
+     * @default "Manage and document cross-border personal data transfers in compliance with NDPA 2023 Part VI (Sections 41-45)."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the manager container
+     */
+    className?: string;
+    /**
+     * Custom CSS class for buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show the compliance summary section
+     * @default true
+     */
+    showSummary?: boolean;
+    /**
+     * Whether to show the TIA section in the form
+     * @default true
+     */
+    showTIA?: boolean;
+    /**
+     * Override class names for individual sections of the component.
+     * Takes priority over className / buttonClassName.
+     */
+    classNames?: CrossBorderTransferManagerClassNames;
+    /**
+     * When true, all default styling is removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Default NDPA-compliant privacy policy sections.
+ * Each section uses {{variable}} placeholders that are resolved at generation time.
+ */
+export declare const DEFAULT_POLICY_SECTIONS: PolicySection[];
+
+/**
+ * Default policy variables for NDPA-compliant privacy policies.
+ * These map to the {{variable}} placeholders used in DEFAULT_POLICY_SECTIONS.
+ */
+export declare const DEFAULT_POLICY_VARIABLES: PolicyVariable[];
+
+/** A map of question IDs to their answer values */
+declare type DPIAAnswerMap = Record<string, DPIAAnswerValue>;
+
+/** Possible value types for a DPIA answer */
+declare type DPIAAnswerValue = string | number | boolean | string[];
+
+/**
+ * Data Protection Impact Assessment types aligned with NDPA 2023 Sections 38-39
+ * A DPIA is required when processing is likely to result in high risk to data subjects
+ */
+/**
+ * Represents a question in the DPIA questionnaire
+ */
+export declare interface DPIAQuestion {
+    /** Unique identifier for the question */
+    id: string;
+    /** The text of the question */
+    text: string;
+    /** Additional guidance for answering the question */
+    guidance?: string;
+    /** Type of input required for the answer */
+    type: 'text' | 'textarea' | 'select' | 'radio' | 'checkbox' | 'scale';
+    /** Options for select, radio, or checkbox questions */
+    options?: Array<{
+        value: string;
+        label: string;
+        riskLevel?: 'low' | 'medium' | 'high';
+    }>;
+    /** For scale questions, the minimum value */
+    minValue?: number;
+    /** For scale questions, the maximum value */
+    maxValue?: number;
+    /** For scale questions, labels for the scale points */
+    scaleLabels?: Record<number, string>;
+    /** Whether the question is required */
+    required: boolean;
+    /** Risk level associated with this question */
+    riskLevel?: 'low' | 'medium' | 'high';
+    /** Whether this question triggers additional questions based on the answer */
+    hasDependentQuestions?: boolean;
+    /** Conditions that determine when this question should be shown */
+    showWhen?: Array<{
+        questionId: string;
+        operator: 'equals' | 'contains' | 'greaterThan' | 'lessThan';
+        value: string | number | boolean;
+    }>;
+}
+
+/**
+ * DPIA questionnaire component. Implements NDPA Section 38 requirements
+ * for conducting Data Protection Impact Assessments on high-risk processing activities.
+ */
+export declare const DPIAQuestionnaire: React__default.FC<DPIAQuestionnaireProps>;
+
+export declare interface DPIAQuestionnaireClassNames {
+    /** Outermost wrapper */
+    root?: string;
+    /** Header area containing progress indicator */
+    header?: string;
+    /** Section title */
+    title?: string;
+    /** Section container */
+    section?: string;
+    /** Section title heading */
+    sectionTitle?: string;
+    /** Individual question wrapper */
+    question?: string;
+    /** Question label text */
+    questionText?: string;
+    /** Guidance / help text below a question */
+    guidance?: string;
+    /** Text / textarea / select inputs */
+    input?: string;
+    /** Radio option group container */
+    radioGroup?: string;
+    /** Individual radio option row */
+    radioOption?: string;
+    /** Navigation button container */
+    navigation?: string;
+    /** Next / submit button */
+    nextButton?: string;
+    /** Previous button */
+    prevButton?: string;
+    /** Alias for nextButton */
+    primaryButton?: string;
+    /** Alias for prevButton */
+    secondaryButton?: string;
+    /** Progress bar wrapper */
+    progressBar?: string;
+}
+
+declare interface DPIAQuestionnaireProps {
+    /**
+     * Sections of the DPIA questionnaire
+     */
+    sections: DPIASection[];
+    /**
+     * Current answers to the questionnaire
+     */
+    answers: Record<string, string | number | boolean | string[]>;
+    /**
+     * Callback function called when an answer is updated
+     */
+    onAnswerChange: (questionId: string, value: string | number | boolean | string[]) => void;
+    /**
+     * Current section index
+     */
+    currentSectionIndex: number;
+    /**
+     * Callback function called when user navigates to the next section
+     */
+    onNextSection?: () => void;
+    /**
+     * Callback function called when user navigates to the previous section
+     */
+    onPrevSection?: () => void;
+    /**
+     * Validation errors for the current section
+     */
+    validationErrors?: Record<string, string>;
+    /**
+     * Whether the questionnaire is in read-only mode
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * Custom CSS class for the questionnaire
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Text for the next button
+     * @default "Next"
+     */
+    nextButtonText?: string;
+    /**
+     * Text for the previous button
+     * @default "Previous"
+     */
+    prevButtonText?: string;
+    /**
+     * Text for the submit button (shown on the last section)
+     * @default "Submit"
+     */
+    submitButtonText?: string;
+    /**
+     * Whether to show a progress indicator
+     * @default true
+     */
+    showProgress?: boolean;
+    /**
+     * Current progress percentage (0-100)
+     */
+    progress?: number;
+    /**
+     * Per-section class name overrides
+     */
+    classNames?: DPIAQuestionnaireClassNames;
+    /**
+     * When true, all default classes are stripped.
+     * Only explicit overrides from `classNames` are applied.
+     * @default false
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * DPIA report component. Implements NDPA Sections 38-39 requirements for documenting
+ * and presenting Data Protection Impact Assessment findings, risks, and recommendations.
+ */
+export declare const DPIAReport: React__default.FC<DPIAReportProps>;
+
+export declare interface DPIAReportClassNames {
+    /** Outermost wrapper */
+    root?: string;
+    /** Report header area */
+    header?: string;
+    /** Main report title */
+    title?: string;
+    /** Executive summary section */
+    summary?: string;
+    /** Risk level badge */
+    riskBadge?: string;
+    /** Risks table element */
+    riskTable?: string;
+    /** Individual risk row */
+    riskRow?: string;
+    /** Recommendation list item */
+    recommendation?: string;
+    /** Conclusion text */
+    conclusion?: string;
+    /** Print button */
+    printButton?: string;
+    /** Alias for printButton */
+    primaryButton?: string;
+}
+
+declare interface DPIAReportProps {
+    /**
+     * The DPIA result to display
+     */
+    result: DPIAResult;
+    /**
+     * The sections of the DPIA questionnaire
+     */
+    sections: DPIASection[];
+    /**
+     * Whether to show the full report or just a summary
+     * @default true
+     */
+    showFullReport?: boolean;
+    /**
+     * Whether to allow printing the report
+     * @default true
+     */
+    allowPrint?: boolean;
+    /**
+     * Whether to allow exporting the report as PDF
+     * @default true
+     */
+    allowExport?: boolean;
+    /**
+     * Callback function called when the report is exported
+     */
+    onExport?: (format: 'pdf' | 'docx' | 'html') => void;
+    /**
+     * Custom CSS class for the report container
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Per-section class name overrides
+     */
+    classNames?: DPIAReportClassNames;
+    /**
+     * When true, all default classes are stripped.
+     * Only explicit overrides from `classNames` are applied.
+     * @default false
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Represents the result of a completed DPIA
+ */
+export declare interface DPIAResult {
+    /** Unique identifier for the DPIA */
+    id: string;
+    /** Title of the DPIA */
+    title: string;
+    /** Description of the processing activity being assessed */
+    processingDescription: string;
+    /** Timestamp when the DPIA was started */
+    startedAt: number;
+    /** Timestamp when the DPIA was completed */
+    completedAt?: number;
+    /** Person responsible for conducting the DPIA */
+    assessor: {
+        name: string;
+        role: string;
+        email: string;
+    };
+    /** Answers to all questions in the DPIA */
+    answers: Record<string, string | number | boolean | string[]>;
+    /** Risks identified in the DPIA */
+    risks: DPIARisk[];
+    /** Overall risk level of the processing activity */
+    overallRiskLevel: 'low' | 'medium' | 'high' | 'critical';
+    /** Whether the DPIA concluded that the processing can proceed */
+    canProceed: boolean;
+    /** Reasons why the processing can or cannot proceed */
+    conclusion: string;
+    /** Recommendations for the processing activity */
+    recommendations?: string[];
+    /** Next review date for the DPIA */
+    reviewDate?: number;
+    /** Version of the DPIA questionnaire used */
+    version: string;
+    /**
+     * Whether prior consultation with NDPC is required
+     * Per NDPA Section 39, consultation is required when DPIA indicates high residual risk
+     */
+    ndpcConsultationRequired?: boolean;
+    /** Date when NDPC consultation was initiated */
+    ndpcConsultationDate?: number;
+    /** Reference number from NDPC consultation */
+    ndpcConsultationReference?: string;
+    /**
+     * The lawful basis for the processing activity being assessed
+     */
+    lawfulBasis?: string;
+    /**
+     * Whether this DPIA involves cross-border data transfers
+     */
+    involvesCrossBorderTransfer?: boolean;
+}
+
+/**
+ * Represents a risk identified in the DPIA
+ */
+export declare interface DPIARisk {
+    /** Unique identifier for the risk */
+    id: string;
+    /** Description of the risk */
+    description: string;
+    /** Likelihood of the risk occurring (1-5) */
+    likelihood: number;
+    /** Impact if the risk occurs (1-5) */
+    impact: number;
+    /** Overall risk score (likelihood * impact) */
+    score: number;
+    /** Risk level based on the score */
+    level: 'low' | 'medium' | 'high' | 'critical';
+    /** Measures to mitigate the risk */
+    mitigationMeasures?: string[];
+    /** Whether the risk has been mitigated */
+    mitigated: boolean;
+    /** Residual risk score after mitigation */
+    residualScore?: number;
+    /** Questions that identified this risk */
+    relatedQuestionIds: string[];
+}
+
+/**
+ * Represents a section in the DPIA questionnaire
+ */
+export declare interface DPIASection {
+    /** Unique identifier for the section */
+    id: string;
+    /** Title of the section */
+    title: string;
+    /** Description of the section */
+    description?: string;
+    /** Questions in this section */
+    questions: DPIAQuestion[];
+    /** Order of the section in the questionnaire */
+    order: number;
+}
+
+/**
+ * Data Subject Request dashboard component. Supports compliance with NDPA Part IV,
+ * providing tools to track, manage, and respond to data subject requests within required timeframes.
+ */
+export declare const DSRDashboard: React__default.FC<DSRDashboardProps>;
+
+export declare interface DSRDashboardClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    filters?: string;
+    requestList?: string;
+    requestItem?: string;
+    statusBadge?: string;
+    detailPanel?: string;
+}
+
+declare interface DSRDashboardProps {
+    /**
+     * List of DSR requests to display
+     */
+    requests: DSRRequest[];
+    /**
+     * Callback function called when a request is selected
+     */
+    onSelectRequest?: (requestId: string) => void;
+    /**
+     * Callback function called when a request status is updated
+     */
+    onUpdateStatus?: (requestId: string, status: DSRStatus) => void;
+    /**
+     * Callback function called when a request is assigned
+     */
+    onAssignRequest?: (requestId: string, assignee: string) => void;
+    /**
+     * Title displayed on the dashboard
+     * @default "Data Subject Request Dashboard"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the dashboard
+     * @default "Track and manage data subject requests in compliance with NDPA Part IV requirements."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the dashboard
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show the request details
+     * @default true
+     */
+    showRequestDetails?: boolean;
+    /**
+     * Whether to show the request timeline
+     * @default true
+     */
+    showRequestTimeline?: boolean;
+    /**
+     * Whether to show the deadline alerts
+     * @default true
+     */
+    showDeadlineAlerts?: boolean;
+    /**
+     * List of possible assignees
+     */
+    assignees?: string[];
+    /**
+     * Object of CSS class overrides keyed by semantic section name.
+     */
+    classNames?: DSRDashboardClassNames;
+    /**
+     * When true, all default Tailwind classes are removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Represents the data submitted by the DSR request form.
+ */
+export declare interface DSRFormSubmission {
+    /** The selected request type identifier */
+    requestType: string;
+    /** Data subject personal information */
+    dataSubject: {
+        fullName: string;
+        email: string;
+        phone?: string;
+        identifierType: string;
+        identifierValue: string;
+    };
+    /** Additional information provided for the selected request type */
+    additionalInfo?: Record<string, string | number | boolean | null>;
+    /** Timestamp (ms) when the form was submitted */
+    submittedAt: number;
+}
+
+/**
+ * Represents a data subject request
+ */
+export declare interface DSRRequest {
+    /** Unique identifier for the request */
+    id: string;
+    /** Type of request */
+    type: DSRType;
+    /** Current status of the request */
+    status: DSRStatus;
+    /** Timestamp when the request was submitted */
+    createdAt: number;
+    /** Timestamp when the request was last updated */
+    updatedAt: number;
+    /** Timestamp when the request was completed (if applicable) */
+    completedAt?: number;
+    /** Timestamp when the identity was verified (if applicable) */
+    verifiedAt?: number;
+    /**
+     * Due date for responding to the request (timestamp)
+     * NDPA requires response within 30 days of receipt
+     */
+    dueDate?: number;
+    /** Description or details of the request */
+    description?: string;
+    /**
+     * The lawful basis under which the data was originally processed
+     * Relevant for evaluating objection and erasure requests
+     */
+    lawfulBasis?: string;
+    /** Data subject information */
+    subject: {
+        name: string;
+        email: string;
+        phone?: string;
+        identifierValue?: string;
+        identifierType?: string;
+    };
+    /** Additional information provided by the data subject */
+    additionalInfo?: Record<string, string | number | boolean | null>;
+    /** Notes added by staff processing the request */
+    internalNotes?: Array<{
+        timestamp: number;
+        author: string;
+        note: string;
+    }>;
+    /** Verification status */
+    verification?: {
+        verified: boolean;
+        method?: string;
+        verifiedAt?: number;
+        verifiedBy?: string;
+    };
+    /** Reason for rejection (if status is 'rejected') */
+    rejectionReason?: string;
+    /** Files attached to the request */
+    attachments?: Array<{
+        id: string;
+        name: string;
+        type: string;
+        url: string;
+        addedAt: number;
+    }>;
+    /**
+     * Whether an extension was requested for this DSR
+     * NDPA allows a one-time extension of 30 days with justification
+     */
+    extensionRequested?: boolean;
+    /** Reason for the extension, if requested */
+    extensionReason?: string;
+}
+
+/**
+ * Data Subject Request form component. Implements NDPA Part IV, Sections 29-36
+ * covering data subject rights including access, rectification, erasure, and portability.
+ */
+export declare const DSRRequestForm: React__default.FC<DSRRequestFormProps>;
+
+export declare interface DSRRequestFormClassNames {
+    root?: string;
+    title?: string;
+    description?: string;
+    form?: string;
+    fieldGroup?: string;
+    label?: string;
+    input?: string;
+    select?: string;
+    textarea?: string;
+    submitButton?: string;
+    /** Alias for submitButton */
+    primaryButton?: string;
+    successMessage?: string;
+    /** Custom class applied when isSubmitting is true (e.g. a loading overlay) */
+    loadingOverlay?: string;
+}
+
+declare interface DSRRequestFormProps {
+    /**
+     * Array of request types that can be submitted
+     */
+    requestTypes: RequestType[];
+    /**
+     * Callback function called when form is submitted
+     */
+    onSubmit: (data: DSRFormSubmission) => void;
+    /**
+     * Callback function called when form validation fails
+     */
+    onValidationError?: (errors: Record<string, string>) => void;
+    /**
+     * Title displayed on the form
+     * @default "Submit a Data Subject Request"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the form
+     * @default "Use this form to exercise your rights under the Nigeria Data Protection Act (NDPA), Part IV, Sections 29-36."
+     */
+    description?: string;
+    /**
+     * Text for the submit button
+     * @default "Submit Request"
+     */
+    submitButtonText?: string;
+    /**
+     * Custom CSS class for the form
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the submit button
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show a confirmation message after submission
+     * @default true
+     */
+    showConfirmation?: boolean;
+    /**
+     * Confirmation message to display after submission
+     * @default "Your request has been submitted successfully. You will receive a confirmation email shortly."
+     */
+    confirmationMessage?: string;
+    /**
+     * Whether to require identity verification
+     * @default true
+     */
+    requireIdentityVerification?: boolean;
+    /**
+     * Types of identifiers accepted for verification
+     * @default ["email", "account", "customer_id"]
+     */
+    identifierTypes?: Array<{
+        id: string;
+        label: string;
+    }>;
+    /**
+     * Whether to collect additional contact information
+     * @default true
+     */
+    collectAdditionalContact?: boolean;
+    /**
+     * Custom labels for form fields
+     */
+    labels?: {
+        name?: string;
+        email?: string;
+        requestType?: string;
+        description?: string;
+        submit?: string;
+    };
+    /**
+     * Object of CSS class overrides keyed by semantic section name.
+     */
+    classNames?: DSRRequestFormClassNames;
+    /**
+     * When true, all default Tailwind classes are removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+    /**
+     * Whether the form is currently submitting.
+     * When true, the submit button is disabled and shows "Submitting..." text.
+     */
+    isSubmitting?: boolean;
+    /**
+     * Default values to pre-fill form fields.
+     * Useful for editing existing requests or pre-populating known data.
+     */
+    defaultValues?: Partial<DSRFormSubmission>;
+    /**
+     * Callback fired when the form is reset via the Reset button.
+     * To fully remount the component (clearing all internal state),
+     * change the `key` prop from the parent.
+     */
+    onReset?: () => void;
+}
+
+/**
+ * Status of a data subject request
+ */
+export declare type DSRStatus = 'pending' | 'awaitingVerification' | 'inProgress' | 'completed' | 'rejected';
+
+/**
+ * DSR tracking and analytics component. Supports compliance with NDPA Part IV,
+ * providing summary statistics, deadline tracking, and compliance metrics for data subject requests.
+ */
+export declare const DSRTracker: React__default.FC<DSRTrackerProps>;
+
+export declare interface DSRTrackerClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    stats?: string;
+    statCard?: string;
+    table?: string;
+    tableHeader?: string;
+    tableRow?: string;
+    statusBadge?: string;
+}
+
+declare interface DSRTrackerProps {
+    /**
+     * List of DSR requests to track
+     */
+    requests: DSRRequest[];
+    /**
+     * Callback function called when a request is selected
+     */
+    onSelectRequest?: (requestId: string) => void;
+    /**
+     * Title displayed on the tracker
+     * @default "DSR Request Tracker"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the tracker
+     * @default "Track the status and progress of data subject requests as required by NDPA Part IV."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the tracker
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show the summary statistics
+     * @default true
+     */
+    showSummaryStats?: boolean;
+    /**
+     * Whether to show the request type breakdown
+     * @default true
+     */
+    showTypeBreakdown?: boolean;
+    /**
+     * Whether to show the status breakdown
+     * @default true
+     */
+    showStatusBreakdown?: boolean;
+    /**
+     * Whether to show the timeline chart
+     * @default true
+     */
+    showTimelineChart?: boolean;
+    /**
+     * Whether to show the overdue requests
+     * @default true
+     */
+    showOverdueRequests?: boolean;
+    /**
+     * Object of CSS class overrides keyed by semantic section name.
+     */
+    classNames?: DSRTrackerClassNames;
+    /**
+     * When true, all default Tailwind classes are removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Data Subject Rights types aligned with NDPA 2023 Part IV (Sections 29-36)
+ */
+/**
+ * Types of data subject requests per NDPA Part IV
+ * - 'information': Right to be informed (Section 29)
+ * - 'access': Right of access (Section 30)
+ * - 'rectification': Right to rectification (Section 31)
+ * - 'erasure': Right to erasure (Section 32)
+ * - 'restriction': Right to restrict processing (Section 33)
+ * - 'portability': Right to data portability (Section 34)
+ * - 'objection': Right to object (Section 35)
+ * - 'automated_decision_making': Rights related to automated decision-making (Section 36)
+ */
+export declare type DSRType = 'information' | 'access' | 'rectification' | 'erasure' | 'restriction' | 'portability' | 'objection' | 'automated_decision_making';
+
+export declare type EffortLevel = 'low' | 'medium' | 'high';
+
+/**
+ * Exports the Record of Processing Activities to a CSV string.
+ * The CSV includes all key fields from each processing record.
+ *
+ * @param ropa - The full Record of Processing Activities
+ * @returns CSV-formatted string
+ */
+export declare function exportROPAToCSV(ropa: RecordOfProcessingActivities): string;
+
+/**
+ * Formats a DSR request for display or submission
+ * @param request The DSR request to format
+ * @returns Formatted request data
+ */
+export declare function formatDSRRequest(request: DSRRequest): {
+    formattedRequest: Record<string, unknown>;
+    isValid: boolean;
+    validationErrors: string[];
+};
+
+/**
+ * Generates a summary of all lawful basis documentation across processing activities.
+ *
+ * @param activities Array of processing activities to summarize
+ * @returns LawfulBasisSummary with counts, breakdowns, and flagged activities
+ */
+export declare function generateLawfulBasisSummary(activities: ProcessingActivity[]): LawfulBasisSummary;
+
+/**
+ * Generates policy text by replacing variables in a template with organization-specific values
+ * @param sectionsOrTemplate The policy sections or template string to generate text for
+ * @param organizationInfoOrVariables The organization information or variable map to use for replacement
+ * @returns The generated policy text or an object with the generated text and metadata
+ */
+export declare function generatePolicyText(sectionsOrTemplate: PolicySection[] | string, organizationInfoOrVariables: OrganizationInfo | Record<string, string>): string | {
+    fullText: string;
+    sectionTexts: Record<string, string>;
+    missingVariables: string[];
+};
+
+/**
+ * Generates a summary of the Record of Processing Activities.
+ * Provides statistics and identifies records that are due for review.
+ *
+ * @param ropa - The full Record of Processing Activities
+ * @returns Summary statistics for the ROPA
+ */
+export declare function generateROPASummary(ropa: RecordOfProcessingActivities): ROPASummary;
+
+/**
+ * Retrieves the full consent audit log from localStorage.
+ * Returns an empty array if no log exists or parsing fails.
+ *
+ * @param storageKey - Base storage key (the audit key is derived as `${storageKey}_audit`)
+ */
+export declare function getAuditLog(storageKey?: string): ConsentAuditEntry[];
+
+/**
+ * Evaluate an organisation's NDPA compliance across all modules.
+ *
+ * @param input - Compliance input object
+ * @returns ComplianceReport with overall score, per-module breakdown, and sorted recommendations
+ */
+export declare function getComplianceScore(input: ComplianceInput): ComplianceReport;
+
+/**
+ * Returns a human-readable description of a lawful basis with the relevant
+ * NDPA section reference.
+ *
+ * @param basis The lawful basis to describe
+ * @returns Description string including NDPA section reference
+ */
+export declare function getLawfulBasisDescription(basis: LawfulBasis): string;
+
+/**
+ * Returns a human-readable description of a transfer mechanism with its NDPA section reference.
+ *
+ * @param mechanism The transfer mechanism
+ * @returns Description including the relevant NDPA section
+ */
+export declare function getTransferMechanismDescription(mechanism: TransferMechanism): string;
+
+/**
+ * Identifies compliance gaps in the Record of Processing Activities.
+ * Finds records that are missing required information per NDPA 2023.
+ *
+ * @param ropa - The full Record of Processing Activities
+ * @returns Array of compliance gaps grouped by record
+ */
+export declare function identifyComplianceGaps(ropa: RecordOfProcessingActivities): ROPAComplianceGap[];
+
+/**
+ * Returns whether NDPC approval is required for a given transfer mechanism.
+ * Approval is required for standard contractual clauses (Section 42),
+ * binding corporate rules (Section 43), and specific NDPC authorization (Section 44).
+ *
+ * @param mechanism The transfer mechanism
+ * @returns Whether NDPC approval is required
+ */
+export declare function isNDPCApprovalRequired(mechanism: TransferMechanism): boolean;
+
+/**
+ * Lawful Basis types aligned with NDPA 2023 Part III (Sections 24-28)
+ * Every processing activity must have a documented lawful basis
+ */
+/**
+ * The six lawful bases for processing personal data per NDPA Section 25(1)
+ */
+export declare type LawfulBasis = 'consent' | 'contract' | 'legal_obligation' | 'vital_interests' | 'public_interest' | 'legitimate_interests';
+
+/**
+ * Compliance gap identified across processing activities
+ */
+export declare interface LawfulBasisComplianceGap {
+    activityId: string;
+    activityName: string;
+    type: 'missing_approval' | 'overdue_review' | 'missing_justification' | 'missing_lia' | 'missing_sensitive_condition' | 'missing_retention' | 'missing_data_categories' | 'missing_purposes';
+    severity: 'high' | 'medium' | 'low';
+    description: string;
+}
+
+/**
+ * Summary of all lawful basis documentation for compliance reporting
+ */
+export declare interface LawfulBasisSummary {
+    /** Total number of processing activities */
+    totalActivities: number;
+    /** Breakdown by lawful basis */
+    byBasis: Record<LawfulBasis, number>;
+    /** Number of activities involving sensitive data */
+    sensitiveDataActivities: number;
+    /** Number of activities involving cross-border transfers */
+    crossBorderActivities: number;
+    /** Activities due for review */
+    activitiesDueForReview: ProcessingActivity[];
+    /** Activities without DPO approval */
+    activitiesWithoutApproval: ProcessingActivity[];
+    /** Last updated timestamp */
+    lastUpdated: number;
+}
+
+/**
+ * Lawful basis tracker component. Implements NDPA Section 25 requirements for documenting
+ * and tracking the lawful basis for each personal data processing activity.
+ */
+export declare const LawfulBasisTracker: React__default.FC<LawfulBasisTrackerProps>;
+
+export declare interface LawfulBasisTrackerClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    summary?: string;
+    summaryCard?: string;
+    table?: string;
+    tableHeader?: string;
+    tableRow?: string;
+    form?: string;
+    input?: string;
+    select?: string;
+    submitButton?: string;
+    /** Alias for submitButton */
+    primaryButton?: string;
+    statusBadge?: string;
+    complianceScore?: string;
+    gapAlert?: string;
+}
+
+declare interface LawfulBasisTrackerProps {
+    /**
+     * List of processing activities to display
+     */
+    activities: ProcessingActivity[];
+    /**
+     * Callback when a new activity is created
+     */
+    onAddActivity?: (activity: Omit<ProcessingActivity, 'id' | 'createdAt' | 'updatedAt'>) => void;
+    /**
+     * Callback when an activity is updated
+     */
+    onUpdateActivity?: (id: string, updates: Partial<ProcessingActivity>) => void;
+    /**
+     * Callback when an activity is archived
+     */
+    onArchiveActivity?: (id: string) => void;
+    /**
+     * Title displayed on the tracker
+     * @default "Lawful Basis Tracker"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the tracker
+     * @default "Document and track the lawful basis for each processing activity as required by NDPA 2023 Section 25."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the tracker container
+     */
+    className?: string;
+    /**
+     * Custom CSS class for buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show the compliance summary at the top
+     * @default true
+     */
+    showSummary?: boolean;
+    /**
+     * Whether to show compliance gap alerts
+     * @default true
+     */
+    showComplianceGaps?: boolean;
+    /**
+     * Override class names for individual sections of the component.
+     * Takes priority over className / buttonClassName.
+     */
+    classNames?: LawfulBasisTrackerClassNames;
+    /**
+     * When true, all default styling is removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Lawful basis for processing personal data per NDPA Section 25(1)
+ */
+export declare type LawfulBasisType = 'consent' | 'contract' | 'legal_obligation' | 'vital_interests' | 'public_interest' | 'legitimate_interests';
+
+/**
+ * Validation result for a processing activity
+ */
+export declare interface LawfulBasisValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+/**
+ * Represents a Legitimate Interest Assessment (LIA)
+ * Required when the lawful basis is 'legitimate_interests'
+ */
+export declare interface LegitimateInterestAssessment {
+    /** Unique identifier */
+    id: string;
+    /** ID of the associated processing activity */
+    processingActivityId: string;
+    /** Date the assessment was conducted */
+    assessmentDate: number;
+    /** Person who conducted the assessment */
+    assessor: {
+        name: string;
+        role: string;
+        email: string;
+    };
+    /** Description of the legitimate interest being pursued */
+    purposeTest: string;
+    /** Why the processing is necessary for this purpose */
+    necessityTest: string;
+    /** Balancing test: rights of data subject vs. legitimate interest */
+    balancingTest: string;
+    /** Safeguards applied to protect data subject rights */
+    safeguards: string[];
+    /** Overall conclusion */
+    conclusion: string;
+    /** Whether the assessment concluded the processing is justified */
+    approved: boolean;
+}
+
+export declare interface ModuleScore {
+    /** Module name (e.g. "consent") */
+    name: string;
+    /** Raw module score 0-100 */
+    score: number;
+    /** Maximum possible score for this module (always 100) */
+    maxScore: number;
+    /** Weighted contribution to the overall score */
+    weightedScore: number;
+    /** NDPA sections this module maps to */
+    ndpaSections: string[];
+    /** Gaps found — list of human-readable gap descriptions */
+    gaps: string[];
+}
+
+/**
+ * Configuration for the NDPR toolkit provider.
+ */
+export declare interface NDPRConfig {
+    /** The official name of the organisation */
+    organizationName?: string;
+    /** Email address of the Data Protection Officer */
+    dpoEmail?: string;
+    /** NDPC registration number, if registered */
+    ndpcRegistrationNumber?: string;
+    /** Prefix for localStorage/sessionStorage keys used by toolkit components */
+    storageKeyPrefix?: string;
+    /** When true, removes all default styles from toolkit components */
+    unstyled?: boolean;
+    /** Theme overrides applied as CSS custom properties */
+    theme?: {
+        /** Primary brand colour (e.g. "#0070f3") */
+        primary?: string;
+        /** Hover state for primary colour */
+        primaryHover?: string;
+        /** Foreground colour used on primary backgrounds */
+        primaryForeground?: string;
+    };
+    /**
+     * Locale strings for all toolkit components.
+     * Pass partial overrides — missing keys fall back to English defaults.
+     */
+    locale?: NDPRLocale;
+    /**
+     * Custom fallback UI to render when a child component throws during rendering.
+     * Receives the error and a reset function. If omitted, a default fallback is shown.
+     */
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    /**
+     * Called when the error boundary catches an error.
+     * Useful for sending errors to an external reporting service.
+     */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+
+/**
+ * Read-only compliance dashboard.
+ *
+ * Visualises a `ComplianceReport` (from `getComplianceScore()`) showing the
+ * overall score, per-module cards, and a prioritised recommendations list.
+ */
+export declare const NDPRDashboard: React__default.FC<NDPRDashboardProps>;
+
+export declare interface NDPRDashboardClassNames {
+    root?: string;
+    header?: string;
+    scoreCircle?: string;
+    scoreValue?: string;
+    ratingBadge?: string;
+    modulesGrid?: string;
+    moduleCard?: string;
+    moduleTitle?: string;
+    moduleScore?: string;
+    moduleGaps?: string;
+    recommendationsSection?: string;
+    recommendationItem?: string;
+    recommendationPriority?: string;
+    recommendationTitle?: string;
+    primaryButton?: string;
+    secondaryButton?: string;
+}
+
+export declare interface NDPRDashboardProps {
+    /** Compliance report produced by getComplianceScore() */
+    report: ComplianceReport;
+    /** Dashboard heading. Defaults to "NDPA Compliance Dashboard" */
+    title?: string;
+    /** Show/hide the recommendations section. Defaults to true */
+    showRecommendations?: boolean;
+    /** Maximum number of recommendations to render. Defaults to 5 */
+    maxRecommendations?: number;
+    /** Per-section class name overrides */
+    classNames?: NDPRDashboardClassNames;
+    /** When true, strips all default classes so consumers can style from scratch */
+    unstyled?: boolean;
+}
+
+/**
+ * Locale strings for all toolkit components.
+ * Pass partial overrides — missing keys fall back to English defaults.
+ */
+declare interface NDPRLocale {
+    consent?: {
+        title?: string;
+        description?: string;
+        acceptAll?: string;
+        rejectAll?: string;
+        customize?: string;
+        savePreferences?: string;
+        selectAll?: string;
+        deselectAll?: string;
+        required?: string;
+        cookieNotice?: string;
+    };
+    dsr?: {
+        title?: string;
+        description?: string;
+        submitRequest?: string;
+        reset?: string;
+        fullName?: string;
+        email?: string;
+        phone?: string;
+        requestType?: string;
+        additionalInfo?: string;
+        identityVerification?: string;
+        identifierType?: string;
+        identifierValue?: string;
+        privacyNotice?: string;
+        successMessage?: string;
+    };
+    breach?: {
+        title?: string;
+        description?: string;
+        submitReport?: string;
+        breachTitle?: string;
+        category?: string;
+        discoveredAt?: string;
+        detailedDescription?: string;
+    };
+    dpia?: {
+        title?: string;
+        next?: string;
+        previous?: string;
+        complete?: string;
+        progress?: string;
+    };
+    policy?: {
+        title?: string;
+        generate?: string;
+        preview?: string;
+        export?: string;
+        sections?: string;
+        variables?: string;
+    };
+    compliance?: {
+        score?: string;
+        excellent?: string;
+        good?: string;
+        needsWork?: string;
+        critical?: string;
+        recommendations?: string;
+        passed?: string;
+        gaps?: string;
+    };
+    common?: {
+        loading?: string;
+        error?: string;
+        save?: string;
+        cancel?: string;
+        delete?: string;
+        edit?: string;
+        add?: string;
+        back?: string;
+        next?: string;
+        search?: string;
+        noResults?: string;
+    };
+}
+
+/**
+ * Provides NDPR configuration to all descendant toolkit components.
+ *
+ * When a `theme` is supplied, the corresponding CSS custom properties
+ * (`--ndpr-primary`, `--ndpr-primary-hover`, `--ndpr-primary-foreground`)
+ * are set on the wrapping element so components can reference them.
+ *
+ * Wraps children in an error boundary so that a rendering failure in any
+ * toolkit component does not crash the host application.
+ */
+export declare const NDPRProvider: React__default.FC<NDPRConfig & {
+    children: React__default.ReactNode;
+}>;
+
+/**
+ * Represents notification requirements for a data breach per NDPA Section 40
+ */
+export declare interface NotificationRequirement {
+    /**
+     * Whether NDPC notification is required
+     * Per NDPA Section 40, notification to NDPC is required for all breaches
+     * that pose a risk to data subjects' rights and freedoms
+     */
+    ndpcNotificationRequired: boolean;
+    /**
+     * Deadline for NDPC notification (72 hours from discovery)
+     * NDPA Section 40(1)
+     */
+    ndpcNotificationDeadline: number;
+    /**
+     * Whether data subject notification is required
+     * Per NDPA Section 40(4), required when breach is likely to result in
+     * high risk to rights and freedoms of data subjects
+     */
+    dataSubjectNotificationRequired: boolean;
+    /** Justification for the notification decision */
+    justification: string;
+    /**
+     * @deprecated Use ndpcNotificationRequired instead. Kept for backward compatibility.
+     */
+    nitdaNotificationRequired?: boolean;
+    /**
+     * @deprecated Use ndpcNotificationDeadline instead. Kept for backward compatibility.
+     */
+    nitdaNotificationDeadline?: number;
+}
+
+/**
+ * Represents organization information for a privacy policy
+ */
+export declare interface OrganizationInfo {
+    /** Name of the organization */
+    name: string;
+    /** Website URL of the organization */
+    website: string;
+    /** Contact email for privacy inquiries */
+    privacyEmail: string;
+    /** Physical address of the organization */
+    address?: string;
+    /** Phone number for privacy inquiries */
+    privacyPhone?: string;
+    /** Name of the Data Protection Officer */
+    dpoName?: string;
+    /** Email of the Data Protection Officer */
+    dpoEmail?: string;
+    /** Industry or sector of the organization */
+    industry?: string;
+    /** NDPC registration number (if registered) */
+    ndpcRegistrationNumber?: string;
+}
+
+declare interface OrganizationInfo_2 {
+    /**
+     * Name of the organization
+     */
+    name: string;
+    /**
+     * Registration number or business ID
+     */
+    registrationNumber?: string;
+    /**
+     * Physical address of the organization
+     */
+    address: string;
+    /**
+     * Website URL
+     */
+    website?: string;
+    /**
+     * Name of the Data Protection Officer
+     */
+    dpoName: string;
+    /**
+     * Email of the Data Protection Officer
+     */
+    dpoEmail: string;
+    /**
+     * Phone number of the Data Protection Officer
+     */
+    dpoPhone?: string;
+}
+
+export declare const PolicyExporter: React__default.FC<PolicyExporterProps>;
+
+export declare interface PolicyExporterClassNames {
+    /** Root container */
+    root?: string;
+    /** Header area containing title and description */
+    header?: string;
+    /** Title element */
+    title?: string;
+    /** Description element */
+    description?: string;
+    /** Format selector container */
+    formatSelector?: string;
+    /** Individual format option */
+    formatOption?: string;
+    /** Export button */
+    exportButton?: string;
+    /** Alias for exportButton */
+    primaryButton?: string;
+    /** NDPA compliance / export tips notice */
+    complianceNotice?: string;
+    /** Preview / export history area */
+    preview?: string;
+}
+
+declare interface PolicyExporterProps {
+    /**
+     * The policy content to export
+     */
+    content: string;
+    /**
+     * The policy title
+     */
+    title?: string;
+    /**
+     * The organization name to include in the exported policy
+     */
+    organizationName?: string;
+    /**
+     * The last updated date to include in the exported policy
+     */
+    lastUpdated?: Date;
+    /**
+     * Callback function called when the export is complete
+     */
+    onExportComplete?: (format: string, url: string) => void;
+    /**
+     * Title displayed on the exporter
+     * @default "Export Privacy Policy"
+     */
+    componentTitle?: string;
+    /**
+     * Description text displayed on the exporter
+     * @default "Export your NDPA-compliant privacy policy in various formats."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the exporter
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show the export history
+     * @default true
+     */
+    showExportHistory?: boolean;
+    /**
+     * Whether to include the NDPA compliance notice in the exported policy
+     * @default true
+     */
+    includeComplianceNotice?: boolean;
+    /**
+     * Whether to include the organization logo in the exported policy
+     * @default false
+     */
+    includeLogo?: boolean;
+    /**
+     * URL of the organization logo
+     */
+    logoUrl?: string;
+    /**
+     * Custom CSS styles for the exported policy
+     */
+    customStyles?: string;
+    /**
+     * Override class names for internal elements
+     */
+    classNames?: PolicyExporterClassNames;
+    /**
+     * If true, removes all default styles. Use with classNames to apply your own.
+     * @default false
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Privacy policy generator component. Implements NDPA Section 24 transparency requirements,
+ * helping organizations generate compliant privacy policies that disclose required information.
+ */
+export declare const PolicyGenerator: React__default.FC<PolicyGeneratorProps>;
+
+export declare interface PolicyGeneratorClassNames {
+    /** Root container */
+    root?: string;
+    /** Header area containing title and description */
+    header?: string;
+    /** Title element */
+    title?: string;
+    /** Description element */
+    description?: string;
+    /** Section list container */
+    sectionList?: string;
+    /** Individual section item */
+    sectionItem?: string;
+    /** Variable form container */
+    form?: string;
+    /** Form input fields */
+    input?: string;
+    /** Generate button */
+    generateButton?: string;
+    /** Alias for generateButton */
+    primaryButton?: string;
+    /** NDPA compliance notice */
+    complianceNotice?: string;
+}
+
+declare interface PolicyGeneratorProps {
+    /**
+     * List of policy sections
+     * @default DEFAULT_POLICY_SECTIONS
+     */
+    sections?: PolicySection[];
+    /**
+     * List of policy variables
+     * @default DEFAULT_POLICY_VARIABLES
+     */
+    variables?: PolicyVariable[];
+    /**
+     * Callback function called when the policy is generated
+     */
+    onGenerate: (policy: {
+        sections: PolicySection[];
+        variables: PolicyVariable[];
+        content: string;
+    }) => void;
+    /**
+     * Title displayed on the generator
+     * @default "NDPA Privacy Policy Generator"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the generator
+     * @default "Generate an NDPA-compliant privacy policy for your organization in accordance with NDPA Section 24."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the generator
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Text for the generate button
+     * @default "Generate Policy"
+     */
+    generateButtonText?: string;
+    /**
+     * Whether to show a preview of the generated policy
+     * @default true
+     */
+    showPreview?: boolean;
+    /**
+     * Whether to allow editing the policy content
+     * @default true
+     */
+    allowEditing?: boolean;
+    /**
+     * Override class names for internal elements
+     */
+    classNames?: PolicyGeneratorClassNames;
+    /**
+     * If true, removes all default styles. Use with classNames to apply your own.
+     * @default false
+     */
+    unstyled?: boolean;
+}
+
+export declare const PolicyPreview: React__default.FC<PolicyPreviewProps>;
+
+export declare interface PolicyPreviewClassNames {
+    /** Root container */
+    root?: string;
+    /** Header area containing title and description */
+    header?: string;
+    /** Title element */
+    title?: string;
+    /** Description element */
+    description?: string;
+    /** Content area wrapping the rendered policy */
+    content?: string;
+    /** Individual rendered section container */
+    section?: string;
+    /** Section title within rendered content */
+    sectionTitle?: string;
+    /** Section content within rendered content */
+    sectionContent?: string;
+    /** NDPA compliance notice */
+    complianceNotice?: string;
+}
+
+declare interface PolicyPreviewProps {
+    /**
+     * The policy content to preview
+     */
+    content: string;
+    /**
+     * The policy sections
+     */
+    sections?: PolicySection[];
+    /**
+     * The policy variables
+     */
+    variables?: PolicyVariable[];
+    /**
+     * Callback function called when the policy is exported
+     */
+    onExport?: (format: 'pdf' | 'html' | 'markdown' | 'docx') => void;
+    /**
+     * Callback function called when the policy is edited
+     */
+    onEdit?: () => void;
+    /**
+     * Title displayed on the preview
+     * @default "Privacy Policy Preview"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the preview
+     * @default "Preview your NDPA-compliant privacy policy before exporting."
+     */
+    description?: string;
+    /**
+     * Custom CSS class for the preview
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Whether to show the export options
+     * @default true
+     */
+    showExportOptions?: boolean;
+    /**
+     * Whether to show the edit button
+     * @default true
+     */
+    showEditButton?: boolean;
+    /**
+     * Whether to show the table of contents
+     * @default true
+     */
+    showTableOfContents?: boolean;
+    /**
+     * Whether to show the policy metadata
+     * @default true
+     */
+    showMetadata?: boolean;
+    /**
+     * The organization name to display in the policy
+     */
+    organizationName?: string;
+    /**
+     * The last updated date to display in the policy
+     */
+    lastUpdated?: Date;
+    /**
+     * Override class names for internal elements
+     */
+    classNames?: PolicyPreviewClassNames;
+    /**
+     * If true, removes all default styles. Use with classNames to apply your own.
+     * @default false
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Privacy policy types aligned with NDPA 2023
+ * Privacy policies must clearly inform data subjects of their rights under the NDPA
+ */
+/**
+ * Represents a section in a privacy policy
+ */
+export declare interface PolicySection {
+    /** Unique identifier for the section */
+    id: string;
+    /** Title of the section */
+    title: string;
+    /** Description of the section */
+    description?: string;
+    /** Order of the section in the policy */
+    order?: number;
+    /** Whether the section is required by NDPA */
+    required: boolean;
+    /** Template text for the section */
+    template: string;
+    /**
+     * Default content for the section (legacy field)
+     * @deprecated Use template instead
+     */
+    defaultContent?: string;
+    /**
+     * Custom content for the section (overrides default content)
+     * @deprecated Use template instead
+     */
+    customContent?: string;
+    /** Whether the section is included in the policy */
+    included: boolean;
+    /** Variables that can be used in the section content */
+    variables?: string[];
+}
+
+/**
+ * Represents a privacy policy template
+ */
+export declare interface PolicyTemplate {
+    /** Unique identifier for the template */
+    id: string;
+    /** Name of the template */
+    name: string;
+    /** Description of the template */
+    description: string;
+    /** Type of organization the template is designed for */
+    organizationType: 'business' | 'nonprofit' | 'government' | 'educational';
+    /** Sections included in the template */
+    sections: PolicySection[];
+    /** Variables used across the template */
+    variables: Record<string, {
+        name: string;
+        description: string;
+        required: boolean;
+        defaultValue?: string;
+    }>;
+    /** Version of the template */
+    version: string;
+    /** Last updated date of the template */
+    lastUpdated: number;
+    /**
+     * Whether this template is NDPA 2023 compliant
+     */
+    ndpaCompliant: boolean;
+}
+
+/**
+ * Represents a variable in a privacy policy
+ */
+export declare interface PolicyVariable {
+    /** Unique identifier for the variable */
+    id: string;
+    /** Name of the variable as it appears in the template */
+    name: string;
+    /** Description of the variable */
+    description: string;
+    /** Default value for the variable */
+    defaultValue?: string;
+    /** Current value of the variable */
+    value: string;
+    /** Type of input for the variable */
+    inputType: 'text' | 'textarea' | 'email' | 'url' | 'date' | 'select';
+    /** Options for select inputs */
+    options?: string[];
+    /** Whether the variable is required */
+    required: boolean;
+}
+
+/**
+ * Represents a generated privacy policy
+ */
+export declare interface PrivacyPolicy {
+    /** Unique identifier for the policy */
+    id: string;
+    /** Title of the policy */
+    title: string;
+    /** Template used to generate the policy */
+    templateId: string;
+    /** Organization information */
+    organizationInfo: OrganizationInfo;
+    /** Sections of the policy */
+    sections: PolicySection[];
+    /** Values for the variables used in the policy */
+    variableValues: Record<string, string>;
+    /** Effective date of the policy */
+    effectiveDate: number;
+    /** Last updated date of the policy */
+    lastUpdated: number;
+    /** Version of the policy */
+    version: string;
+    /**
+     * Applicable legal frameworks
+     */
+    applicableFrameworks?: ('ndpa' | 'ndpr' | 'gdpr' | 'ccpa')[];
+}
+
+/**
+ * Represents a processing activity and its lawful basis
+ */
+export declare interface ProcessingActivity {
+    /** Unique identifier */
+    id: string;
+    /** Name of the processing activity */
+    name: string;
+    /** Description of what processing is performed */
+    description: string;
+    /** The lawful basis for this processing activity */
+    lawfulBasis: LawfulBasis;
+    /** Justification for why this lawful basis applies */
+    lawfulBasisJustification: string;
+    /** Categories of personal data being processed */
+    dataCategories: string[];
+    /** Whether sensitive personal data is involved */
+    involvesSensitiveData: boolean;
+    /** Condition for processing sensitive data (required if involvesSensitiveData is true) */
+    sensitiveDataCondition?: SensitiveDataCondition;
+    /** Categories of data subjects */
+    dataSubjectCategories: string[];
+    /** Purposes of the processing */
+    purposes: string[];
+    /** Data retention period */
+    retentionPeriod: string;
+    /** Justification for the retention period */
+    retentionJustification?: string;
+    /** Recipients or categories of recipients */
+    recipients?: string[];
+    /** Whether data is transferred outside Nigeria */
+    crossBorderTransfer: boolean;
+    /** Timestamp when the record was created */
+    createdAt: number;
+    /** Timestamp when the record was last updated */
+    updatedAt: number;
+    /** Next review date */
+    reviewDate?: number;
+    /** Status of the processing activity */
+    status: 'active' | 'inactive' | 'under_review' | 'archived';
+    /** DPO approval details */
+    dpoApproval?: {
+        approved: boolean;
+        approvedBy: string;
+        approvedAt: number;
+        notes?: string;
+    };
+}
+
+/**
+ * Record of Processing Activities (ROPA) types aligned with NDPA 2023
+ * Data controllers must maintain comprehensive records of all processing activities
+ */
+
+/**
+ * Represents a single processing record in the ROPA
+ */
+export declare interface ProcessingRecord {
+    /** Unique identifier */
+    id: string;
+    /** Name of the processing activity */
+    name: string;
+    /** Detailed description of the processing */
+    description: string;
+    /** Data controller details */
+    controllerDetails: {
+        name: string;
+        contact: string;
+        address: string;
+        registrationNumber?: string;
+        dpoContact?: string;
+    };
+    /** Joint controller details (if applicable) */
+    jointControllerDetails?: {
+        name: string;
+        contact: string;
+        address: string;
+        responsibilities: string;
+    };
+    /** Data processor details (if processing is outsourced) */
+    processorDetails?: {
+        name: string;
+        contact: string;
+        address: string;
+        contractReference?: string;
+    };
+    /** Lawful basis for the processing */
+    lawfulBasis: LawfulBasis;
+    /** Justification for the chosen lawful basis */
+    lawfulBasisJustification: string;
+    /** Purposes of the processing */
+    purposes: string[];
+    /** Categories of personal data processed */
+    dataCategories: string[];
+    /** Categories of sensitive personal data (if any) */
+    sensitiveDataCategories?: string[];
+    /** Categories of data subjects */
+    dataSubjectCategories: string[];
+    /** Recipients or categories of recipients */
+    recipients: string[];
+    /** Cross-border transfer details */
+    crossBorderTransfers?: Array<{
+        destinationCountry: string;
+        countryCode?: string;
+        safeguards: string;
+        transferMechanism: string;
+    }>;
+    /** Data retention period */
+    retentionPeriod: string;
+    /** Justification for the retention period */
+    retentionJustification?: string;
+    /** Technical and organizational security measures */
+    securityMeasures: string[];
+    /** Data source (directly from data subject or from third party) */
+    dataSource: 'data_subject' | 'third_party' | 'public_source' | 'other';
+    /** Third-party source details (if dataSource is 'third_party') */
+    thirdPartySourceDetails?: string;
+    /** Whether a DPIA is required for this processing */
+    dpiaRequired: boolean;
+    /** Reference to the DPIA (if conducted) */
+    dpiaReference?: string;
+    /** Whether automated decision-making is involved */
+    automatedDecisionMaking: boolean;
+    /** Details of automated decision-making (if applicable) */
+    automatedDecisionMakingDetails?: string;
+    /** Status of the processing record */
+    status: 'active' | 'inactive' | 'archived';
+    /** Department or business unit responsible */
+    department?: string;
+    /** System or application used for processing */
+    systemsUsed?: string[];
+    /** Timestamp when the record was created */
+    createdAt: number;
+    /** Timestamp when the record was last updated */
+    updatedAt: number;
+    /** Timestamp when the record was last reviewed */
+    lastReviewedAt?: number;
+    /** Next review date */
+    nextReviewDate?: number;
+}
+
+export declare interface Recommendation {
+    module: string;
+    key: string;
+    label: string;
+    priority: RecommendationPriority;
+    effort: EffortLevel;
+    recommendation: string;
+    ndpaSection: string;
+}
+
+export declare type RecommendationPriority = 'critical' | 'high' | 'medium' | 'low';
+
+/**
+ * Represents a complete Record of Processing Activities
+ */
+export declare interface RecordOfProcessingActivities {
+    /** Unique identifier */
+    id: string;
+    /** Organization name */
+    organizationName: string;
+    /** Organization contact information */
+    organizationContact: string;
+    /** Organization address */
+    organizationAddress: string;
+    /** Data Protection Officer details */
+    dpoDetails?: {
+        name: string;
+        email: string;
+        phone?: string;
+    };
+    /** NDPC registration number */
+    ndpcRegistrationNumber?: string;
+    /** All processing records */
+    records: ProcessingRecord[];
+    /** Timestamp when the ROPA was last updated */
+    lastUpdated: number;
+    /** Version of the ROPA */
+    version: string;
+    /** Export format options */
+    exportFormats?: ('pdf' | 'csv' | 'json' | 'xlsx')[];
+}
+
+/**
+ * Represents a notification sent to the NDPC (Nigeria Data Protection Commission)
+ */
+export declare interface RegulatoryNotification {
+    /** Unique identifier for the notification */
+    id: string;
+    /** ID of the breach this notification is for */
+    breachId: string;
+    /** Timestamp when the notification was sent */
+    sentAt: number;
+    /** Method used to send the notification */
+    method: 'email' | 'portal' | 'letter' | 'other';
+    /** Reference number assigned by the NDPC (if available) */
+    referenceNumber?: string;
+    /** Contact person at the NDPC */
+    ndpcContact?: {
+        name: string;
+        email: string;
+        phone?: string;
+    };
+    /** Content of the notification */
+    content: string;
+    /** Attachments included with the notification */
+    attachments?: Array<{
+        id: string;
+        name: string;
+        type: string;
+        url: string;
+    }>;
+    /** Follow-up communications with the NDPC */
+    followUps?: Array<{
+        timestamp: number;
+        direction: 'sent' | 'received';
+        content: string;
+        attachments?: Array<{
+            id: string;
+            name: string;
+            type: string;
+            url: string;
+        }>;
+    }>;
+    /**
+     * @deprecated Use ndpcContact instead. Kept for backward compatibility.
+     */
+    nitdaContact?: {
+        name: string;
+        email: string;
+        phone?: string;
+    };
+}
+
+export declare interface RegulatoryReference {
+    section: string;
+    title: string;
+    url?: string;
+}
+
+/**
+ * Regulatory report generator component. Implements NDPA Section 40 requirements for
+ * generating formal breach notification reports for submission to the NDPC.
+ */
+export declare const RegulatoryReportGenerator: React__default.FC<RegulatoryReportGeneratorProps>;
+
+export declare interface RegulatoryReportGeneratorClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    reportPreview?: string;
+    field?: string;
+    fieldLabel?: string;
+    fieldValue?: string;
+    generateButton?: string;
+    /** Alias for generateButton */
+    primaryButton?: string;
+    downloadButton?: string;
+    /** Alias for downloadButton */
+    secondaryButton?: string;
+}
+
+declare interface RegulatoryReportGeneratorProps {
+    /**
+     * The breach data to include in the report
+     */
+    breachData: BreachReport;
+    /**
+     * The risk assessment data
+     */
+    assessmentData?: RiskAssessment;
+    /**
+     * Organization information to include in the report
+     */
+    organizationInfo: OrganizationInfo_2;
+    /**
+     * Callback function called when the report is generated
+     */
+    onGenerate: (report: RegulatoryNotification) => void;
+    /**
+     * Title displayed on the generator form
+     * @default "Generate NDPC Notification Report"
+     */
+    title?: string;
+    /**
+     * Description text displayed on the generator form
+     * @default "Generate a report for submission to the NDPC in compliance with NDPA Section 40 breach notification requirements."
+     */
+    description?: string;
+    /**
+     * Text for the generate button
+     * @default "Generate Report"
+     */
+    generateButtonText?: string;
+    /**
+     * Custom CSS class for the form
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Override class names for individual elements
+     */
+    classNames?: RegulatoryReportGeneratorClassNames;
+    /**
+     * Remove all default styles, only applying classNames overrides
+     */
+    unstyled?: boolean;
+    /**
+     * Whether to show a preview of the generated report
+     * @default true
+     */
+    showPreview?: boolean;
+    /**
+     * Whether to allow editing the report content
+     * @default true
+     */
+    allowEditing?: boolean;
+    /**
+     * Whether to allow downloading the report
+     * @default true
+     */
+    allowDownload?: boolean;
+    /**
+     * Format for downloading the report
+     * @default "pdf"
+     */
+    downloadFormat?: 'pdf' | 'docx' | 'html';
+}
+
+/**
+ * Legacy status of a data subject request
+ * @deprecated Use DSRStatus instead
+ */
+export declare type RequestStatus = 'pending' | 'verifying' | 'processing' | 'completed' | 'rejected';
+
+/**
+ * Represents a type of data subject request (detailed configuration)
+ */
+export declare interface RequestType {
+    /** Unique identifier for the request type */
+    id: string;
+    /** Display name for the request type */
+    name: string;
+    /** Description of what this request type entails */
+    description: string;
+    /**
+     * NDPA section reference (e.g., "Section 30" for access requests)
+     */
+    ndpaSection?: string;
+    /**
+     * Estimated time to fulfill this type of request (in days)
+     * NDPA requires response within 30 days
+     */
+    estimatedCompletionTime: number;
+    /** Whether additional information is required for this request type */
+    requiresAdditionalInfo: boolean;
+    /** Custom fields required for this request type */
+    additionalFields?: Array<{
+        id: string;
+        label: string;
+        type: 'text' | 'textarea' | 'select' | 'checkbox' | 'file';
+        options?: string[];
+        required: boolean;
+        placeholder?: string;
+    }>;
+}
+
+/**
+ * Resolves class names for a component section.
+ * If unstyled is true, only the override class is used (or empty string).
+ * If an override is provided, it fully REPLACES the default — no appending.
+ * Otherwise the default class string is returned as-is.
+ */
+export declare function resolveClass(defaultClass: string, override?: string, unstyled?: boolean): string;
+
+/**
+ * Represents a risk assessment for a data breach
+ */
+export declare interface RiskAssessment {
+    /** Unique identifier for the risk assessment */
+    id: string;
+    /** ID of the breach this assessment is for */
+    breachId: string;
+    /** Timestamp when the assessment was conducted */
+    assessedAt: number;
+    /** Person who conducted the assessment */
+    assessor: {
+        name: string;
+        role: string;
+        email: string;
+    };
+    /** Confidentiality impact (1-5) */
+    confidentialityImpact: number;
+    /** Integrity impact (1-5) */
+    integrityImpact: number;
+    /** Availability impact (1-5) */
+    availabilityImpact: number;
+    /** Likelihood of harm to data subjects (1-5) */
+    harmLikelihood: number;
+    /** Severity of potential harm to data subjects (1-5) */
+    harmSeverity: number;
+    /** Overall risk score */
+    overallRiskScore: number;
+    /** Risk level based on the overall score */
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    /** Whether the breach is likely to result in a risk to rights and freedoms */
+    risksToRightsAndFreedoms: boolean;
+    /** Whether the breach is likely to result in a high risk to rights and freedoms */
+    highRisksToRightsAndFreedoms: boolean;
+    /** Justification for the risk assessment */
+    justification: string;
+}
+
+/**
+ * Compliance gap found in a processing record
+ */
+export declare interface ROPAComplianceGap {
+    recordId: string;
+    recordName: string;
+    gaps: string[];
+}
+
+/**
+ * Record of Processing Activities (ROPA) management component. Implements the NDPA
+ * accountability principle, requiring organizations to maintain comprehensive records
+ * of all personal data processing activities.
+ */
+export declare const ROPAManager: React__default.FC<ROPAManagerProps>;
+
+export declare interface ROPAManagerClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    orgInfo?: string;
+    summary?: string;
+    summaryCard?: string;
+    table?: string;
+    tableHeader?: string;
+    tableRow?: string;
+    form?: string;
+    input?: string;
+    select?: string;
+    submitButton?: string;
+    /** Alias for submitButton */
+    primaryButton?: string;
+    statusBadge?: string;
+    exportButton?: string;
+    /** Alias for exportButton */
+    secondaryButton?: string;
+    complianceGap?: string;
+}
+
+declare interface ROPAManagerProps {
+    /**
+     * The full Record of Processing Activities
+     */
+    ropa: RecordOfProcessingActivities;
+    /**
+     * Callback when a new record is added
+     */
+    onAddRecord?: (record: ProcessingRecord) => void;
+    /**
+     * Callback when a record is updated
+     */
+    onUpdateRecord?: (id: string, updates: Partial<ProcessingRecord>) => void;
+    /**
+     * Callback when a record is archived
+     */
+    onArchiveRecord?: (id: string) => void;
+    /**
+     * Title displayed on the manager
+     * @default "Record of Processing Activities (ROPA)"
+     */
+    title?: string;
+    /**
+     * Description text
+     * @default "Maintain a comprehensive record of all data processing activities as required by the NDPA accountability principle."
+     */
+    description?: string;
+    /**
+     * Custom CSS class
+     */
+    className?: string;
+    /**
+     * Custom CSS class for buttons
+     */
+    buttonClassName?: string;
+    /**
+     * Override class names for individual sections of the component.
+     * Takes priority over className / buttonClassName.
+     */
+    classNames?: ROPAManagerClassNames;
+    /**
+     * When true, all default styling is removed so consumers
+     * can style from scratch using classNames.
+     */
+    unstyled?: boolean;
+}
+
+/**
+ * Summary statistics for the ROPA
+ */
+export declare interface ROPASummary {
+    /** Total number of processing records */
+    totalRecords: number;
+    /** Active processing records */
+    activeRecords: number;
+    /** Records by lawful basis */
+    byLawfulBasis: Record<LawfulBasis, number>;
+    /** Records involving sensitive data */
+    sensitiveDataRecords: number;
+    /** Records involving cross-border transfers */
+    crossBorderRecords: number;
+    /** Records requiring DPIA */
+    dpiaRequiredRecords: number;
+    /** Records involving automated decision-making */
+    automatedDecisionRecords: number;
+    /** Records due for review */
+    recordsDueForReview: ProcessingRecord[];
+    /** Departments with most processing activities */
+    topDepartments: Array<{
+        department: string;
+        count: number;
+    }>;
+    /** Last updated timestamp */
+    lastUpdated: number;
+}
+
+/**
+ * Validation result for a processing record
+ */
+export declare interface ROPAValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+
+/**
+ * Sanitizes user input to prevent XSS attacks.
+ * Escapes HTML special characters so that data rendered in dashboards
+ * or other consumer UIs cannot execute embedded scripts.
+ */
+export declare function sanitizeInput(input: string): string;
+
+/**
+ * Additional conditions required for processing sensitive personal data
+ * per NDPA Section 27
+ */
+export declare type SensitiveDataCondition = 'explicit_consent' | 'employment_law' | 'vital_interests_incapable' | 'nonprofit_legitimate' | 'publicly_available' | 'legal_claims' | 'substantial_public_interest' | 'health_purposes' | 'public_health' | 'archiving_research';
+
+declare interface Step {
+    /**
+     * Unique identifier for the step
+     */
+    id: string;
+    /**
+     * Display label for the step
+     */
+    label: string;
+    /**
+     * Optional description for the step
+     */
+    description?: string;
+    /**
+     * Whether the step is completed
+     */
+    completed: boolean;
+    /**
+     * Whether the step is the current active step
+     */
+    active: boolean;
+    /**
+     * Optional icon for the step
+     */
+    icon?: React__default.ReactNode;
+}
+
+export declare const StepIndicator: React__default.FC<StepIndicatorProps>;
+
+export declare interface StepIndicatorClassNames {
+    /** Outermost wrapper */
+    root?: string;
+    /** Individual step wrapper */
+    step?: string;
+    /** Active step circle / indicator */
+    stepActive?: string;
+    /** Completed step circle / indicator */
+    stepCompleted?: string;
+    /** Pending (incomplete, inactive) step circle / indicator */
+    stepPending?: string;
+    /** Connector line between steps */
+    connector?: string;
+    /** Step label text */
+    label?: string;
+}
+
+declare interface StepIndicatorProps {
+    /**
+     * Array of steps to display
+     */
+    steps: Step[];
+    /**
+     * Callback function called when a step is clicked
+     */
+    onStepClick?: (stepId: string) => void;
+    /**
+     * Whether the steps are clickable
+     * @default true
+     */
+    clickable?: boolean;
+    /**
+     * Orientation of the step indicator
+     * @default "horizontal"
+     */
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Custom CSS class for the container
+     */
+    className?: string;
+    /**
+     * Custom CSS class for the active step
+     */
+    activeStepClassName?: string;
+    /**
+     * Custom CSS class for completed steps
+     */
+    completedStepClassName?: string;
+    /**
+     * Custom CSS class for incomplete steps
+     */
+    incompleteStepClassName?: string;
+    /**
+     * Per-section class name overrides
+     */
+    classNames?: StepIndicatorClassNames;
+    /**
+     * When true, all default classes are stripped.
+     * Only explicit overrides from `classNames` are applied.
+     * @default false
+     */
+    unstyled?: boolean;
+}
+
+declare interface StorageAdapter<T = unknown> {
+    /** Load persisted data. Called once on hook mount. */
+    load(): T | null | Promise<T | null>;
+    /** Persist data. Called on every state change. */
+    save(data: T): void | Promise<void>;
+    /** Clear persisted data. Called on reset. */
+    remove(): void | Promise<void>;
+}
+
+/**
+ * Transfer Impact Assessment (TIA) for cross-border transfers
+ */
+export declare interface TransferImpactAssessment {
+    /** Unique identifier */
+    id: string;
+    /** ID of the associated cross-border transfer */
+    transferId: string;
+    /** Date the assessment was conducted */
+    assessmentDate: number;
+    /** Person who conducted the assessment */
+    assessor: {
+        name: string;
+        role: string;
+        email: string;
+    };
+    /** Analysis of the destination country's legal framework */
+    destinationLegalFramework: string;
+    /** Whether the destination has data protection legislation */
+    hasDataProtectionLaw: boolean;
+    /** Whether the destination has an independent supervisory authority */
+    hasIndependentAuthority: boolean;
+    /** Risk of government access to the data */
+    governmentAccessRisk: 'low' | 'medium' | 'high';
+    /** Overall assessment of data protection level */
+    dataProtectionLevel: 'adequate' | 'partially_adequate' | 'inadequate';
+    /** Supplementary measures to address gaps */
+    supplementaryMeasures: string[];
+    /** Technical measures (encryption, pseudonymization, etc.) */
+    technicalMeasures: string[];
+    /** Contractual measures */
+    contractualMeasures: string[];
+    /** Organizational measures */
+    organizationalMeasures: string[];
+    /** Overall conclusion */
+    conclusion: string;
+    /** Whether the transfer can proceed based on the assessment */
+    approved: boolean;
+    /** Conditions for the transfer (if approved with conditions) */
+    conditions?: string[];
+}
+
+/**
+ * Cross-Border Data Transfer types aligned with NDPA 2023 Part VI (Sections 41-45)
+ * Personal data may only be transferred outside Nigeria under specific conditions
+ */
+/**
+ * Transfer mechanisms recognized under the NDPA
+ */
+export declare type TransferMechanism = 'adequacy_decision' | 'standard_clauses' | 'binding_corporate_rules' | 'ndpc_authorization' | 'explicit_consent' | 'contract_performance' | 'public_interest' | 'legal_claims' | 'vital_interests';
+
+/**
+ * Risk assessment result for a cross-border transfer
+ */
+export declare interface TransferRiskResult {
+    riskLevel: 'low' | 'medium' | 'high';
+    riskScore: number;
+    factors: string[];
+    recommendations: string[];
+}
+
+/**
+ * Validation result for a cross-border transfer
+ */
+export declare interface TransferValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+/**
+ * Hook for managing data breach notifications in compliance with the NDPA (Section 40)
+ */
+export declare function useBreach({ categories, initialReports, adapter, storageKey, useLocalStorage, onReport, onAssessment, onNotification, }: UseBreachOptions): UseBreachReturn;
+
+declare interface UseBreachOptions {
+    /**
+     * Available breach categories
+     */
+    categories: BreachCategory[];
+    /**
+     * Initial breach reports
+     */
+    initialReports?: BreachReport[];
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over storageKey/useLocalStorage.
+     */
+    adapter?: StorageAdapter<BreachCompositeState>;
+    /**
+     * Storage key for breach data
+     * @default "ndpr_breach_data"
+     * @deprecated Use adapter instead
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist breach data
+     * @default true
+     * @deprecated Use adapter instead
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when a breach is reported
+     */
+    onReport?: (report: BreachReport) => void;
+    /**
+     * Callback function called when a risk assessment is completed
+     */
+    onAssessment?: (assessment: RiskAssessment) => void;
+    /**
+     * Callback function called when a notification is sent
+     */
+    onNotification?: (notification: RegulatoryNotification) => void;
+}
+
+declare interface UseBreachReturn {
+    /**
+     * All breach reports
+     */
+    reports: BreachReport[];
+    /**
+     * All risk assessments
+     */
+    assessments: RiskAssessment[];
+    /**
+     * All regulatory notifications
+     */
+    notifications: RegulatoryNotification[];
+    /**
+     * Submit a new breach report
+     */
+    reportBreach: (reportData: Omit<BreachReport, 'id' | 'reportedAt'>) => BreachReport;
+    /**
+     * Update an existing breach report
+     */
+    updateReport: (id: string, updates: Partial<BreachReport>) => BreachReport | null;
+    /**
+     * Get a breach report by ID
+     */
+    getReport: (id: string) => BreachReport | null;
+    /**
+     * Conduct a risk assessment for a breach
+     */
+    assessRisk: (breachId: string, assessmentData: Omit<RiskAssessment, 'id' | 'breachId' | 'assessedAt'>) => RiskAssessment;
+    /**
+     * Get a risk assessment for a breach
+     */
+    getAssessment: (breachId: string) => RiskAssessment | null;
+    /**
+     * Calculate notification requirements based on a risk assessment
+     */
+    calculateNotificationRequirements: (breachId: string) => NotificationRequirement | null;
+    /**
+     * Send a regulatory notification
+     */
+    sendNotification: (breachId: string, notificationData: Omit<RegulatoryNotification, 'id' | 'breachId' | 'sentAt'>) => RegulatoryNotification;
+    /**
+     * Get a regulatory notification for a breach
+     */
+    getNotification: (breachId: string) => RegulatoryNotification | null;
+    /**
+     * Get breaches that require notification within the next X hours
+     */
+    getBreachesRequiringNotification: (hoursThreshold?: number) => Array<{
+        report: BreachReport;
+        assessment: RiskAssessment;
+        requirements: NotificationRequirement;
+        hoursRemaining: number;
+    }>;
+    /**
+     * Clear all breach data
+     */
+    clearBreachData: () => void;
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Hook for managing user consent in compliance with NDPA
+ */
+export declare function useConsent({ options, adapter, storageOptions, version, onChange, }: UseConsentOptions): UseConsentReturn;
+
+declare interface UseConsentOptions {
+    /**
+     * Consent options to present to the user
+     */
+    options: ConsentOption[];
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over storageOptions.
+     */
+    adapter?: StorageAdapter<ConsentSettings>;
+    /**
+     * Storage options for consent settings
+     * @deprecated Use adapter instead
+     */
+    storageOptions?: ConsentStorageOptions;
+    /**
+     * Version of the consent form
+     * @default "1.0"
+     */
+    version?: string;
+    /**
+     * Callback function called when consent settings change
+     */
+    onChange?: (settings: ConsentSettings) => void;
+}
+
+declare interface UseConsentReturn {
+    /**
+     * Current consent settings
+     */
+    settings: ConsentSettings | null;
+    /**
+     * Whether consent has been given for a specific option
+     */
+    hasConsent: (optionId: string) => boolean;
+    /**
+     * Update consent settings
+     */
+    updateConsent: (consents: Record<string, boolean>) => void;
+    /**
+     * Accept all consent options
+     */
+    acceptAll: () => void;
+    /**
+     * Reject all non-required consent options
+     */
+    rejectAll: () => void;
+    /**
+     * Whether the consent banner should be shown
+     */
+    shouldShowBanner: boolean;
+    /**
+     * Whether consent settings are valid
+     */
+    isValid: boolean;
+    /**
+     * Validation errors (if any)
+     */
+    validationErrors: string[];
+    /**
+     * Reset consent settings (clear from storage)
+     */
+    resetConsent: () => void;
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Hook for managing cross-border data transfers in compliance with NDPA Part VI (Sections 41-45)
+ */
+export declare function useCrossBorderTransfer({ initialTransfers, adapter, storageKey, useLocalStorage, onAdd, onUpdate, onRemove, }?: UseCrossBorderTransferOptions): UseCrossBorderTransferReturn;
+
+declare interface UseCrossBorderTransferOptions {
+    /**
+     * Initial transfers to load
+     */
+    initialTransfers?: CrossBorderTransfer[];
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over storageKey/useLocalStorage.
+     */
+    adapter?: StorageAdapter<CrossBorderTransfer[]>;
+    /**
+     * Storage key for transfer data
+     * @default "ndpr_cross_border_transfers"
+     * @deprecated Use adapter instead
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist transfers
+     * @default true
+     * @deprecated Use adapter instead
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when a transfer is added
+     */
+    onAdd?: (transfer: CrossBorderTransfer) => void;
+    /**
+     * Callback function called when a transfer is updated
+     */
+    onUpdate?: (transfer: CrossBorderTransfer) => void;
+    /**
+     * Callback function called when a transfer is removed
+     */
+    onRemove?: (id: string) => void;
+}
+
+declare interface UseCrossBorderTransferReturn {
+    /**
+     * All cross-border transfers
+     */
+    transfers: CrossBorderTransfer[];
+    /**
+     * Add a new cross-border transfer
+     */
+    addTransfer: (transfer: Omit<CrossBorderTransfer, 'id' | 'createdAt' | 'updatedAt'>) => CrossBorderTransfer;
+    /**
+     * Update an existing cross-border transfer
+     */
+    updateTransfer: (id: string, updates: Partial<CrossBorderTransfer>) => CrossBorderTransfer | null;
+    /**
+     * Remove a cross-border transfer
+     */
+    removeTransfer: (id: string) => void;
+    /**
+     * Get a cross-border transfer by ID
+     */
+    getTransfer: (id: string) => CrossBorderTransfer | null;
+    /**
+     * Get a compliance summary of all cross-border transfers
+     */
+    getSummary: () => CrossBorderSummary;
+    /**
+     * Validate a cross-border transfer
+     */
+    validateTransfer: (transfer: CrossBorderTransfer) => TransferValidationResult;
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Convenience wrapper around `usePrivacyPolicy`. With `orgInfo` provided
+ * and `autoGenerate` enabled (default), `policy` is non-null on the first
+ * post-load render — no manual `selectTemplate` / `generatePolicy` chaining
+ * required.
+ *
+ * @example
+ * ```tsx
+ * const { policy } = useDefaultPrivacyPolicy({
+ *   orgInfo: { name: 'Acme Ltd', email: 'privacy@acme.ng' }
+ * });
+ * return policy ? <PolicyPage policy={policy} /> : <Spinner />;
+ * ```
+ */
+export declare function useDefaultPrivacyPolicy(options?: UseDefaultPrivacyPolicyOptions): UsePrivacyPolicyReturn;
+
+declare interface UseDefaultPrivacyPolicyOptions {
+    /**
+     * Organisation information to pre-fill into the policy. When provided and
+     * `autoGenerate` is true (the default), the hook will auto-select the
+     * default template and generate a renderable policy on first commit, so
+     * `policy` is non-null on the first useful render.
+     */
+    orgInfo?: {
+        /** Organisation name (maps to `organizationInfo.name` and `orgName` variable) */
+        name?: string;
+        /** Privacy contact email (maps to `privacyEmail`) */
+        email?: string;
+        /** Organisation website URL */
+        website?: string;
+        /** Physical address */
+        address?: string;
+        /** Industry / sector descriptor */
+        industry?: string;
+        /** Data Protection Officer name */
+        dpoName?: string;
+        /** DPO email address */
+        dpoEmail?: string;
+    };
+    /**
+     * Whether the hook should auto-select the default template and generate
+     * the policy as soon as it's mounted with `orgInfo`. Set to false to
+     * retain manual control via `selectTemplate` / `generatePolicy`.
+     * @default true
+     */
+    autoGenerate?: boolean;
+    /**
+     * Storage key for policy data.
+     * @default "ndpr_privacy_policy"
+     */
+    storageKey?: string;
+    /**
+     * Whether to persist policy data in storage. When `false`, the hook
+     * uses an in-memory no-op adapter and nothing survives a page reload.
+     * @default true
+     */
+    persist?: boolean;
+    /**
+     * @deprecated Renamed to `persist` in v3.5.0 — `useLocalStorage` is
+     * still accepted for backward compatibility and will be removed in
+     * v4.0. Use `persist` (or pass an explicit `adapter`) instead.
+     * @default true
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over
+     * storageKey/persist/useLocalStorage.
+     */
+    adapter?: StorageAdapter<PrivacyPolicy>;
+}
+
+/**
+ * Hook for conducting Data Protection Impact Assessments in compliance with the NDPA 2023
+ */
+export declare function useDPIA({ sections, initialAnswers, adapter, storageKey, useLocalStorage, onComplete, }: UseDPIAOptions): UseDPIAReturn;
+
+declare interface UseDPIAOptions {
+    /**
+     * Sections of the DPIA questionnaire
+     */
+    sections: DPIASection[];
+    /**
+     * Initial answers (if resuming a DPIA)
+     */
+    initialAnswers?: DPIAAnswerMap;
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over storageKey/useLocalStorage.
+     */
+    adapter?: StorageAdapter<DPIAAnswerMap>;
+    /**
+     * Storage key for DPIA data
+     * @default "ndpr_dpia_data"
+     * @deprecated Use adapter instead
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist DPIA data
+     * @default true
+     * @deprecated Use adapter instead
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when the DPIA is completed
+     */
+    onComplete?: (result: DPIAResult) => void;
+}
+
+declare interface UseDPIAReturn {
+    /**
+     * Current section index
+     */
+    currentSectionIndex: number;
+    /**
+     * Current section
+     */
+    currentSection: DPIASection | null;
+    /**
+     * All answers
+     */
+    answers: DPIAAnswerMap;
+    /**
+     * Update an answer
+     */
+    updateAnswer: (questionId: string, value: DPIAAnswerValue) => void;
+    /**
+     * Go to the next section
+     */
+    nextSection: () => boolean;
+    /**
+     * Go to the previous section
+     */
+    prevSection: () => boolean;
+    /**
+     * Go to a specific section
+     */
+    goToSection: (index: number) => boolean;
+    /**
+     * Check if the current section is valid
+     */
+    isCurrentSectionValid: () => boolean;
+    /**
+     * Get validation errors for the current section
+     */
+    getCurrentSectionErrors: () => Record<string, string>;
+    /**
+     * Check if the DPIA is complete
+     */
+    isComplete: () => boolean;
+    /**
+     * Complete the DPIA and generate a result
+     */
+    completeDPIA: (assessorInfo: {
+        name: string;
+        role: string;
+        email: string;
+    }, title: string, processingDescription: string) => DPIAResult;
+    /**
+     * Get the visible questions for the current section
+     */
+    getVisibleQuestions: () => DPIAQuestion[];
+    /**
+     * Reset the DPIA
+     */
+    resetDPIA: () => void;
+    /**
+     * Progress percentage
+     */
+    progress: number;
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Hook for managing Data Subject Requests in compliance with the NDPA
+ */
+export declare function useDSR({ initialRequests, requestTypes, adapter, storageKey, useLocalStorage, onSubmit, onUpdate, }: UseDSROptions): UseDSRReturn;
+
+declare interface UseDSROptions {
+    /**
+     * Initial requests to load
+     */
+    initialRequests?: DSRRequest[];
+    /**
+     * Available request types
+     */
+    requestTypes: RequestType[];
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over storageKey/useLocalStorage.
+     */
+    adapter?: StorageAdapter<DSRRequest[]>;
+    /**
+     * Storage key for requests
+     * @default "ndpr_dsr_requests"
+     * @deprecated Use adapter instead
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist requests
+     * @default true
+     * @deprecated Use adapter instead
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when a request is submitted
+     */
+    onSubmit?: (request: DSRRequest) => void;
+    /**
+     * Callback function called when a request is updated
+     */
+    onUpdate?: (request: DSRRequest) => void;
+}
+
+declare interface UseDSRReturn {
+    /**
+     * All requests
+     */
+    requests: DSRRequest[];
+    /**
+     * Submit a new request
+     */
+    submitRequest: (requestData: Omit<DSRRequest, 'id' | 'status' | 'submittedAt' | 'updatedAt' | 'estimatedCompletionDate'>) => DSRRequest;
+    /**
+     * Update an existing request
+     */
+    updateRequest: (id: string, updates: Partial<DSRRequest>) => DSRRequest | null;
+    /**
+     * Get a request by ID
+     */
+    getRequest: (id: string) => DSRRequest | null;
+    /**
+     * Get requests by status
+     */
+    getRequestsByStatus: (status: RequestStatus) => DSRRequest[];
+    /**
+     * Get requests by type
+     */
+    getRequestsByType: (type: string) => DSRRequest[];
+    /**
+     * Get the request type definition by ID
+     */
+    getRequestType: (typeId: string) => RequestType | undefined;
+    /**
+     * Format a request for display or submission
+     */
+    formatRequest: (request: DSRRequest) => Record<string, unknown>;
+    /**
+     * Clear all requests
+     */
+    clearRequests: () => void;
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Hook for managing lawful basis documentation for processing activities
+ * in compliance with NDPA 2023 Section 25.
+ */
+export declare function useLawfulBasis({ initialActivities, adapter, storageKey, useLocalStorage, onAdd, onUpdate, onRemove, }?: UseLawfulBasisOptions): UseLawfulBasisReturn;
+
+declare interface UseLawfulBasisOptions {
+    /**
+     * Initial processing activities to load
+     */
+    initialActivities?: ProcessingActivity[];
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over storageKey/useLocalStorage.
+     */
+    adapter?: StorageAdapter<ProcessingActivity[]>;
+    /**
+     * Storage key for persisting activities
+     * @default "ndpr_lawful_basis_activities"
+     * @deprecated Use adapter instead
+     */
+    storageKey?: string;
+    /**
+     * Whether to use local storage to persist activities
+     * @default true
+     * @deprecated Use adapter instead
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback when an activity is added
+     */
+    onAdd?: (activity: ProcessingActivity) => void;
+    /**
+     * Callback when an activity is updated
+     */
+    onUpdate?: (activity: ProcessingActivity) => void;
+    /**
+     * Callback when an activity is removed
+     */
+    onRemove?: (id: string) => void;
+}
+
+declare interface UseLawfulBasisReturn {
+    /**
+     * All processing activities
+     */
+    activities: ProcessingActivity[];
+    /**
+     * Add a new processing activity
+     */
+    addActivity: (activity: Omit<ProcessingActivity, 'id' | 'createdAt' | 'updatedAt'>) => ProcessingActivity;
+    /**
+     * Update an existing processing activity
+     */
+    updateActivity: (id: string, updates: Partial<ProcessingActivity>) => ProcessingActivity | null;
+    /**
+     * Remove a processing activity
+     */
+    removeActivity: (id: string) => void;
+    /**
+     * Get a specific processing activity by ID
+     */
+    getActivity: (id: string) => ProcessingActivity | null;
+    /**
+     * Get a summary of all lawful basis documentation
+     */
+    getSummary: () => LawfulBasisSummary;
+    /**
+     * Validate a processing activity
+     */
+    validateActivity: (activity: ProcessingActivity) => LawfulBasisValidationResult;
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Returns the current NDPR configuration from the nearest `NDPRProvider`.
+ * If no provider is found, returns an empty config object.
+ */
+export declare function useNDPRConfig(): NDPRConfig;
+
+/**
+ * Hook for generating NDPA-compliant privacy policies
+ */
+export declare function usePrivacyPolicy({ templates, initialPolicy, adapter, storageKey, persist, useLocalStorage, onGenerate, }: UsePrivacyPolicyOptions): UsePrivacyPolicyReturn;
+
+declare interface UsePrivacyPolicyOptions {
+    /**
+     * Available policy templates
+     */
+    templates: PolicyTemplate[];
+    /**
+     * Initial policy data (if editing an existing policy)
+     */
+    initialPolicy?: PrivacyPolicy;
+    /**
+     * Pluggable storage adapter. When provided, takes precedence over storageKey/useLocalStorage.
+     */
+    adapter?: StorageAdapter<PrivacyPolicy>;
+    /**
+     * Storage key for policy data
+     * @default "ndpr_privacy_policy"
+     * @deprecated Use adapter instead
+     */
+    storageKey?: string;
+    /**
+     * Whether to persist policy data in storage. When `false`, the hook
+     * uses an in-memory no-op adapter and nothing survives a page reload.
+     * Prefer `adapter` for richer control (custom backends, async APIs).
+     *
+     * @default true
+     */
+    persist?: boolean;
+    /**
+     * @deprecated Renamed to `persist` in v3.5.0 — `useLocalStorage` is
+     * still accepted for backward compatibility and will be removed in
+     * v4.0. Use `persist` (or pass an explicit `adapter`) instead.
+     * @default true
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Callback function called when a policy is generated
+     */
+    onGenerate?: (policy: PrivacyPolicy) => void;
+}
+
+declare interface UsePrivacyPolicyReturn {
+    /**
+     * Current policy data
+     */
+    policy: PrivacyPolicy | null;
+    /**
+     * Selected template
+     */
+    selectedTemplate: PolicyTemplate | null;
+    /**
+     * Organization information
+     */
+    organizationInfo: OrganizationInfo;
+    /**
+     * Select a template
+     */
+    selectTemplate: (templateId: string) => boolean;
+    /**
+     * Update organization information
+     */
+    updateOrganizationInfo: (updates: Partial<OrganizationInfo>) => void;
+    /**
+     * Toggle whether a section is included in the policy
+     */
+    toggleSection: (sectionId: string, included: boolean) => void;
+    /**
+     * Update section content
+     */
+    updateSectionContent: (sectionId: string, content: string) => void;
+    /**
+     * Update variable values
+     */
+    updateVariableValue: (variable: string, value: string) => void;
+    /**
+     * Generate the policy
+     */
+    generatePolicy: () => PrivacyPolicy | null;
+    /**
+     * Get the generated policy text
+     */
+    getPolicyText: () => {
+        fullText: string;
+        sectionTexts: Record<string, string>;
+        missingVariables: string[];
+    };
+    /**
+     * Reset the policy
+     */
+    resetPolicy: () => void;
+    /**
+     * Check if the policy is valid
+     */
+    isValid: () => {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Hook for managing a Record of Processing Activities (ROPA)
+ * in compliance with NDPA 2023 requirements.
+ *
+ * Provides state management and utility functions for maintaining
+ * a comprehensive register of all data processing activities.
+ */
+export declare function useROPA({ initialData, adapter, onRecordAdd, onRecordUpdate, onRecordArchive, }: UseROPAOptions): UseROPAReturn;
+
+export declare interface UseROPAOptions {
+    /**
+     * Initial ROPA state
+     */
+    initialData: RecordOfProcessingActivities;
+    /**
+     * Pluggable storage adapter. When provided, adapter data is loaded on mount
+     * and the ROPA is persisted after every mutation. Falls back to initialData
+     * when no adapter data is found.
+     */
+    adapter?: StorageAdapter<RecordOfProcessingActivities>;
+    /**
+     * Callback when a record is added
+     */
+    onRecordAdd?: (record: ProcessingRecord) => void;
+    /**
+     * Callback when a record is updated
+     */
+    onRecordUpdate?: (id: string, updates: Partial<ProcessingRecord>) => void;
+    /**
+     * Callback when a record is archived
+     */
+    onRecordArchive?: (id: string) => void;
+}
+
+export declare interface UseROPAReturn {
+    /**
+     * Current state of the Record of Processing Activities
+     */
+    ropa: RecordOfProcessingActivities;
+    /**
+     * Add a new processing record
+     */
+    addRecord: (record: ProcessingRecord) => void;
+    /**
+     * Update an existing processing record
+     */
+    updateRecord: (id: string, updates: Partial<ProcessingRecord>) => void;
+    /**
+     * Archive a processing record by setting its status to 'archived'
+     */
+    archiveRecord: (id: string) => void;
+    /**
+     * Get a single processing record by ID
+     */
+    getRecord: (id: string) => ProcessingRecord | undefined;
+    /**
+     * Get a summary of the ROPA including statistics
+     */
+    getSummary: () => ROPASummary;
+    /**
+     * Export the ROPA as a CSV string
+     */
+    exportCSV: () => string;
+    /**
+     * Identify compliance gaps across all records
+     */
+    getComplianceGaps: () => ROPAComplianceGap[];
+    /**
+     * Whether the adapter is still loading data (relevant for async adapters)
+     */
+    isLoading: boolean;
+}
+
+/**
+ * Validates consent settings to ensure they meet NDPA requirements
+ * @param settings The consent settings to validate
+ * @returns An object containing validation result and any error messages
+ */
+export declare function validateConsent(settings: ConsentSettings): {
+    valid: boolean;
+    errors: string[];
+};
+
+/**
+ * Validates that consent options meet NDPA Section 26 requirements.
+ * Each consent option must specify a purpose for which data will be processed,
+ * as consent must be specific and informed per the Nigeria Data Protection Act.
+ * @param options The consent options to validate
+ * @returns An object containing validation result and any error messages
+ */
+export declare function validateConsentOptions(options: ConsentOption[]): {
+    valid: boolean;
+    errors: string[];
+};
+
+/**
+ * Validates that all required fields are present on a processing activity
+ * and that the lawful basis is properly documented.
+ *
+ * If lawfulBasis is 'legitimate_interests', ensures a LIA justification exists.
+ * If involvesSensitiveData is true, ensures sensitiveDataCondition is set.
+ *
+ * @param activity The processing activity to validate
+ * @returns Validation result with errors and warnings
+ */
+export declare function validateProcessingActivity(activity: ProcessingActivity): LawfulBasisValidationResult;
+
+/**
+ * Validates a processing record to ensure all required fields are present
+ * and properly filled per NDPA 2023 requirements.
+ *
+ * @param record - The processing record to validate
+ * @returns Validation result with any errors found
+ */
+export declare function validateProcessingRecord(record: ProcessingRecord): ROPAValidationResult;
+
+/**
+ * Validates a cross-border transfer record for completeness and compliance.
+ * Checks required fields, verifies that NDPC approval is documented when required,
+ * and ensures safeguards are in place.
+ *
+ * @param transfer The cross-border transfer to validate
+ * @returns Validation result with errors and warnings
+ */
+export declare function validateTransfer(transfer: CrossBorderTransfer): TransferValidationResult;
+
+export { }