@tantainnovative/ndpr-toolkit 3.4.1 → 3.5.0

package/dist/presets.d.mts

@@ -1,114 +1,1020 @@
-import React__default from 'react';
-import { b as ConsentBannerClassNames } from './ConsentBanner-F5ayys5K.mjs';
-import { C as ConsentOption, a as ConsentSettings } from './consent-CmVzqZUk.mjs';
-import { S as StorageAdapter } from './types-DK2CoKOC.mjs';
-import { D as DSRFormSubmission, b as DSRRequestFormClassNames } from './DSRRequestForm-DRouEr9j.mjs';
-import { c as RequestType } from './dsr-yKbqX531.mjs';
-import { B as BreachFormSubmission, b as BreachReportFormClassNames } from './BreachReportForm-yJ2Zl6gz.mjs';
-import { B as BreachCategory } from './breach-Eu9byel8.mjs';
-import { c as PrivacyPolicy } from './privacy-Ca6te9Ir.mjs';
-import { P as PolicyDraft } from './policy-engine-5qTfp2z4.mjs';
-import { a as DPIAQuestionnaireClassNames } from './DPIAQuestionnaire-jkt1Veb6.mjs';
-import { c as DPIASection } from './dpia-c9GiiOq0.mjs';
-import { a as LawfulBasisTrackerClassNames } from './LawfulBasisTracker-CBqOxX1D.mjs';
-import { P as ProcessingActivity } from './lawful-basis-Cv1VmDLn.mjs';
-import { a as CrossBorderTransferManagerClassNames } from './CrossBorderTransferManager-DkZhv9vD.mjs';
-import { a as CrossBorderTransfer } from './cross-border-UyT00llA.mjs';
-import { a as ROPAManagerClassNames } from './ROPAManager-BS4eB8Hw.mjs';
-import { a as RecordOfProcessingActivities } from './ropa-CFHuT7jE.mjs';
-import { C as ComplianceInput } from './compliance-score-racQe_E_.mjs';
-import { a as NDPRDashboardClassNames } from './NDPRDashboard-CLJpEg0X.mjs';
-
-interface NDPRConsentProps {
-    extraOptions?: ConsentOption[];
-    options?: ConsentOption[];
-    adapter?: StorageAdapter<ConsentSettings>;
-    position?: 'top' | 'bottom' | 'center' | 'inline';
-    classNames?: ConsentBannerClassNames;
-    unstyled?: boolean;
-    onSave?: (settings: ConsentSettings) => void;
-}
-declare const NDPRConsent: React__default.FC<NDPRConsentProps>;
-
-interface NDPRSubjectRightsProps {
-    requestTypes?: RequestType[];
-    adapter?: StorageAdapter<DSRFormSubmission>;
-    classNames?: DSRRequestFormClassNames;
-    unstyled?: boolean;
-    onSubmit?: (data: DSRFormSubmission) => void;
-}
-declare const NDPRSubjectRights: React__default.FC<NDPRSubjectRightsProps>;
-
-interface NDPRBreachReportProps {
-    categories?: BreachCategory[];
-    adapter?: StorageAdapter<BreachFormSubmission>;
-    classNames?: BreachReportFormClassNames;
-    unstyled?: boolean;
-    onSubmit?: (data: BreachFormSubmission) => void;
-}
-declare const NDPRBreachReport: React__default.FC<NDPRBreachReportProps>;
-
-interface NDPRPrivacyPolicyProps {
-    adapter?: StorageAdapter<PolicyDraft>;
-    onComplete?: (policy: PrivacyPolicy) => void;
-    classNames?: Record<string, string>;
-    unstyled?: boolean;
-}
-declare const NDPRPrivacyPolicy: React__default.FC<NDPRPrivacyPolicyProps>;
-
-interface NDPRDPIAProps {
-    sections?: DPIASection[];
-    adapter?: StorageAdapter<Record<string, any>>;
-    classNames?: DPIAQuestionnaireClassNames;
-    unstyled?: boolean;
-    onComplete?: (answers: Record<string, any>) => void;
-}
-declare const NDPRDPIA: React__default.FC<NDPRDPIAProps>;
-
-interface NDPRLawfulBasisProps {
-    initialActivities?: ProcessingActivity[];
-    adapter?: StorageAdapter<ProcessingActivity[]>;
-    classNames?: LawfulBasisTrackerClassNames;
-    unstyled?: boolean;
-}
-declare const NDPRLawfulBasis: React__default.FC<NDPRLawfulBasisProps>;
-
-interface NDPRCrossBorderProps {
-    initialTransfers?: CrossBorderTransfer[];
-    adapter?: StorageAdapter<CrossBorderTransfer[]>;
-    classNames?: CrossBorderTransferManagerClassNames;
-    unstyled?: boolean;
-}
-declare const NDPRCrossBorder: React__default.FC<NDPRCrossBorderProps>;
-
-interface NDPRROPAProps {
-    initialData?: RecordOfProcessingActivities;
-    adapter?: StorageAdapter<RecordOfProcessingActivities>;
-    classNames?: ROPAManagerClassNames;
-    unstyled?: boolean;
-}
-declare const NDPRROPA: React__default.FC<NDPRROPAProps>;
-
-interface NDPRDashboardPresetProps {
-    /** Raw compliance input — the preset calls getComplianceScore() internally */
-    input: ComplianceInput;
-    /** 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;
-}
-/**
- * Preset wrapper for NDPRDashboard.
- *
- * Accepts raw ComplianceInput, computes the report via getComplianceScore(),
- * and delegates rendering to the NDPRDashboard component.
- */
-declare const NDPRDashboard: React__default.FC<NDPRDashboardPresetProps>;
-
-export { NDPRBreachReport, type NDPRBreachReportProps, NDPRDashboard as NDPRComplianceDashboard, NDPRConsent, type NDPRConsentProps, NDPRCrossBorder, type NDPRCrossBorderProps, NDPRDPIA, type NDPRDPIAProps, type NDPRDashboardPresetProps, NDPRLawfulBasis, type NDPRLawfulBasisProps, NDPRPrivacyPolicy, type NDPRPrivacyPolicyProps, NDPRROPA, type NDPRROPAProps, NDPRSubjectRights, type NDPRSubjectRightsProps };
+import React__default from 'react';
+
+/**
+ * Adequacy status of a destination country
+ */
+declare type AdequacyStatus = 'adequate' | 'inadequate' | 'pending_review' | 'unknown';
+
+/**
+ * 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
+ */
+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';
+}
+
+/**
+ * Represents the data submitted by the breach report form.
+ */
+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;
+    }>;
+}
+
+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 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;
+    };
+}
+
+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;
+}
+
+/**
+ * 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
+ */
+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
+ */
+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;
+}
+
+/**
+ * Represents a cross-border data transfer record
+ */
+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;
+}
+
+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;
+}
+
+/** A user-defined section added to the policy outside the generated ones. */
+declare interface CustomSection {
+    id: string;
+    title: string;
+    content: string;
+    order: number;
+    required: false;
+}
+
+/** A logical category of personal data the organisation may collect. */
+declare interface DataCategory {
+    /** Machine-readable identifier. */
+    id: string;
+    /** Human-readable label shown in the wizard. */
+    label: string;
+    /** Grouping for display and compliance checks. */
+    group: 'identity' | 'financial' | 'behavioral' | 'sensitive' | 'children';
+    /** Specific data points within this category. */
+    dataPoints: string[];
+    /** Whether this category is currently selected by the user. */
+    selected: boolean;
+}
+
+/**
+ * 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
+ */
+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;
+    }>;
+}
+
+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;
+}
+
+/**
+ * Represents a section in the DPIA questionnaire
+ */
+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;
+}
+
+/**
+ * Represents the data submitted by the DSR request form.
+ */
+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;
+}
+
+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;
+}
+
+/**
+ * Policy engine types for the adaptive privacy policy generator.
+ * These types power the wizard-driven policy builder, compliance checker,
+ * and export functionality — all aligned with the NDPA 2023.
+ */
+
+/** Industry verticals with sector-specific compliance requirements. */
+declare type Industry = 'fintech' | 'healthcare' | 'ecommerce' | 'saas' | 'education' | 'government' | 'other';
+
+/**
+ * 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)
+ */
+declare type LawfulBasis = 'consent' | 'contract' | 'legal_obligation' | 'vital_interests' | 'public_interest' | 'legitimate_interests';
+
+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;
+}
+
+/**
+ * Lawful basis for processing personal data per NDPA Section 25(1)
+ */
+declare type LawfulBasisType = 'consent' | 'contract' | 'legal_obligation' | 'vital_interests' | 'public_interest' | 'legitimate_interests';
+
+export declare const NDPRBreachReport: React__default.FC<NDPRBreachReportProps>;
+
+export declare interface NDPRBreachReportProps {
+    categories?: BreachCategory[];
+    adapter?: StorageAdapter<BreachFormSubmission>;
+    classNames?: BreachReportFormClassNames;
+    unstyled?: boolean;
+    onSubmit?: (data: BreachFormSubmission) => void;
+}
+
+/**
+ * Preset wrapper for NDPRDashboard.
+ *
+ * Accepts raw ComplianceInput, computes the report via getComplianceScore(),
+ * and delegates rendering to the NDPRDashboard component.
+ */
+export declare const NDPRComplianceDashboard: React__default.FC<NDPRDashboardPresetProps>;
+
+export declare const NDPRConsent: React__default.FC<NDPRConsentProps>;
+
+export declare interface NDPRConsentProps {
+    extraOptions?: ConsentOption[];
+    options?: ConsentOption[];
+    adapter?: StorageAdapter<ConsentSettings>;
+    position?: 'top' | 'bottom' | 'center' | 'inline';
+    classNames?: ConsentBannerClassNames;
+    unstyled?: boolean;
+    onSave?: (settings: ConsentSettings) => void;
+}
+
+export declare const NDPRCrossBorder: React__default.FC<NDPRCrossBorderProps>;
+
+export declare interface NDPRCrossBorderProps {
+    initialTransfers?: CrossBorderTransfer[];
+    adapter?: StorageAdapter<CrossBorderTransfer[]>;
+    classNames?: CrossBorderTransferManagerClassNames;
+    unstyled?: boolean;
+}
+
+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 NDPRDashboardPresetProps {
+    /** Raw compliance input — the preset calls getComplianceScore() internally */
+    input: ComplianceInput;
+    /** 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;
+}
+
+export declare const NDPRDPIA: React__default.FC<NDPRDPIAProps>;
+
+export declare interface NDPRDPIAProps {
+    sections?: DPIASection[];
+    adapter?: StorageAdapter<Record<string, any>>;
+    classNames?: DPIAQuestionnaireClassNames;
+    unstyled?: boolean;
+    onComplete?: (answers: Record<string, any>) => void;
+}
+
+export declare const NDPRLawfulBasis: React__default.FC<NDPRLawfulBasisProps>;
+
+export declare interface NDPRLawfulBasisProps {
+    initialActivities?: ProcessingActivity[];
+    adapter?: StorageAdapter<ProcessingActivity[]>;
+    classNames?: LawfulBasisTrackerClassNames;
+    unstyled?: boolean;
+}
+
+export declare const NDPRPrivacyPolicy: React__default.FC<NDPRPrivacyPolicyProps>;
+
+export declare interface NDPRPrivacyPolicyProps {
+    adapter?: StorageAdapter<PolicyDraft>;
+    onComplete?: (policy: PrivacyPolicy) => void;
+    classNames?: Record<string, string>;
+    unstyled?: boolean;
+}
+
+export declare const NDPRROPA: React__default.FC<NDPRROPAProps>;
+
+export declare interface NDPRROPAProps {
+    initialData?: RecordOfProcessingActivities;
+    adapter?: StorageAdapter<RecordOfProcessingActivities>;
+    classNames?: ROPAManagerClassNames;
+    unstyled?: boolean;
+}
+
+export declare const NDPRSubjectRights: React__default.FC<NDPRSubjectRightsProps>;
+
+export declare interface NDPRSubjectRightsProps {
+    requestTypes?: RequestType[];
+    adapter?: StorageAdapter<DSRFormSubmission>;
+    classNames?: DSRRequestFormClassNames;
+    unstyled?: boolean;
+    onSubmit?: (data: DSRFormSubmission) => void;
+}
+
+/**
+ * Represents organization information for a privacy policy
+ */
+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;
+}
+
+/** Organisation size tiers — affects complexity of generated language. */
+declare type OrgSize = 'startup' | 'midsize' | 'enterprise';
+
+/** Represents an in-progress policy being built in the wizard. */
+declare interface PolicyDraft {
+    /** Unique identifier for the draft. */
+    id: string;
+    /** The template context driving section generation. */
+    templateContext: TemplateContext;
+    /** Custom sections added by the user. */
+    customSections: CustomSection[];
+    /** Per-section content overrides keyed by section id. */
+    sectionOverrides: Record<string, string>;
+    /** Ordered list of section ids defining the final order. */
+    sectionOrder: string[];
+    /** Current wizard step (0-indexed). */
+    currentStep: number;
+    /** Timestamp of the last save. */
+    lastSavedAt: number;
+    /** The draft is always in "draft" status until finalised. */
+    status: 'draft';
+}
+
+/**
+ * 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
+ */
+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 generated privacy policy
+ */
+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
+ */
+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;
+    };
+}
+
+/** Lawful processing purposes recognised under the NDPA. */
+declare type ProcessingPurpose = 'service_delivery' | 'marketing' | 'analytics' | 'research' | 'legal_compliance' | 'fraud_prevention';
+
+/**
+ * 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
+ */
+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;
+}
+
+/**
+ * Represents a complete Record of Processing Activities
+ */
+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 type of data subject request (detailed configuration)
+ */
+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;
+    }>;
+}
+
+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;
+}
+
+/**
+ * Additional conditions required for processing sensitive personal data
+ * per NDPA Section 27
+ */
+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 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>;
+}
+
+/** Full context used to generate an adaptive privacy policy. */
+declare interface TemplateContext {
+    /** Organisation details, extended with industry and size. */
+    org: OrganizationInfo & {
+        industry: Industry;
+        orgSize: OrgSize;
+        country: string;
+    };
+    /** Data categories the organisation collects. */
+    dataCategories: DataCategory[];
+    /** Processing purposes relevant to the organisation. */
+    purposes: ProcessingPurpose[];
+    /** Whether the organisation processes children's data. */
+    hasChildrenData: boolean;
+    /** Whether the organisation processes sensitive/special-category data. */
+    hasSensitiveData: boolean;
+    /** Whether the organisation processes financial data. */
+    hasFinancialData: boolean;
+    /** Whether data is transferred outside Nigeria. */
+    hasCrossBorderTransfer: boolean;
+    /** Whether automated decision-making or profiling is used. */
+    hasAutomatedDecisions: boolean;
+    /** Third-party processors that receive personal data. */
+    thirdPartyProcessors: ThirdPartyProcessor[];
+}
+
+/** A third-party entity that processes data on behalf of the organisation. */
+declare interface ThirdPartyProcessor {
+    /** Name of the third party. */
+    name: string;
+    /** Purpose of sharing data with this processor. */
+    purpose: string;
+    /** Country where the processor is located. */
+    country: 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
+ */
+declare type TransferMechanism = 'adequacy_decision' | 'standard_clauses' | 'binding_corporate_rules' | 'ndpc_authorization' | 'explicit_consent' | 'contract_performance' | 'public_interest' | 'legal_claims' | 'vital_interests';
+
+export { }