@redacto.io/consent-sdk-react 4.0.0 → 5.0.0

package/dist/privacy-center.d.mts

@@ -0,0 +1,649 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+
+/**
+ * Options for apiFetch function
+ */
+type ApiFetchOptions = RequestInit & {
+    /**
+     * Auth token getter function
+     */
+    getAuthToken?: () => Promise<string | null>;
+};
+/**
+ * Standard API response wrapper
+ */
+type ApiResponse<T> = {
+    code: number;
+    status: string;
+    detail: T;
+};
+
+/**
+ * Base request parameters for consent service calls
+ */
+type BaseRequest = {
+    organisationUuid: string;
+    workspaceUuid: string;
+    authToken: string;
+};
+/**
+ * Consent service client factory.
+ * Creates a client instance with a specific base URL.
+ * @param baseUrl - Consent server base URL
+ */
+declare function createConsentClient(baseUrl: string): {
+    /**
+     * Get form data (privacy center)
+     */
+    getFormData(baseRequest: BaseRequest, contact: string, authToken?: string, options?: ApiFetchOptions & {
+        useSessionAuth?: boolean;
+    }, language?: string): Promise<unknown>;
+    /**
+     * Create case request (privacy center or case management)
+     */
+    createCaseRequest(baseRequest: BaseRequest, payload: unknown, authToken?: string, options?: ApiFetchOptions & {
+        useSessionAuth?: boolean;
+    }): Promise<unknown>;
+    /**
+     * Create OTP (public)
+     */
+    createOtp(organisationId: string, workspaceId: string, email: string, options?: Omit<ApiFetchOptions, "getAuthToken">): Promise<unknown>;
+    /**
+     * Verify OTP (public)
+     */
+    verifyOtp(organisationId: string, workspaceId: string, otpId: string, otp: string, options?: Omit<ApiFetchOptions, "getAuthToken">): Promise<unknown>;
+    /**
+     * Exchange one-time token for JWT tokens (public)
+     */
+    exchangeToken(token: string): Promise<unknown>;
+    /**
+     * Refresh OTP token (public)
+     */
+    refreshOtpToken(organisationId: string, workspaceId: string, refreshToken: string, options?: Omit<ApiFetchOptions, "getAuthToken">): Promise<unknown>;
+    /**
+     * Get products
+     */
+    getProducts(baseRequest: BaseRequest, skip?: number, limit?: number, options?: Omit<ApiFetchOptions, "getAuthToken">): Promise<unknown>;
+    /**
+     * Get user consents (privacy center)
+     */
+    getUserConsents(baseRequest: BaseRequest, contact: string, offset?: number, limit?: number, search?: string, status?: string, product_uuid?: string, language?: string, authToken?: string, options?: Omit<ApiFetchOptions, "getAuthToken">): Promise<unknown>;
+    /**
+     * Manage consent (privacy center) - revoke, regrant, or renew
+     */
+    manageConsent(baseRequest: BaseRequest, purposeId: string, contact: string, status: "revoke" | "regrant" | "renew", authToken?: string, options?: Omit<ApiFetchOptions, "getAuthToken">, nominatorContact?: string, dataElementUuids?: string[]): Promise<unknown>;
+    /**
+     * Get activities (privacy center)
+     */
+    getActivities(baseRequest: BaseRequest, offset?: number, limit?: number, language?: string, authToken?: string, options?: Omit<ApiFetchOptions, "getAuthToken">): Promise<unknown>;
+    /**
+     * Get case history (privacy center)
+     */
+    getCaseHistory(baseRequest: BaseRequest, _contact: string, offset?: number, limit?: number, language?: string, authToken?: string, options?: Omit<ApiFetchOptions, "getAuthToken">): Promise<unknown>;
+    /**
+     * Get messages for a case (privacy center)
+     */
+    getCaseMessages(baseRequest: BaseRequest, caseUuid: string, authToken?: string): Promise<CaseMessage[]>;
+    /**
+     * Send a message on a case (privacy center)
+     */
+    sendCaseMessage(baseRequest: BaseRequest, caseUuid: string, body: string, documentUuids: string[], authToken?: string): Promise<CaseMessage>;
+    /**
+     * Upload a document on a case (multipart/form-data, privacy center)
+     */
+    uploadCaseDocument(baseRequest: BaseRequest, caseUuid: string, file: File, authToken?: string): Promise<UploadDocumentResponse>;
+    /**
+     * Submit a document against a handler document request (privacy center)
+     */
+    submitDocumentForRequest(baseRequest: BaseRequest, caseUuid: string, requestEventUuid: string, documentUuid: string, body: string, authToken?: string): Promise<CaseMessage>;
+    /**
+     * Get document info/download URL for a case document (privacy center)
+     */
+    getCaseDocument(baseRequest: BaseRequest, caseUuid: string, documentUuid: string, authToken?: string): Promise<MessageDocument>;
+};
+
+type Workspace = {
+    uuid: string;
+    suid: string;
+    name: string;
+    description: string;
+    workspace_type: string;
+    status: string;
+};
+type OrganizationDetail = {
+    uuid: string;
+    suid: string;
+    name: string;
+    slug: string;
+    description: string;
+    domain: string;
+    workspaces: Workspace[];
+    ai_summary: Record<string, unknown>;
+    icon_url: string | null;
+    activated: boolean;
+    allowed_domains: string[];
+};
+type OrganizationResponse = {
+    code: number;
+    status: string;
+    detail: OrganizationDetail;
+};
+type DataElement = {
+    uuid: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+    required: boolean;
+    given_consent: boolean;
+    selected: boolean;
+};
+type Purpose = {
+    uuid: string;
+    name: string;
+    description: string;
+    industries: string;
+    selected: boolean;
+    given_consent: boolean;
+    data_elements: DataElement[];
+    status?: string;
+    validity?: number | null;
+    purpose_uuid?: string;
+    enabled?: boolean;
+};
+type RawPurposeWrapper = {
+    purpose: Purpose;
+};
+type GrievanceValue = 'consent_violation' | 'unlawful_processing' | 'data_breach';
+type GrievanceOptions = {
+    value: GrievanceValue;
+    label: string;
+};
+type FormData = {
+    uuid: string;
+    name: string;
+    contact: string;
+    grievance_options: GrievanceOptions[];
+    purposes: RawPurposeWrapper[];
+};
+type FormDataResponse = {
+    code: number;
+    detail: FormData;
+};
+declare enum RequestTypeEnum {
+    ACCESS = "ACCESS",
+    CORRECTION = "CORRECTION",
+    ERASURE = "erasure",
+    GRIEVANCE = "grievance",
+    NOMINATION = "nomination"
+}
+type NominationData = {
+    nominee_email: string;
+    nominee_mobile?: string;
+};
+type UpdatePurpose = {
+    purpose_uuid: string;
+    data_element_uuids: string[];
+};
+type UpdateCorrectionDataItem = {
+    name: string;
+    curr_value: string;
+    new_value: string;
+};
+declare enum GrievanceTypeEnum {
+    CONSENT_VIOLATION = "consent_violation",
+    UNLAWFUL_PROCESSING = "unlawful_processing",
+    DATA_BREACH = "data_breach"
+}
+type GrievanceTypeElement = {
+    grievance: GrievanceValue;
+};
+type UpdateRequestDetails = {
+    purposes: UpdatePurpose[];
+    correction_data: UpdateCorrectionDataItem[];
+    grievance_types?: GrievanceTypeElement[];
+    nomination_data?: NominationData;
+};
+type UserDataRequest = {
+    uuid: string;
+    name: string;
+    contact: string;
+    request_type: RequestTypeEnum;
+    supporting_docs_uuids: string[];
+    request_details: {
+        purposes: UpdatePurpose[];
+        correction_data: UpdateCorrectionDataItem[];
+        grievance_types: GrievanceTypeElement[];
+        nomination_data?: NominationData;
+    };
+    time_period: number | null;
+    requestor_note: string;
+    revoke_consent_on_fulfilment?: boolean;
+};
+type CreateCaseResponse = {
+    code: number;
+    status: string;
+    detail: {
+        uuid: string;
+        case_id: string;
+    };
+};
+type OtpResponse = {
+    uuid: string;
+    to: string;
+    channel: string;
+    expire_at: string;
+    success: boolean;
+    message: string;
+};
+type OtpVerificationResponse = {
+    token: string;
+    success: boolean;
+    message: string;
+};
+type TokenExchangeResponse = {
+    token: string;
+    refresh_token: string;
+    expires_at: string;
+    notice_uuid: string;
+};
+type FetchOrgParams = {
+    slug?: string;
+    name?: string;
+};
+type ConsentDataElement = {
+    uuid: string;
+    name: string;
+    enabled: boolean;
+    required: boolean;
+    selected: boolean;
+};
+type UserConsent = {
+    purpose_uuid?: string;
+    purpose: string;
+    purpose_description: string;
+    status: ConsentStatusEnum;
+    given_date: string;
+    valid_till: string;
+    method: string;
+    data_elements: ConsentDataElement[];
+    product_uuid?: string;
+    product_name?: string;
+    product_description?: string | null;
+    nominator_info?: NominatorInfo;
+};
+type NominatorInfo = {
+    org_user_id: string;
+    name: string | null;
+    uuid: string;
+    email: string | null;
+};
+type ConsentHistoryStatusSummary = {
+    total_purposes: number;
+    direct_purposes: number;
+    nominated_purposes: number;
+    nominee_purposes?: number;
+    active_purposes: number;
+    inactive_purposes: number;
+};
+type ProductConsentHistoryGroup = {
+    product_uuid: string;
+    product_name: string;
+    product_description: string | null;
+    purposes: UserConsent[];
+    total_purposes: number;
+    active_purposes: number;
+};
+type NominatedPurposesGroup = {
+    nominator_info: NominatorInfo;
+    product_groups: ProductConsentHistoryGroup[];
+};
+type Pagination = {
+    total_count: number;
+    offset: number;
+    limit: number;
+};
+type UserConsentDetail = {
+    data?: UserConsent[];
+    product_purpose_groups?: ProductConsentHistoryGroup[];
+    pagination: Pagination;
+    direct_product_groups?: ProductConsentHistoryGroup[];
+    user_status?: 'ACTIVE' | 'TRANSFERRED' | null;
+    nominated_purposes?: NominatedPurposesGroup[];
+    nominators?: NominatorInfo[];
+    status_summary?: ConsentHistoryStatusSummary | null;
+};
+type UserConsentResponse = {
+    code: number;
+    status: string;
+    detail: UserConsentDetail;
+};
+declare enum ConsentStatusEnum {
+    ACTIVE = "ACTIVE",
+    WITHDRAWN = "WITHDRAW",
+    EXPIRED = "EXPIRED",
+    DECLINED = "DECLINED"
+}
+type ConsentAction = 'revoke' | 'regrant' | 'renew';
+type ManageConsentResponse = {
+    code: number;
+    status: string;
+    detail: {
+        success: boolean;
+    };
+};
+type ManageConsentParams = {
+    organizationId: string;
+    workspaceId: string;
+    purposeId: string;
+    contact: string;
+    action: ConsentAction;
+    nominatorContact?: string;
+    dataElementUuids?: string[];
+};
+type Activity = {
+    activity_type: string;
+    activity_type_display?: string;
+    timestamp: string;
+    title: string;
+    title_display?: string;
+    description: string;
+    description_display?: string;
+    case_id?: string;
+    status?: 'Processing' | 'Completed' | 'Rejected';
+    status_display?: string;
+};
+type ActivityDetail = {
+    data: Activity[];
+    pagination: Pagination;
+};
+type ActivityResponse = {
+    code: number;
+    status: string;
+    detail: ActivityDetail;
+};
+type ActivityBadgeStatus$1 = 'success' | 'warning' | 'error' | 'info' | 'pending';
+type CaseRequestDetails = {
+    purposes: RawPurposeWrapper[];
+    correction_data: UpdateCorrectionDataItem[];
+    grievance_types?: GrievanceTypeElement[];
+    nomination_data?: NominationData;
+};
+type CaseRequest = {
+    uuid: string;
+    case_id: string;
+    status: string;
+    status_display?: string;
+    request_type: string;
+    request_type_display?: string;
+    description: string;
+    description_display?: string;
+    created_at: string;
+    completed_at?: string;
+    due_date?: string;
+    request_details?: CaseRequestDetails;
+};
+type CaseHistoryDetail = {
+    data: CaseRequest[];
+    pagination: Pagination;
+};
+type CaseHistoryResponse = {
+    code: number;
+    status: string;
+    detail: CaseRequest[];
+};
+type MessageType = 'message_sent' | 'document_requested' | 'document_submitted' | 'document_replaced' | 'document_replacement_requested' | 'document_approved' | 'document_rejected';
+type DocumentRequestStatus = 'pending' | 'under_review' | 'approved' | 'rejected' | 'replacement_requested';
+type FileUrlMap = {
+    url?: string;
+    download_url?: string;
+};
+type MessageDocument = {
+    uuid: string;
+    file_name: string | null;
+    content_type: string | null;
+    file_size: number | null;
+    file_url: FileUrlMap | null;
+};
+type DocumentRequestMetadata = {
+    title: string;
+    accepted_document: string;
+    document_request_status: DocumentRequestStatus;
+    document_request_uuid: string | null;
+    rejection_reason: string;
+};
+type CaseMessage = {
+    uuid: string;
+    case_uuid: string;
+    sender_role: 'data_fiduciary' | 'data_principal';
+    triggered_by_email: string;
+    created_at: string;
+    body: string;
+    document_uuids: string[];
+    documents: MessageDocument[];
+    message_type: MessageType;
+    document_request_metadata: DocumentRequestMetadata | null;
+};
+type UploadDocumentResponse = {
+    uuid: string;
+    suid: string;
+    file_name: string;
+    file_type: string;
+    content_type: string;
+    file_size: number;
+    created_at: string;
+    is_public: boolean;
+    file: string;
+    file_hash: string | null;
+    status: string;
+    allow_ai_processing: boolean;
+    metadata: Record<string, string> | null;
+};
+
+type InternalPage = 'consent-manager' | 'form' | 'activity' | 'case-details';
+interface NavigationContextType {
+    currentPage: InternalPage;
+    navigateTo: (page: InternalPage) => void;
+    selectedCase: CaseRequest | null;
+    setSelectedCase: (c: CaseRequest | null) => void;
+    pendingCaseUuid: string | null;
+}
+declare const NavigationProvider: ({ children, initialPage }: {
+    children: ReactNode;
+    initialPage?: InternalPage;
+}) => react_jsx_runtime.JSX.Element;
+declare const useInternalNavigation: () => NavigationContextType;
+
+interface RedactoPrivacyCenterProps {
+    baseUrl: string;
+    slug: string;
+    theme?: 'light' | 'dark';
+    accessToken: string;
+    refreshToken: string;
+    onError: (error: Error) => boolean;
+    initialPage?: InternalPage;
+    onBack?: 'back' | 'signout';
+}
+declare function RedactoPrivacyCenter({ baseUrl, slug, theme, accessToken, refreshToken, onError, initialPage, onBack, }: RedactoPrivacyCenterProps): react_jsx_runtime.JSX.Element;
+
+interface PrivacyCenterLayoutProps {
+    children: ReactNode;
+    defaultTheme?: 'light' | 'dark';
+    slug: string;
+    onBack?: 'back' | 'signout';
+}
+declare function PrivacyCenterLayout({ children, defaultTheme, slug, onBack }: PrivacyCenterLayoutProps): react_jsx_runtime.JSX.Element;
+
+declare function PrivacyCenterHomePage(): react_jsx_runtime.JSX.Element;
+
+declare function PrivacyCenterConsentManagerPage(): react_jsx_runtime.JSX.Element;
+
+declare function PrivacyCenterFormPage(): react_jsx_runtime.JSX.Element;
+
+declare function PrivacyCenterActivityPage(): react_jsx_runtime.JSX.Element;
+
+declare const PrivacyCenterCaseDetailsPage: () => react_jsx_runtime.JSX.Element | null;
+
+type AuthContextValue = Readonly<{
+    accessToken: string;
+    refreshToken: string;
+    onError: (error: Error) => boolean;
+    updateTokens: (accessToken: string, refreshToken?: string) => void;
+}>;
+type BaseUrlContextValue = Readonly<{
+    baseUrl: string;
+    consentClient: ReturnType<typeof createConsentClient>;
+}>;
+
+declare const BaseUrlProvider: ({ children, baseUrl, }: {
+    children: ReactNode;
+    baseUrl: string;
+}) => react_jsx_runtime.JSX.Element;
+declare const useBaseUrl: () => Readonly<{
+    baseUrl: string;
+    consentClient: ReturnType<typeof createConsentClient>;
+}>;
+
+declare function createOtpServer(email: string, organizationId: string, workspaceId: string, consentClient?: ReturnType<typeof createConsentClient>): Promise<OtpResponse>;
+declare function verifyOtpServer(otpId: string, otp: string, organizationId: string, workspaceId: string, consentClient?: ReturnType<typeof createConsentClient>): Promise<OtpVerificationResponse>;
+declare function exchangeTokenServer(token: string, consentClient?: ReturnType<typeof createConsentClient>): Promise<TokenExchangeResponse>;
+
+declare const getCookieValue: (name: string) => string | null;
+/**
+ * Set refresh token cookie with proper attributes
+ * @param refreshToken - The refresh token value to set
+ */
+declare const setRefreshTokenCookie: (refreshToken: string) => void;
+/**
+ * Decode JWT token and extract payload
+ * @param token - JWT token string
+ * @returns Decoded JWT payload or null if decoding fails
+ */
+declare const decodeJwtToken: (token: string) => {
+    organisation_uuid?: string;
+    organisation_name?: string;
+    workspace_uuid?: string;
+    [key: string]: any;
+} | null;
+/**
+ * Decode JWT payload and check if token is expired or will expire soon
+ * @param token - JWT token string
+ * @param bufferSeconds - Buffer time in seconds before expiration to consider token expired (default: 5 minutes)
+ * @returns true if token is expired, invalid, or will expire within buffer time; false if valid
+ */
+declare const isJwtExpired: (token: string, bufferSeconds?: number) => boolean;
+/**
+ * Check if user is authenticated in privacy center
+ * User is considered authenticated if both access_token and email exist in sessionStorage
+ */
+declare const isUserAuthenticated: (expectedSlug: string) => boolean;
+/**
+ * Get initial state for sign-in form visibility
+ * Returns true if window is undefined (SSR) or user is not authenticated
+ * @param slug - The organization slug to check authentication against
+ * @returns true if sign-in form should be shown, false otherwise
+ */
+declare const getInitialState: (slug: string) => boolean;
+/**
+ * Check authentication status and attempt token refresh if needed
+ * This function checks if the user is authenticated, validates JWT expiration,
+ * and attempts to refresh using the refresh token cookie if the token is expired or missing.
+ * @param expectedSlug - The organization slug to verify against
+ * @param organizationId - Optional organization ID (will be read from sessionStorage if not provided)
+ * @param workspaceId - Optional workspace ID (will be read from sessionStorage if not provided)
+ * @returns Promise<boolean> - true if authenticated with valid non-expired token, false otherwise
+ */
+declare const checkAndRefreshAuth: (expectedSlug: string, organizationId?: string, workspaceId?: string, consentClient?: BaseUrlContextValue["consentClient"]) => Promise<boolean>;
+/**
+ * Compare two email addresses (case-insensitive, handles URL encoding)
+ * @param email1 - First email (can be URL-encoded)
+ * @param email2 - Second email
+ * @returns true if emails match (case-insensitive), false otherwise
+ */
+declare const compareEmails: (email1: string | null, email2: string | null) => boolean;
+/**
+ * Sign out from privacy center only
+ * Clears privacy-center specific storage and cookies without touching Supabase auth
+ */
+declare const signOutPrivacyCenter: () => void;
+/**
+ * Ensure a valid access token is available before making API calls.
+ * This function checks if the current token is valid (not expired).
+ * If expired or missing, it attempts to refresh using the refresh token.
+ * If refresh fails (refresh token expired), it signs out and redirects to sign-in.
+ *
+ * @param organizationId - The organization UUID
+ * @param workspaceId - The workspace UUID
+ * @param slug - The organization slug for redirect
+ * @param authContext - Optional auth context values (accessToken, refreshToken, onError, updateTokens)
+ * @returns Promise<string | null> - Valid access token or null if auth failed
+ */
+declare const ensureValidToken: (organizationId?: string, workspaceId?: string, slug?: string, authContext?: {
+    accessToken?: string;
+    refreshToken?: string;
+    onError?: (error: Error) => boolean;
+    updateTokens?: (accessToken: string, refreshToken?: string) => void;
+}, consentClient?: BaseUrlContextValue["consentClient"]) => Promise<string | null>;
+type ActivityBadgeStatus = 'success' | 'warning' | 'error' | 'info' | 'pending';
+/**
+ * Get badge status based on activity type
+ */
+declare const getActivityTypeStatus: (activityType: string) => ActivityBadgeStatus;
+/**
+ * Format activity type for display
+ */
+declare const formatActivityType: (activityType: string) => string;
+
+interface AuthContext {
+    accessToken?: string;
+    refreshToken?: string;
+    onError?: (error: Error) => boolean;
+    updateTokens?: (accessToken: string, refreshToken?: string) => void;
+}
+
+declare const getFormData: (organizationId: string, workspaceId: string, contact: string, _isPopup?: boolean, useSessionAuth?: boolean, authContext?: AuthContext, consentClient?: BaseUrlContextValue["consentClient"], language?: string) => Promise<FormData | null>;
+declare const createCaseRequest: (organizationId: string, workspaceId: string, data: UserDataRequest, _isPopup?: boolean, useSessionAuth?: boolean, authContext?: AuthContext, consentClient?: BaseUrlContextValue["consentClient"]) => Promise<CreateCaseResponse | null>;
+declare const fetchProducts: (organizationId: string, workspaceId: string, skip?: number, limit?: number, authContext?: AuthContext, consentClient?: BaseUrlContextValue["consentClient"]) => Promise<Array<{
+    uuid: string;
+    name: string;
+    description?: string;
+}> | null>;
+declare const fetchUserConsents: (organizationId: string, workspaceId: string, contact: string, offset?: number, limit?: number, search?: string, status?: string, product_uuid?: string, authContext?: AuthContext, consentClient?: BaseUrlContextValue["consentClient"], language?: string) => Promise<UserConsentDetail | null>;
+declare const manageConsent: ({ organizationId, workspaceId, purposeId, contact, action, authContext, consentClient, nominatorContact, dataElementUuids, }: {
+    organizationId: string;
+    workspaceId: string;
+    purposeId: string;
+    contact: string;
+    action: "revoke" | "regrant" | "renew";
+    authContext?: AuthContext;
+    consentClient?: BaseUrlContextValue["consentClient"];
+    nominatorContact?: string;
+    dataElementUuids?: string[];
+}) => Promise<boolean | null>;
+declare const fetchActivities: (organizationId: string, workspaceId: string, offset?: number, limit?: number, authContext?: AuthContext, consentClient?: BaseUrlContextValue["consentClient"], language?: string) => Promise<ActivityDetail | null>;
+declare const fetchCaseHistory: (organizationId: string, workspaceId: string, contact: string, offset?: number, limit?: number, authContext?: AuthContext, consentClient?: BaseUrlContextValue["consentClient"], language?: string) => Promise<CaseHistoryDetail | null>;
+
+declare const useCaseHistory: (organizationId: string | undefined, workspaceId: string | undefined, contact: string | undefined, authContext?: AuthContext) => _tanstack_react_query.UseQueryResult<CaseRequest[], Error>;
+
+interface AuthProviderProps {
+    children: ReactNode;
+    accessToken: string;
+    refreshToken: string;
+    onError: (error: Error) => boolean;
+}
+declare const AuthProvider: ({ children, accessToken: initialAccessToken, refreshToken: initialRefreshToken, onError, }: AuthProviderProps) => react_jsx_runtime.JSX.Element;
+declare const useAuth: () => AuthContextValue;
+
+/**
+ * CSS Injection Utility for Privacy Center SDK
+ *
+ * Injects CSS that cannot be done with inline styles:
+ * - Keyframe animations
+ * - Pseudo-elements (::after, ::before)
+ * - Checkbox checked states
+ * - Focus states for form elements
+ */
+declare const injectPCStyles: () => void;
+
+export { type Activity, type ActivityBadgeStatus$1 as ActivityBadgeStatus, type ActivityDetail, type ActivityResponse, type ApiFetchOptions, type ApiResponse, type AuthContext, AuthProvider, type BaseRequest, BaseUrlProvider, type CaseHistoryDetail, type CaseHistoryResponse, type CaseRequest, type ConsentAction, type ConsentDataElement, type ConsentHistoryStatusSummary, ConsentStatusEnum, type CreateCaseResponse, type DataElement, type FetchOrgParams, type FormData, type FormDataResponse, type GrievanceOptions, type GrievanceTypeElement, GrievanceTypeEnum, type GrievanceValue, type InternalPage, type ManageConsentParams, type ManageConsentResponse, NavigationProvider, type NominatedPurposesGroup, type NominationData, type NominatorInfo, type OrganizationDetail, type OrganizationResponse, type OtpResponse, type OtpVerificationResponse, type Pagination, PrivacyCenterActivityPage, PrivacyCenterCaseDetailsPage, PrivacyCenterConsentManagerPage, PrivacyCenterFormPage, PrivacyCenterHomePage, PrivacyCenterLayout, type ProductConsentHistoryGroup, type Purpose, type RawPurposeWrapper, RedactoPrivacyCenter, RequestTypeEnum, type TokenExchangeResponse, type UpdateCorrectionDataItem, type UpdatePurpose, type UpdateRequestDetails, type UserConsent, type UserConsentDetail, type UserConsentResponse, type UserDataRequest, type Workspace, checkAndRefreshAuth, compareEmails, createCaseRequest, createConsentClient, createOtpServer as createOtp, decodeJwtToken, ensureValidToken, exchangeTokenServer as exchangeToken, fetchActivities, fetchCaseHistory, fetchProducts, fetchUserConsents, formatActivityType, getActivityTypeStatus, getCookieValue, getFormData, getInitialState, injectPCStyles, isJwtExpired, isUserAuthenticated, manageConsent, setRefreshTokenCookie, signOutPrivacyCenter, useAuth, useBaseUrl, useCaseHistory, useInternalNavigation, verifyOtpServer as verifyOtp };