@redacto.io/consent-sdk-react-native 5.0.0-beta.6 → 5.0.0-beta.8

package/README.md

@@ -64,6 +64,81 @@ pnpm add @tanstack/react-query i18next react-i18next dayjs \
 
 > **Note:** `react-native-svg` must be linked for native builds. Follow the [react-native-svg setup guide](https://github.com/software-mansion/react-native-svg#installation).
 
+## Sandbox Mode (No Backend Required)
+
+Sandbox mode lets you build and test a full consent PoC — **notice → Privacy Center → DSAR** — straight from your app, with **no backend and no token minting**. Instead of your server generating a JWT, you paste a **static sandbox token** into the SDK. Everything you create is recorded as test data, isolated from your live records.
+
+Going live is a config swap, not a rewrite: drop the sandbox props and pass a real JWT (see [Backend Server Setup](#backend-server-setup)).
+
+### 1. Get your sandbox credentials
+
+In the **Redacto Dashboard → API Keys → Sandbox** tab, copy:
+
+- your **Sandbox token** (a static string; it never expires and needs no refresh)
+- your **Organization ID** and **Workspace ID** (shown under *Workspace identifiers* on the same page)
+
+### 2. Collect consent
+
+Pass the sandbox `token`, org/workspace, and a test identity (`email`, `mobile`, or `ucic`). No `accessToken` is needed:
+
+```tsx
+import { RedactoNoticeConsent } from "@redacto.io/consent-sdk-react-native";
+
+<RedactoNoticeConsent
+  noticeId={NOTICE_UUID}
+  token={SANDBOX_TOKEN}
+  organisationUuid={ORG_UUID}
+  workspaceUuid={WORKSPACE_UUID}
+  email="test.user@example.com" // or `mobile`, or `ucic`
+  onAccept={() => console.log("consent recorded (test)")}
+  onDecline={() => {}}
+/>;
+```
+
+### 3. Manage consent & raise a DSAR
+
+Point the Privacy Center at the same sandbox token and test identity. The same test user can now review the consent from step 2, withdraw it, and file a DSAR — end to end, all as test data:
+
+```tsx
+import { RedactoPrivacyCenter } from "@redacto.io/consent-sdk-react-native/privacy-center";
+
+<RedactoPrivacyCenter
+  baseUrl={BASE_URL}
+  slug="acme-co"
+  token={SANDBOX_TOKEN}
+  organisationUuid={ORG_UUID}
+  workspaceUuid={WORKSPACE_UUID}
+  email="test.user@example.com" // or `mobile`, or `ucic`
+  onError={(error) => {
+    console.error(error);
+    return false;
+  }}
+/>;
+```
+
+### Sandbox props
+
+Both `RedactoNoticeConsent` and `RedactoPrivacyCenter` accept the same sandbox props:
+
+| Prop                        | Required     | Description                                                                          |
+| --------------------------- | ------------ | ----------------------------------------------------------------------------------- |
+| `token`                     | Yes          | Static sandbox token from the Dashboard. Its presence activates sandbox mode.        |
+| `organisationUuid`          | Yes          | Organization ID from the Dashboard.                                                 |
+| `workspaceUuid`             | Yes          | Workspace ID from the Dashboard.                                                    |
+| `email` / `mobile` / `ucic` | One required | The test subject. Precedence when more than one is set: `ucic` > `email` > `mobile`. |
+
+### How it works
+
+- The SDK sends the sandbox token as an `X-Consent-Token` header and the test identity inside each request (query params on reads, body on writes) — no JWT decode, no token refresh (a `401` fails fast).
+- The server records everything under `environment=test`, namespaced so sandbox data never mixes with — or reads — your live records.
+- Sandbox always talks to the consent server; it never routes to the Go ledger.
+
+### Going live
+
+Sandbox and production use the same components. To ship, remove the sandbox props and pass a real `accessToken` / `refreshToken` (JWT) minted by your backend — see [Backend Server Setup](#backend-server-setup) below. New records are then written as `environment=live`.
+
+> Sandbox is available on `RedactoNoticeConsent` and `RedactoPrivacyCenter`. The inline widget (`RedactoNoticeConsentInline`) is JWT-only.
+
 ## Backend Server Setup
 
 The SDK never talks to Redacto with your CMS API key directly — your backend acts as a token broker. Obtain your **CMS-API-Key** from the Redacto Dashboard, store it in your backend's environment, and expose two endpoints to your mobile app:

package/dist/{chunk-UVRSRLYW.mjs → chunk-B2TXWC2C.mjs}

@@ -49,8 +49,12 @@ function toLanguageCode(lang) {
   return (_c = (_b = (_a = codeByLabel.get(trimmed)) != null ? _a : codeByName.get(lower)) != null ? _b : codeByLower.get(lower)) != null ? _c : trimmed;
 }
 
+// src/shared/sandbox.ts
+var SANDBOX_TOKEN_HEADER = "X-Consent-Token";
+
 export {
   __require,
+  SANDBOX_TOKEN_HEADER,
   languageOptions,
   toLanguageCode
 };

package/dist/index.d.mts

@@ -28,8 +28,34 @@ type Settings$1 = {
 
 type Props$1 = Readonly<{
     noticeId: string;
-    accessToken: string;
-    refreshToken: string;
+    /**
+     * JWT access token. Optional so sandbox integrations (see `token`) can
+     * omit it. Required in the normal JWT flow.
+     */
+    accessToken?: string;
+    /** JWT refresh token. Optional; accepted for source-compat, currently unused. */
+    refreshToken?: string;
+    /**
+     * Sandbox PoC: a pasted static token. When set, the SDK runs against the
+     * sandbox with no JWT — it sends the single `X-Consent-Token` header, carries
+     * the acting identity (`email` || `mobile` || `ucic`) in each request's own
+     * payload, takes org/workspace from `organisationUuid`/`workspaceUuid`, and
+     * does no token refresh.
+     */
+    token?: string;
+    /** Sandbox test subject email (carried in the request payload when set). */
+    email?: string;
+    /** Sandbox test subject mobile (fallback subject when `email` is absent). */
+    mobile?: string;
+    /**
+     * Sandbox UCIC: the client's own user id / org_user_id, e.g. a UUID or
+     * customer code; optional third identifier alongside email/mobile.
+     */
+    ucic?: string;
+    /** Sandbox org UUID (replaces the JWT-decoded org in sandbox mode). */
+    organisationUuid?: string;
+    /** Sandbox workspace UUID (replaces the JWT-decoded workspace in sandbox mode). */
+    workspaceUuid?: string;
     baseUrl?: string;
     /** Go ledger base URL — serves check-consent and the consent write; omit to use the legacy consent server. */
     ledgerBaseUrl?: string;

package/dist/index.d.ts

@@ -28,8 +28,34 @@ type Settings$1 = {
 
 type Props$1 = Readonly<{
     noticeId: string;
-    accessToken: string;
-    refreshToken: string;
+    /**
+     * JWT access token. Optional so sandbox integrations (see `token`) can
+     * omit it. Required in the normal JWT flow.
+     */
+    accessToken?: string;
+    /** JWT refresh token. Optional; accepted for source-compat, currently unused. */
+    refreshToken?: string;
+    /**
+     * Sandbox PoC: a pasted static token. When set, the SDK runs against the
+     * sandbox with no JWT — it sends the single `X-Consent-Token` header, carries
+     * the acting identity (`email` || `mobile` || `ucic`) in each request's own
+     * payload, takes org/workspace from `organisationUuid`/`workspaceUuid`, and
+     * does no token refresh.
+     */
+    token?: string;
+    /** Sandbox test subject email (carried in the request payload when set). */
+    email?: string;
+    /** Sandbox test subject mobile (fallback subject when `email` is absent). */
+    mobile?: string;
+    /**
+     * Sandbox UCIC: the client's own user id / org_user_id, e.g. a UUID or
+     * customer code; optional third identifier alongside email/mobile.
+     */
+    ucic?: string;
+    /** Sandbox org UUID (replaces the JWT-decoded org in sandbox mode). */
+    organisationUuid?: string;
+    /** Sandbox workspace UUID (replaces the JWT-decoded workspace in sandbox mode). */
+    workspaceUuid?: string;
     baseUrl?: string;
     /** Go ledger base URL — serves check-consent and the consent write; omit to use the legacy consent server. */
     ledgerBaseUrl?: string;

package/dist/index.js

@@ -43,6 +43,67 @@ var import_react_native_svg3 = __toESM(require("react-native-svg"));
 // src/RedactoNoticeConsent/api/index.ts
 var import_jwt_decode = require("jwt-decode");
 
+// src/shared/sandbox.ts
+var SANDBOX_TOKEN_HEADER = "X-Consent-Token";
+
+// src/RedactoNoticeConsent/api/sandbox.ts
+var resolveSandboxAuth = (params) => {
+  var _a, _b, _c, _d, _e;
+  const token = (_a = params.token) == null ? void 0 : _a.trim();
+  if (!token) {
+    return null;
+  }
+  const organisationUuid = (_b = params.organisationUuid) == null ? void 0 : _b.trim();
+  const workspaceUuid = (_c = params.workspaceUuid) == null ? void 0 : _c.trim();
+  const ucic = (_d = params.sandboxUcic) == null ? void 0 : _d.trim();
+  const subject = (_e = params.sandboxSubject) == null ? void 0 : _e.trim();
+  if (!organisationUuid || !workspaceUuid) {
+    throw new Error(
+      "Sandbox mode requires organisationUuid and workspaceUuid props"
+    );
+  }
+  if (!ucic && !subject) {
+    throw new Error("Sandbox mode requires a UCIC, email, or mobile");
+  }
+  return { token, ucic, subject: subject != null ? subject : "", organisationUuid, workspaceUuid };
+};
+var resolveRequestAuth = (accessToken, sandboxParams, decodeTokenSafely2) => {
+  const sandbox = resolveSandboxAuth(sandboxParams);
+  if (sandbox) {
+    return {
+      organisationUuid: sandbox.organisationUuid,
+      workspaceUuid: sandbox.workspaceUuid,
+      sandbox
+    };
+  }
+  const decodedToken = accessToken ? decodeTokenSafely2(accessToken) : null;
+  if (!decodedToken) {
+    throw new Error("Invalid access token");
+  }
+  const { organisation_uuid, workspace_uuid } = decodedToken;
+  if (!organisation_uuid || !workspace_uuid) {
+    throw new Error("Invalid token: missing organization or workspace UUID");
+  }
+  return {
+    organisationUuid: organisation_uuid,
+    workspaceUuid: workspace_uuid,
+    sandbox: null
+  };
+};
+var buildAuthHeaders = (accessToken, sandbox) => {
+  if (sandbox) {
+    return { [SANDBOX_TOKEN_HEADER]: sandbox.token };
+  }
+  return { Authorization: `Bearer ${accessToken}` };
+};
+var sandboxBodyIdentity = (sandbox) => {
+  if (sandbox.ucic) {
+    return { org_user_id: sandbox.ucic };
+  }
+  return sandbox.subject.includes("@") ? { primary_email: sandbox.subject } : { primary_mobile: sandbox.subject };
+};
+var sandboxQueryIdentity = (sandbox) => sandboxBodyIdentity(sandbox);
+
 // src/constants.ts
 var DEFAULT_CONSENT_API_BASE_URL = "https://api.redacto.io/consent";
 
@@ -125,21 +186,19 @@ var fetchConsentContent = async ({
   specific_uuid,
   validate_against = "all",
   include_fully_consented_data = false,
-  signal
+  signal,
+  ...sandboxParams
 }) => {
-  if (!noticeId || !accessToken || !validate_against) {
-    throw new Error("noticeId and accessToken are required");
-  }
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
+  if (!noticeId || !validate_against) {
+    throw new Error("noticeId is required");
   }
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
+  if (!accessToken && !sandboxParams.token) {
+    throw new Error("accessToken or token is required");
   }
+  const { organisationUuid: ORGANISATION_UUID, workspaceUuid: WORKSPACE_UUID, sandbox } = resolveRequestAuth(accessToken, sandboxParams, decodeTokenSafely);
   const apiBaseUrl = baseUrl || DEFAULT_CONSENT_API_BASE_URL;
-  const cacheKey = `${accessToken}-${noticeId}-${validate_against}-${language}-${specific_uuid || ""}-${include_fully_consented_data}`;
+  const cacheIdentity = sandbox ? `sandbox:${sandbox.organisationUuid}:${sandbox.workspaceUuid}:${sandbox.ucic || sandbox.subject}` : accessToken;
+  const cacheKey = `${cacheIdentity}-${noticeId}-${validate_against}-${language}-${specific_uuid || ""}-${include_fully_consented_data}`;
   if (validate_against === "all" && !specific_uuid) {
     const cachedData = getCachedData(cacheKey);
     if (cachedData) {
@@ -156,10 +215,15 @@ var fetchConsentContent = async ({
   if (include_fully_consented_data) {
     url.searchParams.append("include_fully_consented_data", "true");
   }
+  if (sandbox) {
+    for (const [key, value] of Object.entries(sandboxQueryIdentity(sandbox))) {
+      url.searchParams.append(key, value);
+    }
+  }
   const response = await fetch(url.toString(), {
     method: "GET",
     headers: {
-      Authorization: `Bearer ${accessToken}`,
+      ...buildAuthHeaders(accessToken, sandbox),
       "Accept-Language": language,
       "Content-Type": "application/json"
     },
@@ -199,20 +263,17 @@ var submitConsentEvent = async ({
   guardianVerificationReference,
   selfDeclaredAdult,
   language,
-  signal
+  signal,
+  ...sandboxParams
 }) => {
-  if (!noticeUuid || !accessToken || !Array.isArray(purposes)) {
-    throw new Error("noticeUuid, accessToken, and purposes array are required");
-  }
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
+  if (!noticeUuid || !Array.isArray(purposes)) {
+    throw new Error("noticeUuid and purposes array are required");
   }
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
+  if (!accessToken && !sandboxParams.token) {
+    throw new Error("accessToken or token is required");
   }
-  const apiBaseUrl = ledgerBaseUrl || baseUrl || DEFAULT_CONSENT_API_BASE_URL;
+  const { organisationUuid: ORGANISATION_UUID, workspaceUuid: WORKSPACE_UUID, sandbox } = resolveRequestAuth(accessToken, sandboxParams, decodeTokenSafely);
+  const apiBaseUrl = (sandbox ? null : ledgerBaseUrl) || baseUrl || DEFAULT_CONSENT_API_BASE_URL;
   const validatedPurposes = purposes.map((purpose) => {
     if (!purpose.uuid) {
       throw new Error("Invalid purpose data: missing uuid");
@@ -238,15 +299,16 @@ var submitConsentEvent = async ({
     self_declared_adult: selfDeclaredAdult,
     language: toLanguageCode(language)
   };
+  const requestBody = sandbox ? { ...payload, ...sandboxBodyIdentity(sandbox) } : payload;
   const response = await fetch(
     `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/submit-consent`,
     {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${accessToken}`,
+        ...buildAuthHeaders(accessToken, sandbox),
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(payload),
+      body: JSON.stringify(requestBody),
       signal
     }
   );
@@ -272,28 +334,30 @@ var submitConsentEvent = async ({
 var fetchTTSAudioUrls = async ({
   accessToken,
   baseUrl,
+  ledgerBaseUrl,
   noticeUuid,
   language,
-  signal
+  signal,
+  ...sandboxParams
 }) => {
-  if (!accessToken || !noticeUuid || !language) {
-    throw new Error("accessToken, noticeUuid, and language are required");
-  }
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
-  }
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
+  if (!accessToken && !sandboxParams.token || !noticeUuid || !language) {
+    throw new Error("accessToken (or token), noticeUuid, and language are required");
   }
-  const apiBaseUrl = baseUrl || DEFAULT_CONSENT_API_BASE_URL;
+  const { organisationUuid: ORGANISATION_UUID, workspaceUuid: WORKSPACE_UUID, sandbox } = resolveRequestAuth(accessToken, sandboxParams, decodeTokenSafely);
+  const apiBaseUrl = (sandbox ? null : ledgerBaseUrl) || baseUrl || DEFAULT_CONSENT_API_BASE_URL;
   const normalizedLanguage = language === "en" || language === "EN" ? "English" : language;
-  const url = `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeUuid}/audio/${encodeURIComponent(normalizedLanguage)}`;
-  const response = await fetch(url, {
+  const url = new URL(
+    `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeUuid}/audio/${encodeURIComponent(normalizedLanguage)}`
+  );
+  if (sandbox) {
+    for (const [key, value] of Object.entries(sandboxQueryIdentity(sandbox))) {
+      url.searchParams.append(key, value);
+    }
+  }
+  const response = await fetch(url.toString(), {
     method: "GET",
     headers: {
-      Authorization: `Bearer ${accessToken}`,
+      ...buildAuthHeaders(accessToken, sandbox),
       Accept: "application/json",
       "Content-Type": "application/json"
     },
@@ -1800,6 +1864,12 @@ var RedactoNoticeConsent = ({
   noticeId,
   accessToken,
   refreshToken: _refreshToken,
+  token,
+  email,
+  mobile,
+  ucic,
+  organisationUuid,
+  workspaceUuid,
   baseUrl,
   ledgerBaseUrl,
   settings,
@@ -1815,6 +1885,16 @@ var RedactoNoticeConsent = ({
 }) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
   const { isMobile } = useResponsive();
+  const sandboxParams = (0, import_react2.useMemo)(
+    () => ({
+      token,
+      sandboxUcic: ucic,
+      sandboxSubject: email || mobile,
+      organisationUuid,
+      workspaceUuid
+    }),
+    [token, ucic, email, mobile, organisationUuid, workspaceUuid]
+  );
   const [content, setContent] = (0, import_react2.useState)(null);
   const [isLoading, setIsLoading] = (0, import_react2.useState)(true);
   const [isSubmitting, setIsSubmitting] = (0, import_react2.useState)(false);
@@ -1869,20 +1949,22 @@ var RedactoNoticeConsent = ({
     setIsLoading(true);
     setErrorMessage(null);
     try {
+      const noticeBaseUrl = ledgerBaseUrl && !applicationId && !token ? ledgerBaseUrl : baseUrl;
       const data = await fetchConsentContent({
         noticeId,
         accessToken,
-        baseUrl,
+        baseUrl: noticeBaseUrl,
         language: "English",
         validate_against: validateAgainst,
         include_fully_consented_data: includeFullyConsentedData,
         specific_uuid: applicationId,
-        signal: abortControllerRef.current.signal
+        signal: abortControllerRef.current.signal,
+        ...sandboxParams
       });
       const activeConfig2 = data.detail.active_config;
       let purposeSelections = data.detail.purpose_selections;
       let reconsentRequired = data.detail.reconsent_required || false;
-      if (ledgerBaseUrl && !applicationId) {
+      if (accessToken && ledgerBaseUrl && !applicationId && !token) {
         const ledgerStatus = await fetchNoticeConsentStatus({
           accessToken,
           ledgerBaseUrl,
@@ -1959,7 +2041,7 @@ var RedactoNoticeConsent = ({
     } finally {
       setIsLoading(false);
     }
-  }, [noticeId, accessToken, baseUrl, ledgerBaseUrl, validateAgainst, includeFullyConsentedData, applicationId, onAccept, onError]);
+  }, [noticeId, accessToken, sandboxParams, token, baseUrl, ledgerBaseUrl, validateAgainst, includeFullyConsentedData, applicationId, onAccept, onError]);
   (0, import_react2.useEffect)(() => {
     hasBootstrappedLanguageRef.current = false;
   }, [noticeId, accessToken]);
@@ -1980,8 +2062,10 @@ var RedactoNoticeConsent = ({
       const data = await fetchTTSAudioUrls({
         accessToken,
         baseUrl,
+        ledgerBaseUrl,
         noticeUuid: content.detail.active_config.notice_uuid,
-        language: selectedLanguage
+        language: selectedLanguage,
+        ...sandboxParams
       });
       const urls = {
         notice_text: data.detail.notice_text_audio_url,
@@ -2035,7 +2119,7 @@ var RedactoNoticeConsent = ({
       setTtsAudioUrls({});
       setIsTTSAvailable(false);
     }
-  }, [content, accessToken, baseUrl, selectedLanguage]);
+  }, [content, accessToken, sandboxParams, baseUrl, ledgerBaseUrl, selectedLanguage]);
   const clearPlaybackWatchers = (0, import_react2.useCallback)(() => {
     if (playbackSubscriptionRef.current) {
       playbackSubscriptionRef.current.remove();
@@ -2376,7 +2460,8 @@ var RedactoNoticeConsent = ({
         meta_data: applicationId ? { specific_uuid: applicationId } : void 0,
         guardianVerificationReference: verificationReferenceRef.current || void 0,
         selfDeclaredAdult: selfDeclaredAdult || void 0,
-        language: selectedLanguage
+        language: selectedLanguage,
+        ...sandboxParams
       });
       await stopAudio();
       clearApiCache();
@@ -2391,7 +2476,7 @@ var RedactoNoticeConsent = ({
     } finally {
       setIsSubmitting(false);
     }
-  }, [content, accessToken, baseUrl, ledgerBaseUrl, applicationId, selectedPurposes, selectedDataElements, selectedLanguage, stopAudio, onAccept, onError]);
+  }, [content, accessToken, sandboxParams, baseUrl, ledgerBaseUrl, applicationId, selectedPurposes, selectedDataElements, selectedLanguage, selfDeclaredAdult, stopAudio, onAccept, onError]);
   const handleDecline = (0, import_react2.useCallback)(() => {
     stopAudio();
     stopPolling();
@@ -2993,14 +3078,16 @@ var fetchConsentContent2 = async ({
   org_uuid,
   workspace_uuid,
   notice_uuid,
+  accessToken,
   baseUrl,
   language = "en",
   specific_uuid,
   signal
 }) => {
   const apiBaseUrl = baseUrl || DEFAULT_CONSENT_API_BASE_URL;
+  const noticesUrl = `${apiBaseUrl}/public/organisations/${org_uuid}/workspaces/${workspace_uuid}/notices`;
   const url = new URL(
-    `${apiBaseUrl}/public/organisations/${org_uuid}/workspaces/${workspace_uuid}/notices/get-notice/${notice_uuid}`
+    accessToken ? `${noticesUrl}/${notice_uuid}` : `${noticesUrl}/get-notice/${notice_uuid}`
   );
   if (specific_uuid) {
     url.searchParams.append("specific_uuid", specific_uuid);
@@ -3009,7 +3096,8 @@ var fetchConsentContent2 = async ({
     method: "GET",
     headers: {
       "Content-Type": "application/json",
-      "Accept-Language": language
+      "Accept-Language": language,
+      ...accessToken ? { Authorization: `Bearer ${accessToken}` } : {}
     },
     signal
   });
@@ -3450,11 +3538,13 @@ var RedactoConsentInlineComponent = ({
   const fetchNotice = (0, import_react3.useCallback)(async (signal) => {
     setIsLoading(true);
     setFetchError(null);
+    setHasAlreadyConsented(false);
     try {
       const consentContentData = await fetchConsentContent2({
         org_uuid,
         workspace_uuid,
         notice_uuid,
+        accessToken,
         baseUrl,
         language,
         specific_uuid: applicationId,
@@ -3504,7 +3594,7 @@ var RedactoConsentInlineComponent = ({
         setIsLoading(false);
       }
     }
-  }, [org_uuid, workspace_uuid, notice_uuid, baseUrl, language, applicationId, onError]);
+  }, [org_uuid, workspace_uuid, notice_uuid, accessToken, baseUrl, language, applicationId, onError]);
   (0, import_react3.useEffect)(() => {
     const controller = new AbortController();
     void fetchNotice(controller.signal);