@tantainnovative/ndpr-toolkit 1.0.7 → 1.0.9

package/dist/index.d.ts

@@ -1,24 +1,448 @@
-export { ConsentProvider, useConsent, ConsentContext } from './contexts/ConsentContext';
-export type { ConsentCategories, ConsentState, ConsentActions, ConsentContextValue } from './contexts/ConsentContext';
-export { createConsentContext } from './contexts/GenericConsentContext';
-export type { BaseConsentCategories, DefaultConsentCategories, ConsentProviderProps, } from './types/consent';
-export { ConsentManager } from './components/consent/ConsentManager';
-export { ConsentBanner } from './components/consent/ConsentBanner';
-export { ConsentSettings } from './components/consent/ConsentSettings';
-export type { ConsentManagerProps, BannerProps, SettingsProps, RenderProps } from './components/consent/ConsentManager';
-export { UnstyledConsentBanner, UnstyledConsentSettings, UnstyledConsentToggle, } from './components/consent/unstyled';
-export { useConsentState } from './hooks/useConsentState';
-export { useConsentActions } from './hooks/useConsentActions';
-export { useConsentManager } from './hooks/useConsentManager';
-export { consentService } from './lib/consentService';
-export declare const cookieUtils: {
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+export { ConsentBanner as UnstyledConsentBanner, ConsentSettings as UnstyledConsentSettings, ConsentToggle as UnstyledConsentToggle } from './unstyled.js';
+
+interface ConsentCategories {
+    necessary: boolean;
+    analytics: boolean;
+    marketing: boolean;
+    functional: boolean;
+    [key: string]: boolean;
+}
+interface ConsentState$1 {
+    hasUserConsented: boolean;
+    consentState: ConsentCategories;
+    showBanner: boolean;
+    showSettings: boolean;
+}
+interface ConsentActions$1 {
+    acceptAll: () => void;
+    rejectAll: () => void;
+    savePreferences: (preferences: Partial<ConsentCategories>) => void;
+    openSettings: () => void;
+    closeSettings: () => void;
+    updateConsent: (category: keyof ConsentCategories, value: boolean) => void;
+}
+interface ConsentContextValue$1 extends ConsentState$1, ConsentActions$1 {
+}
+declare const ConsentContext: React__default.Context<ConsentContextValue$1 | undefined>;
+interface ConsentProviderProps$1 {
+    children: ReactNode;
+    initialConsent?: Partial<ConsentCategories>;
+    onConsentChange?: (consent: ConsentCategories) => void;
+    storageKey?: string;
+}
+declare function ConsentProvider({ children, initialConsent, onConsentChange, storageKey, }: ConsentProviderProps$1): React__default.JSX.Element;
+declare function useConsent(): ConsentContextValue$1;
+
+/**
+ * Base consent categories interface that can be extended
+ */
+interface BaseConsentCategories {
+    necessary: boolean;
+    [key: string]: boolean;
+}
+/**
+ * Default consent categories provided by the toolkit
+ */
+interface DefaultConsentCategories extends BaseConsentCategories {
+    necessary: boolean;
+    analytics: boolean;
+    marketing: boolean;
+    functional: boolean;
+}
+/**
+ * Generic consent state interface
+ */
+interface ConsentState<T extends BaseConsentCategories = DefaultConsentCategories> {
+    hasUserConsented: boolean;
+    consentState: T;
+    showBanner: boolean;
+    showSettings: boolean;
+}
+/**
+ * Generic consent actions interface
+ */
+interface ConsentActions<T extends BaseConsentCategories = DefaultConsentCategories> {
+    acceptAll: () => void;
+    rejectAll: () => void;
+    savePreferences: (preferences: Partial<T>) => void;
+    openSettings: () => void;
+    closeSettings: () => void;
+    updateConsent: (category: keyof T, value: boolean) => void;
+}
+/**
+ * Combined consent context value
+ */
+interface ConsentContextValue<T extends BaseConsentCategories = DefaultConsentCategories> extends ConsentState<T>, ConsentActions<T> {
+}
+/**
+ * Consent provider props with generic support
+ */
+interface ConsentProviderProps<T extends BaseConsentCategories = DefaultConsentCategories> {
+    children: React.ReactNode;
+    initialConsent?: Partial<T>;
+    onConsentChange?: (consent: T) => void;
+    storageKey?: string;
+    categories?: Array<{
+        id: keyof T;
+        name: string;
+        description: string;
+        required?: boolean;
+    }>;
+}
+
+/**
+ * Factory function to create a typed consent context
+ */
+declare function createConsentContext<T extends BaseConsentCategories = DefaultConsentCategories>(): {
+    ConsentContext: React__default.Context<ConsentContextValue<T> | undefined>;
+    ConsentProvider: ({ children, initialConsent, onConsentChange, storageKey, categories, }: ConsentProviderProps<T>) => React__default.JSX.Element;
+    useConsent: () => ConsentContextValue<T>;
+};
+
+interface ConsentBannerProps {
+    renderBanner?: (props: BannerProps) => ReactNode;
+    theme?: {
+        primaryColor?: string;
+        textColor?: string;
+        backgroundColor?: string;
+    };
+    position?: "top" | "bottom" | "center";
+    animation?: "slide" | "fade" | "none";
+    fullWidth?: boolean;
+    maxWidth?: string;
+    unstyled?: boolean;
+    className?: string;
+    children?: ReactNode;
+}
+interface ConsentBannerComponent extends React__default.FC<ConsentBannerProps> {
+    Message: React__default.FC<{
+        children: ReactNode;
+        className?: string;
+    }>;
+    Actions: React__default.FC<{
+        children: ReactNode;
+        className?: string;
+    }>;
+}
+declare const ConsentBanner: ConsentBannerComponent;
+
+interface ConsentSettingsProps {
+    renderSettings?: (props: SettingsProps) => ReactNode;
+    theme?: {
+        primaryColor?: string;
+        textColor?: string;
+        backgroundColor?: string;
+    };
+    unstyled?: boolean;
+    className?: string;
+    children?: ReactNode;
+}
+declare const ConsentSettings: React__default.FC<ConsentSettingsProps>;
+
+interface BannerProps {
+    onAcceptAll: () => void;
+    onRejectAll: () => void;
+    onOpenSettings: () => void;
+}
+interface SettingsProps {
+    consentState: ConsentCategories;
+    onUpdateConsent: (category: keyof ConsentCategories, value: boolean) => void;
+    onSave: () => void;
+    onClose: () => void;
+}
+interface RenderProps {
+    consents: ConsentCategories;
+    actions: ConsentActions$1;
+    ui: {
+        showBanner: boolean;
+        showSettings: boolean;
+        openSettings: () => void;
+        closeSettings: () => void;
+    };
+}
+interface ConsentManagerProps extends Omit<ConsentProviderProps$1, "children"> {
+    children?: ReactNode | ((props: RenderProps) => ReactNode);
+    headless?: boolean;
+    renderBanner?: (props: BannerProps) => ReactNode;
+    renderSettings?: (props: SettingsProps) => ReactNode;
+    components?: {
+        Banner?: React__default.ComponentType<unknown>;
+        Settings?: React__default.ComponentType<unknown>;
+    };
+    theme?: {
+        primaryColor?: string;
+        textColor?: string;
+        backgroundColor?: string;
+    };
+    position?: "top" | "bottom" | "center";
+    animation?: "slide" | "fade" | "none";
+    fullWidth?: boolean;
+    maxWidth?: string;
+}
+interface ConsentManagerComponent extends React__default.FC<ConsentManagerProps> {
+    Banner: typeof ConsentBanner;
+    Settings: typeof ConsentSettings;
+}
+declare const ConsentManager: ConsentManagerComponent;
+
+/**
+ * Hook to access only the consent state without actions
+ */
+declare function useConsentState(): {
+    hasUserConsented: boolean;
+    consentState: ConsentCategories;
+    showBanner: boolean;
+    showSettings: boolean;
+};
+
+/**
+ * Hook to access only the consent actions without state
+ */
+declare function useConsentActions(): {
+    acceptAll: () => void;
+    rejectAll: () => void;
+    savePreferences: (preferences: Partial<ConsentCategories>) => void;
+    openSettings: () => void;
+    closeSettings: () => void;
+    updateConsent: (category: keyof ConsentCategories, value: boolean) => void;
+};
+
+type ConsentEventType = "consent:accepted" | "consent:rejected" | "consent:updated" | "banner:shown" | "banner:hidden" | "settings:opened" | "settings:closed";
+type ConsentEventListener = (data?: unknown) => void;
+interface ConsentEventManager {
+    on: (event: ConsentEventType, listener: ConsentEventListener) => () => void;
+    off: (event: ConsentEventType, listener: ConsentEventListener) => void;
+    emit: (event: ConsentEventType, data?: unknown) => void;
+}
+/**
+ * Advanced hook that provides event-driven consent management
+ */
+declare function useConsentManager(): ConsentEventManager & ReturnType<typeof useConsent>;
+
+type DSRStatus = "pending" | "in-progress" | "completed" | "rejected";
+type DSRType = "access" | "rectification" | "erasure" | "portability" | "objection" | "restriction";
+type RequestType = DSRType;
+interface DSRRequestType {
+    id: string;
+    name: string;
+    description: string;
+    estimatedCompletionTime: number;
+    requiresAdditionalInfo: boolean;
+}
+interface ConsentOption {
+    id: string;
+    label: string;
+    description: string;
+    required?: boolean;
+    defaultValue?: boolean;
+}
+interface BreachReport {
+    id: string;
+    title: string;
+    description: string;
+    category: string;
+    discoveredAt: number;
+    reportedAt: number;
+    reporter: {
+        name: string;
+        email: string;
+        department: string;
+    };
+    affectedSystems: string[];
+    dataTypes: string[];
+    estimatedAffectedSubjects: number;
+    status: "ongoing" | "resolved" | "contained";
+    initialActions: string;
+}
+interface DPIAQuestion {
+    id: string;
+    text: string;
+    type: "yes-no" | "multiple-choice" | "text" | "number" | "textarea" | "select" | "radio" | "checkbox" | "scale";
+    options?: Array<{
+        id?: string;
+        label: string;
+        value: string;
+        riskLevel?: unknown;
+    }>;
+    required?: boolean;
+    category?: string;
+    guidance?: string;
+    minValue?: number;
+    maxValue?: number;
+    scaleLabels?: Record<string, string>;
+}
+type RiskAssessmentQuestion = DPIAQuestion;
+type BreachSeverity = "low" | "medium" | "high" | "critical";
+interface ConsentRecord {
+    id: string;
+    userId?: string;
+    consents: Record<string, boolean>;
+    timestamp: Date;
+    ipAddress?: string;
+    userAgent?: string;
+    version: string;
+}
+interface ConsentHistoryEntry {
+    timestamp: Date;
+    consents: Record<string, boolean>;
+    action: "granted" | "revoked" | "updated";
+    ipAddress?: string;
+    userAgent?: string;
+    version: string;
+}
+interface DSRRequest {
+    id: string;
+    type: DSRType;
+    status: DSRStatus;
+    createdAt: number;
+    updatedAt: number;
+    dueDate: number;
+    completedAt?: number;
+    subject: {
+        name: string;
+        email: string;
+        phone?: string;
+    };
+    description: string;
+}
+interface RiskAssessment {
+    id: string;
+    breachId: string;
+    riskLevel: "low" | "medium" | "high" | "critical";
+    assessment: string;
+    mitigationMeasures: string[];
+    assessedAt: number;
+    assessor: string;
+}
+interface DPIAResult {
+    id: string;
+    title: string;
+    processingDescription: string;
+    startedAt: number;
+    completedAt?: number;
+    assessor: {
+        name: string;
+        role: string;
+        email: string;
+    };
+    answers: Record<string, unknown>;
+    risks: Array<{
+        id: string;
+        description: string;
+        likelihood: number;
+        impact: number;
+        score: number;
+        level: string;
+        mitigationMeasures: string[];
+        mitigated?: boolean;
+        residualScore?: number;
+        relatedQuestionIds?: string[];
+    }>;
+    overallRiskLevel: "low" | "medium" | "high" | "critical";
+    canProceed: boolean;
+    conclusion: string;
+    recommendations: string[];
+    reviewDate: number;
+    version: string;
+}
+interface PolicyVariable {
+    name: string;
+    label: string;
+    type: "text" | "textarea" | "select" | "checkbox" | "date";
+    required?: boolean;
+    options?: string[];
+    defaultValue?: unknown;
+}
+interface PolicyTemplate {
+    id: string;
+    name: string;
+    description: string;
+    sections: PolicySection[];
+    variables: PolicyVariable[];
+    version: string;
+}
+interface PolicySection {
+    id: string;
+    title: string;
+    content: string;
+    template?: string;
+    required: boolean;
+    order: number;
+    included?: boolean;
+    variables?: string[];
+}
+
+declare const consentService: {
+    saveConsent: (consents: Record<string, boolean>, userId?: string) => ConsentRecord;
+    getCurrentConsent: () => ConsentRecord | null;
+    getConsentHistory: () => ConsentHistoryEntry[];
+    updateConsent: (consents: Record<string, boolean>, changeReason?: string, userId?: string) => ConsentRecord;
+    clearConsentData: () => boolean;
+    hasConsent: (type: string) => boolean;
+};
+
+interface BreachNotificationFormProps {
+    onSubmit: (data: {
+        title: string;
+        description: string;
+        discoveryDate: string;
+        affectedDataSubjects: number;
+        dataCategories: string[];
+        severity: BreachSeverity;
+        mitigationSteps: string[];
+        reportedToAuthorities: boolean;
+        reportedToDataSubjects: boolean;
+    }) => void;
+    className?: string;
+}
+declare function BreachNotificationForm({ onSubmit, className, }: BreachNotificationFormProps): React$1.JSX.Element;
+
+interface DPIAQuestionnaireProps {
+    questions: RiskAssessmentQuestion[];
+    onSubmit: (answers: Record<string, number>, projectName: string) => void;
+    className?: string;
+}
+declare function DPIAQuestionnaire({ questions, onSubmit, className, }: DPIAQuestionnaireProps): React$1.JSX.Element;
+
+interface DataSubjectRequestFormProps {
+    onSubmit: (data: {
+        requestType: RequestType;
+        name: string;
+        email: string;
+        details: string;
+        consent: boolean;
+    }) => void;
+    className?: string;
+}
+declare function DataSubjectRequestForm({ onSubmit, className, }: DataSubjectRequestFormProps): React$1.JSX.Element;
+
+interface PolicyGeneratorProps {
+    onGenerate: (policy: {
+        organizationName: string;
+        organizationContact: string;
+        sections: PolicySection[];
+    }) => void;
+    className?: string;
+}
+declare function PolicyGenerator({ onGenerate, className, }: PolicyGeneratorProps): React__default.JSX.Element;
+
+declare const cookieUtils: {
     set: (name: string, value: string, days: number) => void;
     get: (name: string) => string | null;
     delete: (name: string) => void;
 };
-export declare const consentStorage: {
-    save: (key: string, data: any) => void;
-    load: (key: string) => any | null;
+declare const consentStorage: {
+    save: (key: string, data: unknown) => void;
+    load: <T = unknown>(key: string) => T | null;
+    remove: (key: string) => void;
+};
+
+declare const ConsentStorage: {
+    save: (key: string, data: unknown) => void;
+    load: <T = unknown>(key: string) => T | null;
     remove: (key: string) => void;
 };
-//# sourceMappingURL=index.d.ts.map
+
+export { type BannerProps, type BaseConsentCategories, BreachNotificationForm as BreachNotificationManager, type BreachReport, BreachNotificationForm as BreachReportForm, BreachNotificationForm as BreachRiskAssessment, type BreachSeverity, type ConsentActions$1 as ConsentActions, ConsentBanner, type ConsentCategories, ConsentContext, type ConsentContextValue$1 as ConsentContextValue, type ConsentHistoryEntry, ConsentManager, type ConsentManagerProps, type ConsentOption, ConsentProvider, type ConsentProviderProps, type ConsentRecord, ConsentSettings, type ConsentState$1 as ConsentState, ConsentStorage, type DPIAQuestion, DPIAQuestionnaire, type DPIAResult, DataSubjectRequestForm as DSRDashboard, type DSRRequest, DataSubjectRequestForm as DSRRequestForm, type DSRRequestType, type DSRStatus, DataSubjectRequestForm as DSRTracker, type DSRType, type DefaultConsentCategories, PolicyGenerator as PolicyExporter, PolicyGenerator, PolicyGenerator as PolicyPreview, type PolicySection, type PolicyTemplate, type PolicyVariable, BreachNotificationForm as RegulatoryReportGenerator, type RenderProps, type RequestType, type RiskAssessment, type SettingsProps, consentService, consentStorage, cookieUtils, createConsentContext, useConsent, useConsentActions, useConsentManager, useConsentState };