@redacto.io/consent-sdk-react 10.0.0-beta.9 → 10.0.0

package/src/RedactoPrivacyCenter/lib/api.ts

@@ -1,759 +0,0 @@
-import {
-  createCaseRequestServer,
-  fetchActivitiesServer,
-  fetchReceiptsServer,
-  fetchReceiptPdfServer,
-  fetchCaseHistoryServer,
-  fetchProductsServer,
-  fetchUserConsentsServer,
-  fetchGroupPurposesServer,
-  getFormDataServer,
-  manageConsentServer,
-  getCaseMessagesServer,
-  sendCaseMessageServer,
-  uploadCaseDocumentServer,
-  submitDocumentForRequestServer,
-  getCaseDocumentServer,
-  getNotificationsServer,
-  getNotificationSummaryServer,
-  getUnreadCountServer,
-  markNotificationReadServer,
-  markAllNotificationsReadServer,
-  acknowledgeNotificationServer,
-} from '../api/actions';
-import type { BaseUrlContextValue } from '../context/BaseUrlContext';
-import type {
-  ActivityDetail,
-  CaseHistoryDetail,
-  CaseMessage,
-  CreateCaseResponse,
-  FormData,
-  MessageDocument,
-  NotificationActionResponse,
-  NotificationListResponse,
-  NotificationQueryParams,
-  NotificationSummary,
-  UnreadCountResponse,
-  UploadDocumentResponse,
-  UserConsentDetail,
-  UserDataRequest,
-  GroupPurposesOut,
-  ReceiptEventType,
-  ReceiptPurposeStatus,
-} from './types';
-import { ensureValidToken } from './utils';
-
-// Auth context type for passing to API functions
-export interface AuthContext {
-  accessToken?: string;
-  refreshToken?: string;
-  onError?: (error: Error) => boolean;
-  updateTokens?: (accessToken: string, refreshToken?: string) => void;
-}
-
-// Re-export server actions for client components
-export {
-  createOtpServer as createOtp,
-  exchangeTokenServer as exchangeToken,
-  verifyOtpServer as verifyOtp,
-} from '../api/actions';
-
-// Re-export refreshOtpTokenServer for utils
-export { refreshOtpTokenServer } from '../api/actions';
-
-// Re-export types
-export type {
-  ActivityDetail,
-  CaseHistoryDetail,
-  CreateCaseResponse,
-  FormData,
-  OrganizationResponse,
-  OtpResponse,
-  OtpVerificationResponse,
-  TokenExchangeResponse,
-  UserConsentDetail,
-  UserDataRequest,
-} from './types';
-
-// Keep utility functions
-export { getCookieValue } from './utils';
-
-/**
- * Check if an error is an authentication/JWT related error
- */
-function isAuthError(error: any): boolean {
-  const errorMessage = error?.message || '';
-  return (
-    errorMessage.includes('401') ||
-    errorMessage.includes('JWT') ||
-    errorMessage.includes('expired') ||
-    errorMessage.includes('token') ||
-    errorMessage.includes('Unauthorized')
-  );
-}
-
-/**
- * Handle client-side auth errors by attempting token refresh
- * If refresh fails, signs out and redirects to sign-in
- * @returns true if token was refreshed successfully and caller should retry, false otherwise
- */
-async function handleClientAuthError(
-  error: any,
-  organizationId: string,
-  workspaceId: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<boolean> {
-  if (isAuthError(error)) {
-    // Try to get a fresh token
-    const newToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (newToken) {
-      // Token refresh succeeded - caller should retry with new token
-      return true;
-    }
-    // Token refresh failed - ensureValidToken already handled sign out and redirect
-    return false;
-  }
-  return false;
-}
-
-export const getFormData = async (
-  organizationId: string,
-  workspaceId: string,
-  contact: string,
-  _isPopup?: boolean,
-  useSessionAuth?: boolean,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient'],
-  language?: string
-): Promise<FormData | null> => {
-  try {
-    // If useSessionAuth is explicitly set to true (case management), use session auth
-    if (useSessionAuth) {
-      return await getFormDataServer(organizationId, workspaceId, contact, undefined, true, consentClient, language);
-    }
-
-    // Ensure we have a valid token before making the API call
-    const authToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!authToken) {
-      // ensureValidToken already handled sign out and redirect
-      return null;
-    }
-
-    const data = await getFormDataServer(
-      organizationId,
-      workspaceId,
-      contact,
-      authToken,
-      false,
-      consentClient,
-      language
-    );
-    return data;
-  } catch (error: any) {
-    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (shouldRetry) {
-      // Read from sessionStorage first (synchronously updated) then fall back to context
-      const newAuthToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      return await getFormDataServer(
-        organizationId,
-        workspaceId,
-        contact,
-        newAuthToken,
-        false,
-        consentClient,
-        language
-      );
-    }
-    console.error('Error fetching form data:', error);
-    if (error.message?.includes('404')) {
-      throw error;
-    }
-    return null;
-  }
-};
-
-/**
- * Public helper for creating a case request. Returns `null` on any
- * non-auth error (preserves the documented
- * `Promise<CreateCaseResponse | null>` contract the SDK exposes to
- * consumers) — does NOT throw. Auth errors trigger a single token
- * refresh + retry before falling through.
- */
-export const createCaseRequest = async (
-  organizationId: string,
-  workspaceId: string,
-  data: UserDataRequest,
-  _isPopup?: boolean,
-  useSessionAuth?: boolean,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<CreateCaseResponse | null> => {
-  try {
-    // If useSessionAuth is explicitly set to true (case management), use session auth
-    if (useSessionAuth) {
-      return await createCaseRequestServer(organizationId, workspaceId, data, undefined, true, consentClient);
-    }
-
-    // Ensure we have a valid token before making the API call
-    const authToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!authToken) {
-      // ensureValidToken already handled sign out and redirect
-      return null;
-    }
-
-    return await createCaseRequestServer(
-      organizationId,
-      workspaceId,
-      data,
-      authToken,
-      false,
-      consentClient
-    );
-  } catch (error: any) {
-    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (shouldRetry) {
-      // Read from sessionStorage first (synchronously updated) then fall back to context
-      const newAuthToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      try {
-        return await createCaseRequestServer(
-          organizationId,
-          workspaceId,
-          data,
-          newAuthToken,
-          false,
-          consentClient
-        );
-      } catch (retryError) {
-        // The post-refresh retry can still fail (network blip, 5xx,
-        // expired-again token). Honor the documented `Promise<… | null>`
-        // contract by swallowing here rather than letting the rethrow
-        // escape — callers (e.g. Form.tsx) rely on null-on-error.
-        console.error('Error creating case request after auth refresh:', retryError);
-        return null;
-      }
-    }
-    console.error('Error creating case request:', error);
-    return null;
-  }
-};
-
-export const fetchProducts = async (
-  organizationId: string,
-  workspaceId: string,
-  skip?: number,
-  limit?: number,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<Array<{ uuid: string; name: string; description?: string }> | null> => {
-  try {
-    // Ensure we have a valid token before making the API call
-    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!accessToken) {
-      // ensureValidToken already handled sign out and redirect
-      return null;
-    }
-
-    const result = await fetchProductsServer({
-      organizationId,
-      workspaceId,
-      skip,
-      limit,
-      authToken: accessToken,
-      consentClient,
-    });
-    return result;
-  } catch (error: any) {
-    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (shouldRetry) {
-      // Read from sessionStorage first (synchronously updated) then fall back to context
-      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      return await fetchProductsServer({
-        organizationId,
-        workspaceId,
-        skip,
-        limit,
-        authToken: newAccessToken || undefined,
-        consentClient,
-      });
-    }
-    console.error('Error fetching products:', error);
-    return null;
-  }
-};
-
-export type FetchUserConsentsParams = {
-  organizationId: string;
-  workspaceId: string;
-  offset?: number;
-  limit?: number;
-  nominatedOffset?: number;
-  nominatedLimit?: number;
-  search?: string;
-  status?: string;
-  product_uuid?: string;
-  language?: string;
-  authContext?: AuthContext;
-  consentClient?: BaseUrlContextValue['consentClient'];
-};
-
-export const fetchUserConsents = async (
-  params: FetchUserConsentsParams
-): Promise<UserConsentDetail | null> => {
-  const { organizationId, workspaceId, authContext, consentClient, ...rest } = params;
-  try {
-    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!accessToken) {
-      return null;
-    }
-
-    const result = await fetchUserConsentsServer({
-      organizationId,
-      workspaceId,
-      ...rest,
-      authToken: accessToken,
-      consentClient,
-    });
-    return result;
-  } catch (error: any) {
-    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (shouldRetry) {
-      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      return await fetchUserConsentsServer({
-        organizationId,
-        workspaceId,
-        ...rest,
-        authToken: newAccessToken || undefined,
-        consentClient,
-      });
-    }
-    console.error('Error fetching user consent data:', error);
-    return null;
-  }
-};
-
-export type FetchGroupPurposesParams = {
-  organizationId: string;
-  workspaceId: string;
-  productUuid: string;
-  offset?: number;
-  limit?: number;
-  status?: string;
-  search?: string;
-  language?: string;
-  nominatorUuid?: string;
-  authContext?: AuthContext;
-  consentClient?: BaseUrlContextValue['consentClient'];
-};
-
-export const fetchGroupPurposes = async (
-  params: FetchGroupPurposesParams
-): Promise<GroupPurposesOut | null> => {
-  const { organizationId, workspaceId, authContext, consentClient, ...rest } = params;
-  try {
-    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!accessToken) {
-      return null;
-    }
-
-    const result = await fetchGroupPurposesServer({
-      organizationId,
-      workspaceId,
-      ...rest,
-      authToken: accessToken,
-      consentClient,
-    });
-    return result;
-  } catch (error: any) {
-    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (shouldRetry) {
-      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      return await fetchGroupPurposesServer({
-        organizationId,
-        workspaceId,
-        ...rest,
-        authToken: newAccessToken || undefined,
-        consentClient,
-      });
-    }
-    console.error('Error fetching group purposes:', error);
-    return null;
-  }
-};
-
-export const manageConsent = async ({
-  organizationId,
-  workspaceId,
-  purposeId,
-  contact,
-  action,
-  authContext,
-  consentClient,
-  nominatorContact,
-  dataElementUuids,
-  productUuid,
-  noticeUuid,
-  dataElements,
-  language,
-}: {
-  organizationId: string;
-  workspaceId: string;
-  purposeId: string;
-  contact: string;
-  action: 'revoke' | 'regrant' | 'renew';
-  authContext?: AuthContext;
-  consentClient?: BaseUrlContextValue['consentClient'];
-  nominatorContact?: string;
-  dataElementUuids?: string[];
-  productUuid?: string;
-  noticeUuid?: string;
-  dataElements?: Array<{ uuid: string; selected: boolean }>;
-  language?: string;
-}): Promise<boolean | null> => {
-  try {
-    // Ensure we have a valid token before making the API call
-    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!accessToken) {
-      // ensureValidToken already handled sign out and redirect
-      return null;
-    }
-
-    const result = await manageConsentServer({
-      organizationId,
-      workspaceId,
-      purposeId,
-      contact,
-      action,
-      authToken: accessToken,
-      consentClient,
-      nominatorContact,
-      dataElementUuids,
-      productUuid,
-      noticeUuid,
-      dataElements,
-      language,
-    });
-    return result;
-  } catch (error: any) {
-    // Re-throw nominator-specific errors (stable code) so the UI can show targeted messages
-    if (error?.name === 'ConsentApiError') {
-      throw error;
-    }
-    // Auth errors (401) mean the request was rejected before processing, so a single retry is safe
-    const recovered = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (recovered) {
-      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      return await manageConsentServer({
-        organizationId,
-        workspaceId,
-        purposeId,
-        contact,
-        action,
-        authToken: newAccessToken || undefined,
-        consentClient,
-        nominatorContact,
-        dataElementUuids,
-        productUuid,
-        noticeUuid,
-        dataElements,
-      });
-    }
-    console.error(`Error ${action} consent:`, error);
-    return null;
-  }
-};
-
-export const fetchActivities = async (
-  organizationId: string,
-  workspaceId: string,
-  offset?: number,
-  limit?: number,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient'],
-  language?: string
-): Promise<ActivityDetail | null> => {
-  try {
-    // Ensure we have a valid token before making the API call
-    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!accessToken) {
-      // ensureValidToken already handled sign out and redirect
-      return null;
-    }
-
-    const result = await fetchActivitiesServer({
-      organizationId,
-      workspaceId,
-      offset,
-      limit,
-      language,
-      authToken: accessToken,
-      consentClient,
-    });
-    return result;
-  } catch (error: any) {
-    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (shouldRetry) {
-      // Read from sessionStorage first (synchronously updated) then fall back to context
-      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      return await fetchActivitiesServer({
-        organizationId,
-        workspaceId,
-        offset,
-        limit,
-        language,
-        authToken: newAccessToken || undefined,
-        consentClient,
-      });
-    }
-    console.error('Error fetching activities:', error);
-    return null;
-  }
-};
-
-export const fetchCaseHistory = async (
-  organizationId: string,
-  workspaceId: string,
-  contact: string,
-  offset?: number,
-  limit?: number,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient'],
-  language?: string
-): Promise<CaseHistoryDetail | null> => {
-  try {
-    // Ensure we have a valid token before making the API call
-    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!accessToken) {
-      // ensureValidToken already handled sign out and redirect
-      return null;
-    }
-
-    const result = await fetchCaseHistoryServer({
-      organizationId,
-      workspaceId,
-      contact,
-      offset,
-      limit,
-      language,
-      authToken: accessToken,
-      consentClient,
-    });
-    return result;
-  } catch (error: any) {
-    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (shouldRetry) {
-      // Read from sessionStorage first (synchronously updated) then fall back to context
-      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      return await fetchCaseHistoryServer({
-        organizationId,
-        workspaceId,
-        contact,
-        offset,
-        limit,
-        language,
-        authToken: newAccessToken || undefined,
-        consentClient,
-      });
-    }
-    console.error('Error fetching case history: ', error);
-    return null;
-  }
-};
-
-// ─── Auth-retry helper ──────────────────────────────────────────────────────
-
-/**
- * Wraps an API call with token acquisition and single-retry-on-auth-error logic.
- * `fn` receives a valid access token and returns the API result.
- */
-async function withAuthRetry<T>(
-  organizationId: string,
-  workspaceId: string,
-  authContext: AuthContext | undefined,
-  consentClient: BaseUrlContextValue['consentClient'] | undefined,
-  errorLabel: string,
-  fn: (token: string) => Promise<T>
-): Promise<T | null> {
-  try {
-    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
-    if (!accessToken) return null;
-    return await fn(accessToken);
-  } catch (error: any) {
-    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
-    if (shouldRetry) {
-      const token = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
-      return await fn(token);
-    }
-    console.error(errorLabel, error);
-    return null;
-  }
-}
-
-// ─── Case Communication ──────────────────────────────────────────────────────
-
-export const getCaseMessages = async (
-  organizationId: string,
-  workspaceId: string,
-  caseUuid: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<CaseMessage[] | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error fetching case messages:', (token) =>
-    getCaseMessagesServer({ organizationId, workspaceId, caseUuid, authToken: token, consentClient })
-  );
-
-export const sendCaseMessage = async (
-  organizationId: string,
-  workspaceId: string,
-  caseUuid: string,
-  body: string,
-  documentUuids: string[],
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<CaseMessage | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error sending case message:', (token) =>
-    sendCaseMessageServer({ organizationId, workspaceId, caseUuid, body, documentUuids, authToken: token, consentClient })
-  );
-
-export const uploadCaseDocument = async (
-  organizationId: string,
-  workspaceId: string,
-  caseUuid: string,
-  file: File,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<UploadDocumentResponse | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error uploading case document:', (token) =>
-    uploadCaseDocumentServer({ organizationId, workspaceId, caseUuid, file, authToken: token, consentClient })
-  );
-
-export const submitDocumentForRequest = async (
-  organizationId: string,
-  workspaceId: string,
-  caseUuid: string,
-  requestEventUuid: string,
-  documentUuid: string,
-  body: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<CaseMessage | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error submitting document for request:', (token) =>
-    submitDocumentForRequestServer({ organizationId, workspaceId, caseUuid, requestEventUuid, documentUuid, body, authToken: token, consentClient })
-  );
-
-export const getCaseDocument = async (
-  organizationId: string,
-  workspaceId: string,
-  caseUuid: string,
-  documentUuid: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<MessageDocument | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error fetching case document:', (token) =>
-    getCaseDocumentServer({ organizationId, workspaceId, caseUuid, documentUuid, authToken: token, consentClient })
-  );
-
-// ─── Receipts ────────────────────────────────────────────────────────────────
-
-export type FetchReceiptsParams = {
-  skip?: number;
-  limit?: number;
-  notice_uuid?: string;
-  event_type?: ReceiptEventType;
-  status?: ReceiptPurposeStatus;
-  created_after?: string;
-  created_before?: string;
-  language?: string;
-};
-
-export const fetchReceipts = async (
-  organizationId: string,
-  workspaceId: string,
-  params?: FetchReceiptsParams,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient'],
-): Promise<unknown | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error fetching receipts:', (token) =>
-    fetchReceiptsServer({ organizationId, workspaceId, ...params, authToken: token, consentClient })
-  );
-
-/**
- * Download a single receipt as a PDF Blob. The UI builds an object URL from the
- * Blob to open/save it (PDF UI is a later pass; the SDK function is ready now).
- */
-export const fetchReceiptPdf = async (
-  organizationId: string,
-  workspaceId: string,
-  receiptUuid: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient'],
-): Promise<Blob | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error downloading receipt PDF:', (token) =>
-    fetchReceiptPdfServer({ organizationId, workspaceId, receiptUuid, authToken: token, consentClient })
-  );
-
-// ─── Notification Hub ───────────────────────────────────────────────────────
-
-export const fetchNotifications = async (
-  organizationId: string,
-  workspaceId: string,
-  params?: NotificationQueryParams,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient'],
-  language?: string,
-): Promise<NotificationListResponse | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error fetching notifications:', (token) =>
-    getNotificationsServer({ organizationId, workspaceId, ...params, language, authToken: token, consentClient })
-  );
-
-export const fetchNotificationSummary = async (
-  organizationId: string,
-  workspaceId: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<NotificationSummary | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error fetching notification summary:', (token) =>
-    getNotificationSummaryServer({ organizationId, workspaceId, authToken: token, consentClient })
-  );
-
-export const fetchUnreadCount = async (
-  organizationId: string,
-  workspaceId: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<UnreadCountResponse | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error fetching unread count:', (token) =>
-    getUnreadCountServer({ organizationId, workspaceId, authToken: token, consentClient })
-  );
-
-export const markNotificationRead = async (
-  organizationId: string,
-  workspaceId: string,
-  notificationUuid: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<NotificationActionResponse | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error marking notification as read:', (token) =>
-    markNotificationReadServer({ organizationId, workspaceId, notificationUuid, authToken: token, consentClient })
-  );
-
-export const markAllRead = async (
-  organizationId: string,
-  workspaceId: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<NotificationActionResponse | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error marking all notifications as read:', (token) =>
-    markAllNotificationsReadServer({ organizationId, workspaceId, authToken: token, consentClient })
-  );
-
-export const acknowledgeNotification = async (
-  organizationId: string,
-  workspaceId: string,
-  notificationUuid: string,
-  authContext?: AuthContext,
-  consentClient?: BaseUrlContextValue['consentClient']
-): Promise<NotificationActionResponse | null> =>
-  withAuthRetry(organizationId, workspaceId, authContext, consentClient, 'Error acknowledging notification:', (token) =>
-    acknowledgeNotificationServer({ organizationId, workspaceId, notificationUuid, authToken: token, consentClient })
-  );