@asgardeo/react 0.11.3 → 0.12.0

package/dist/index.js

@@ -886,11 +886,12 @@ var AsgardeoReactClient = class extends AsgardeoBrowserClient {
 var AsgardeoReactClient_default = AsgardeoReactClient;
 
 // src/hooks/useBrowserUrl.ts
-import { hasAuthParamsInUrl } from "@asgardeo/browser";
+import { hasAuthParamsInUrl, hasCalledForThisInstanceInUrl } from "@asgardeo/browser";
 var useBrowserUrl = () => {
   const hasAuthParams = (url, afterSignInUrl) => hasAuthParamsInUrl() && new URL(url.origin + url.pathname).toString() === new URL(afterSignInUrl).toString() || // authParams?.authorizationCode || // FIXME: These are sent externally. Need to see what we can do about this.
   url.searchParams.get("error") !== null;
-  return { hasAuthParams };
+  const hasCalledForThisInstance = (url, instanceId) => hasCalledForThisInstanceInUrl(instanceId, url.search);
+  return { hasAuthParams, hasCalledForThisInstance };
 };
 var useBrowserUrl_default = useBrowserUrl;
 
@@ -1550,7 +1551,7 @@ var AsgardeoProvider = ({
 }) => {
   const reRenderCheckRef = useRef(false);
   const asgardeo = useMemo6(() => new AsgardeoReactClient_default(instanceId), [instanceId]);
-  const { hasAuthParams } = useBrowserUrl_default();
+  const { hasAuthParams, hasCalledForThisInstance } = useBrowserUrl_default();
   const [user, setUser] = useState6(null);
   const [currentOrganization, setCurrentOrganization] = useState6(null);
   const [isSignedInSync, setIsSignedInSync] = useState6(false);
@@ -1689,7 +1690,7 @@ var AsgardeoProvider = ({
         return;
       }
       const currentUrl = new URL(window.location.href);
-      const hasAuthParamsResult = hasAuthParams(currentUrl, afterSignInUrl);
+      const hasAuthParamsResult = hasAuthParams(currentUrl, afterSignInUrl) && hasCalledForThisInstance(currentUrl, instanceId ?? 0);
       const isV2Platform = config.platform === Platform2.AsgardeoV2;
       if (hasAuthParamsResult) {
         try {
@@ -7854,7 +7855,134 @@ import {
   EmbeddedSignInFlowStatusV2 as EmbeddedSignInFlowStatusV22,
   EmbeddedSignInFlowTypeV2
 } from "@asgardeo/browser";
-import { useState as useState15, useEffect as useEffect12, useRef as useRef4 } from "react";
+import { useState as useState15, useEffect as useEffect13, useRef as useRef5 } from "react";
+
+// src/hooks/v2/useOAuthCallback.ts
+import { useEffect as useEffect12, useRef as useRef4 } from "react";
+function cleanupUrlParams() {
+  if (typeof window === "undefined") return;
+  const url = new URL(window.location.href);
+  url.searchParams.delete("code");
+  url.searchParams.delete("nonce");
+  url.searchParams.delete("state");
+  url.searchParams.delete("error");
+  url.searchParams.delete("error_description");
+  window.history.replaceState({}, "", url.toString());
+}
+function useOAuthCallback({
+  currentFlowId,
+  flowIdStorageKey = "asgardeo_flow_id",
+  isInitialized,
+  isSubmitting = false,
+  onComplete,
+  onError,
+  onFlowChange,
+  onProcessingStart,
+  onSubmit,
+  processedRef,
+  setFlowId,
+  tokenValidationAttemptedRef
+}) {
+  const internalRef = useRef4(false);
+  const oauthCodeProcessedRef = processedRef ?? internalRef;
+  useEffect12(() => {
+    if (!isInitialized || isSubmitting) {
+      return;
+    }
+    const urlParams = new URLSearchParams(window.location.search);
+    const code = urlParams.get("code");
+    const nonce = urlParams.get("nonce");
+    const state = urlParams.get("state");
+    const flowIdFromUrl = urlParams.get("flowId");
+    const error = urlParams.get("error");
+    const errorDescription = urlParams.get("error_description");
+    if (error) {
+      oauthCodeProcessedRef.current = true;
+      if (tokenValidationAttemptedRef) {
+        tokenValidationAttemptedRef.current = true;
+      }
+      onError?.(new Error(errorDescription || error || "OAuth authentication failed"));
+      cleanupUrlParams();
+      return;
+    }
+    if (!code || oauthCodeProcessedRef.current) {
+      return;
+    }
+    if (tokenValidationAttemptedRef?.current) {
+      return;
+    }
+    const storedFlowId = sessionStorage.getItem(flowIdStorageKey);
+    const flowIdToUse = currentFlowId || storedFlowId || flowIdFromUrl || state || null;
+    if (!flowIdToUse) {
+      oauthCodeProcessedRef.current = true;
+      onError?.(new Error("Invalid flow. Missing flowId."));
+      cleanupUrlParams();
+      return;
+    }
+    oauthCodeProcessedRef.current = true;
+    if (tokenValidationAttemptedRef) {
+      tokenValidationAttemptedRef.current = true;
+    }
+    onProcessingStart?.();
+    if (!currentFlowId && setFlowId) {
+      setFlowId(flowIdToUse);
+    }
+    (async () => {
+      try {
+        const payload = {
+          flowId: flowIdToUse,
+          inputs: {
+            code,
+            ...nonce && { nonce }
+          }
+        };
+        const response = await onSubmit(payload);
+        onFlowChange?.(response);
+        if (response?.flowStatus === "COMPLETE" || response?.status === "COMPLETE") {
+          onComplete?.();
+        }
+        if (response?.flowStatus === "ERROR" || response?.status === "ERROR") {
+          onError?.(response);
+        }
+        cleanupUrlParams();
+      } catch (err) {
+        onError?.(err);
+        cleanupUrlParams();
+      }
+    })();
+  }, [
+    isInitialized,
+    currentFlowId,
+    isSubmitting,
+    onSubmit,
+    onComplete,
+    onError,
+    onFlowChange,
+    setFlowId,
+    flowIdStorageKey
+  ]);
+}
+
+// src/utils/oauth.ts
+import { navigate as navigate4 } from "@asgardeo/browser";
+function initiateOAuthRedirect(redirectURL) {
+  const basePath = document.querySelector("base")?.getAttribute("href") || "";
+  let returnPath = window.location.pathname;
+  if (basePath && returnPath.startsWith(basePath)) {
+    returnPath = returnPath.slice(basePath.length) || "/";
+  }
+  const state = crypto.randomUUID();
+  sessionStorage.setItem(
+    `asgardeo_oauth_${state}`,
+    JSON.stringify({
+      path: returnPath,
+      timestamp: Date.now()
+    })
+  );
+  const redirectUrlObj = new URL(redirectURL);
+  redirectUrlObj.searchParams.set("state", state);
+  navigate4(redirectUrlObj.toString());
+}
 
 // src/utils/v2/passkey.ts
 import { AsgardeoRuntimeError as AsgardeoRuntimeError7, arrayBufferToBase64url, base64urlToArrayBuffer } from "@asgardeo/browser";
@@ -8027,9 +8155,9 @@ var SignIn = ({
     flowId: null,
     isActive: false
   });
-  const initializationAttemptedRef = useRef4(false);
-  const oauthCodeProcessedRef = useRef4(false);
-  const passkeyProcessedRef = useRef4(false);
+  const initializationAttemptedRef = useRef5(false);
+  const oauthCodeProcessedRef = useRef5(false);
+  const passkeyProcessedRef = useRef5(false);
   const setFlowId = (flowId) => {
     setCurrentFlowId(flowId);
     if (flowId) {
@@ -8062,7 +8190,6 @@ var SignIn = ({
       sessionStorage.setItem("asgardeo_auth_id", authId);
     }
   };
-  const resolveFlowId = (activeFlowId, state, flowIdFromUrl, storedFlowId) => activeFlowId || state || flowIdFromUrl || storedFlowId || null;
   const cleanupOAuthUrlParams = (includeNonce = false) => {
     if (!window?.location?.href) return;
     const url = new URL(window.location.href);
@@ -8104,7 +8231,7 @@ var SignIn = ({
         }
         const urlParams = getUrlParams2();
         handleAuthId(urlParams.authId);
-        window.location.href = redirectURL;
+        initiateOAuthRedirect(redirectURL);
         return true;
       }
     }
@@ -8157,7 +8284,7 @@ var SignIn = ({
       initializationAttemptedRef.current = false;
     }
   };
-  useEffect12(() => {
+  useEffect13(() => {
     const urlParams = getUrlParams2();
     if (urlParams.error) {
       handleOAuthError(urlParams.error, urlParams.errorDescription);
@@ -8254,37 +8381,19 @@ var SignIn = ({
   const handleError = (error) => {
     setError(error);
   };
-  useEffect12(() => {
-    const urlParams = getUrlParams2();
-    const storedFlowId = sessionStorage.getItem("asgardeo_flow_id");
-    if (urlParams.error) {
-      handleOAuthError(urlParams.error, urlParams.errorDescription);
-      oauthCodeProcessedRef.current = true;
-      return;
-    }
-    if (!urlParams.code || oauthCodeProcessedRef.current || isSubmitting) {
-      return;
-    }
-    const flowIdToUse = resolveFlowId(currentFlowId, urlParams.state, urlParams.flowId, storedFlowId);
-    if (!flowIdToUse || !signIn) {
-      return;
-    }
-    oauthCodeProcessedRef.current = true;
-    if (!currentFlowId) {
-      setFlowId(flowIdToUse);
-    }
-    const submitPayload = {
-      flowId: flowIdToUse,
-      inputs: {
-        code: urlParams.code,
-        ...urlParams.nonce && { nonce: urlParams.nonce }
-      }
-    };
-    handleSubmit(submitPayload).catch(() => {
-      cleanupOAuthUrlParams(true);
-    });
-  }, [isFlowInitialized, currentFlowId, isInitialized, isLoading, isSubmitting, signIn]);
-  useEffect12(() => {
+  useOAuthCallback({
+    currentFlowId,
+    isInitialized: isInitialized && !isLoading,
+    isSubmitting,
+    onError: (err) => {
+      clearFlowState();
+      setError(err instanceof Error ? err : new Error(String(err)));
+    },
+    onSubmit: async (payload) => handleSubmit({ flowId: payload.flowId, inputs: payload.inputs }),
+    processedRef: oauthCodeProcessedRef,
+    setFlowId
+  });
+  useEffect13(() => {
     if (!passkeyState.isActive || !passkeyState.challenge && !passkeyState.creationOptions || !passkeyState.flowId) {
       return;
     }
@@ -8423,7 +8532,7 @@ import {
   createPackageComponentLogger as createPackageComponentLogger6
 } from "@asgardeo/browser";
 import { cx as cx21 } from "@emotion/css";
-import { useEffect as useEffect13, useState as useState16, useCallback as useCallback10, useRef as useRef5 } from "react";
+import { useEffect as useEffect14, useState as useState16, useCallback as useCallback10, useRef as useRef6 } from "react";
 
 // src/components/presentation/auth/SignUp/v1/SignUpOptionFactory.tsx
 import { EmbeddedFlowComponentType as EmbeddedFlowComponentType2 } from "@asgardeo/browser";
@@ -9171,7 +9280,7 @@ var BaseSignUpContent = ({
   const [isLoading, setIsLoading] = useState16(false);
   const [isFlowInitialized, setIsFlowInitialized] = useState16(false);
   const [currentFlow, setCurrentFlow] = useState16(null);
-  const initializationAttemptedRef = useRef5(false);
+  const initializationAttemptedRef = useRef6(false);
   const extractFormFields = useCallback10(
     (components) => {
       const fields = [];
@@ -9457,7 +9566,7 @@ var BaseSignUpContent = ({
       handleSubmit
     ]
   );
-  useEffect13(() => {
+  useEffect14(() => {
     if (isInitialized && !isFlowInitialized && !initializationAttemptedRef.current) {
       initializationAttemptedRef.current = true;
       (async () => {
@@ -9558,7 +9667,7 @@ import {
   createPackageComponentLogger as createPackageComponentLogger7
 } from "@asgardeo/browser";
 import { cx as cx22 } from "@emotion/css";
-import { useEffect as useEffect14, useState as useState17, useCallback as useCallback11, useRef as useRef6 } from "react";
+import { useEffect as useEffect15, useState as useState17, useCallback as useCallback11, useRef as useRef7 } from "react";
 import { jsx as jsx68, jsxs as jsxs29 } from "react/jsx-runtime";
 var logger7 = createPackageComponentLogger7(
   "@asgardeo/react",
@@ -9600,8 +9709,8 @@ var BaseSignUpContent2 = ({
     flowId: null,
     isActive: false
   });
-  const initializationAttemptedRef = useRef6(false);
-  const passkeyProcessedRef = useRef6(false);
+  const initializationAttemptedRef = useRef7(false);
+  const passkeyProcessedRef = useRef7(false);
   const handleError = useCallback11(
     (error) => {
       const errorMessage = error?.failureReason || extractErrorMessage(error, t);
@@ -9889,7 +9998,7 @@ var BaseSignUpContent2 = ({
       setIsLoading(false);
     }
   };
-  useEffect14(() => {
+  useEffect15(() => {
     if (!passkeyState.isActive || !passkeyState.creationOptions || !passkeyState.flowId) {
       return;
     }
@@ -9995,7 +10104,7 @@ var BaseSignUpContent2 = ({
       state: urlParams.get("state")
     };
   };
-  useEffect14(() => {
+  useEffect15(() => {
     const urlParams = getUrlParams2();
     if (urlParams.code || urlParams.state) {
       return;
@@ -10257,7 +10366,7 @@ import { EmbeddedFlowType as EmbeddedFlowType5 } from "@asgardeo/browser";
 // src/components/presentation/auth/InviteUser/v2/BaseInviteUser.tsx
 import { EmbeddedFlowType as EmbeddedFlowType4 } from "@asgardeo/browser";
 import { cx as cx23 } from "@emotion/css";
-import { useCallback as useCallback12, useEffect as useEffect15, useRef as useRef7, useState as useState18 } from "react";
+import { useCallback as useCallback12, useEffect as useEffect16, useRef as useRef8, useState as useState18 } from "react";
 
 // src/components/presentation/auth/InviteUser/v2/BaseInviteUser.styles.ts
 import { css as css18 } from "@emotion/css";
@@ -10326,7 +10435,7 @@ var BaseInviteUser = ({
   const [inviteLink, setInviteLink] = useState18();
   const [inviteLinkCopied, setInviteLinkCopied] = useState18(false);
   const [isFormValid, setIsFormValid] = useState18(true);
-  const initializationAttemptedRef = useRef7(false);
+  const initializationAttemptedRef = useRef8(false);
   const handleError = useCallback12(
     (error) => {
       const errorMessage = error?.failureReason || extractErrorMessage(error, t, "components.inviteUser.errors.generic");
@@ -10484,7 +10593,7 @@ var BaseInviteUser = ({
     setInviteLinkCopied(false);
     initializationAttemptedRef.current = false;
   }, []);
-  useEffect15(() => {
+  useEffect16(() => {
     if (isInitialized && !isFlowInitialized && !initializationAttemptedRef.current) {
       initializationAttemptedRef.current = true;
       (async () => {
@@ -10511,7 +10620,7 @@ var BaseInviteUser = ({
       })();
     }
   }, [isInitialized, isFlowInitialized, onInitialize, onFlowChange, handleError, normalizeFlowResponseLocal]);
-  useEffect15(() => {
+  useEffect16(() => {
     if (currentFlow && isFlowInitialized) {
       const components2 = currentFlow.data?.components || [];
       if (components2.length > 0) {
@@ -10724,7 +10833,7 @@ import { useMemo as useMemo27 } from "react";
 
 // src/components/presentation/auth/AcceptInvite/v2/BaseAcceptInvite.tsx
 import { cx as cx24 } from "@emotion/css";
-import { useCallback as useCallback13, useEffect as useEffect16, useRef as useRef8, useState as useState19 } from "react";
+import { useCallback as useCallback13, useEffect as useEffect17, useRef as useRef9, useState as useState19 } from "react";
 
 // src/components/presentation/auth/AcceptInvite/v2/BaseAcceptInvite.styles.ts
 import { css as css19 } from "@emotion/css";
@@ -10795,7 +10904,7 @@ var BaseAcceptInvite = ({
   const [touchedFields, setTouchedFields] = useState19({});
   const [isFormValid, setIsFormValid] = useState19(true);
   const [completionTitle, setCompletionTitle] = useState19(void 0);
-  const tokenValidationAttemptedRef = useRef8(false);
+  const tokenValidationAttemptedRef = useRef9(false);
   const handleError = useCallback13(
     (error) => {
       const errorMessage = error?.failureReason || extractErrorMessage(error, t, "components.acceptInvite.errors.generic");
@@ -10827,6 +10936,38 @@ var BaseAcceptInvite = ({
     },
     [t, children]
   );
+  useOAuthCallback({
+    currentFlowId: flowId ?? null,
+    isInitialized: true,
+    onComplete: () => {
+      setIsComplete(true);
+      setIsValidatingToken(false);
+      onComplete?.();
+    },
+    onError: (error) => {
+      setIsTokenInvalid(true);
+      setIsValidatingToken(false);
+      handleError(error);
+    },
+    onFlowChange: (response) => {
+      onFlowChange?.(response);
+      if (response.flowStatus !== "COMPLETE") {
+        setCurrentFlow(response);
+        setFormValues({});
+        setFormErrors({});
+        setTouchedFields({});
+      }
+    },
+    onProcessingStart: () => {
+      setIsValidatingToken(true);
+    },
+    onSubmit: async (payload) => {
+      const rawResponse = await onSubmit(payload);
+      const response = normalizeFlowResponseLocal(rawResponse);
+      return response;
+    },
+    tokenValidationAttemptedRef
+  });
   const handleInputChange = useCallback13((name, value) => {
     setFormValues((prev) => ({ ...prev, [name]: value }));
     setFormErrors((prev) => {
@@ -10892,6 +11033,13 @@ var BaseAcceptInvite = ({
         const rawResponse = await onSubmit(payload);
         const response = normalizeFlowResponseLocal(rawResponse);
         onFlowChange?.(response);
+        if (response.type === "REDIRECTION") {
+          const redirectURL = response.data?.redirectURL || response?.redirectURL;
+          if (redirectURL && typeof window !== "undefined") {
+            initiateOAuthRedirect(redirectURL);
+            return;
+          }
+        }
         if (currentFlow?.data?.components || currentFlow?.data?.meta?.components) {
           const currentComponents = currentFlow.data.components || currentFlow.data.meta?.components || [];
           const heading = currentComponents.find(
@@ -10931,13 +11079,14 @@ var BaseAcceptInvite = ({
       normalizeFlowResponseLocal
     ]
   );
-  useEffect16(() => {
-    if (!flowId || !inviteToken || tokenValidationAttemptedRef.current) {
-      if (!flowId || !inviteToken) {
-        setIsValidatingToken(false);
-        setIsTokenInvalid(true);
-        handleError(new Error("Invalid invite link. Missing flowId or inviteToken."));
-      }
+  useEffect17(() => {
+    if (tokenValidationAttemptedRef.current) {
+      return;
+    }
+    if (!flowId || !inviteToken) {
+      setIsValidatingToken(false);
+      setIsTokenInvalid(true);
+      handleError(new Error("Invalid invite link. Missing flowId or inviteToken."));
       return;
     }
     tokenValidationAttemptedRef.current = true;
@@ -10945,6 +11094,9 @@ var BaseAcceptInvite = ({
       setIsValidatingToken(true);
       setApiError(null);
       try {
+        if (flowId) {
+          sessionStorage.setItem("asgardeo_flow_id", flowId);
+        }
         const payload = {
           flowId,
           inputs: {
@@ -11171,6 +11323,95 @@ var AcceptInvite = ({
 };
 var AcceptInvite_default = AcceptInvite;
 
+// src/components/auth/Callback/Callback.tsx
+import { navigate as browserNavigate } from "@asgardeo/browser";
+import { useEffect as useEffect18, useRef as useRef10 } from "react";
+var Callback = ({ onNavigate, onError }) => {
+  const processingRef = useRef10(false);
+  const navigate6 = (path) => {
+    if (onNavigate) {
+      onNavigate(path);
+    } else {
+      browserNavigate(path);
+    }
+  };
+  useEffect18(() => {
+    const processOAuthCallback = () => {
+      if (processingRef.current) {
+        return;
+      }
+      processingRef.current = true;
+      let returnPath = "/";
+      try {
+        const urlParams = new URLSearchParams(window.location.search);
+        const code = urlParams.get("code");
+        const state = urlParams.get("state");
+        const nonce = urlParams.get("nonce");
+        const oauthError = urlParams.get("error");
+        const errorDescription = urlParams.get("error_description");
+        if (!state) {
+          throw new Error("Missing OAuth state parameter - possible security issue");
+        }
+        const storedData = sessionStorage.getItem(`asgardeo_oauth_${state}`);
+        if (!storedData) {
+          if (oauthError) {
+            const errorMsg = errorDescription || oauthError || "OAuth authentication failed";
+            const err = new Error(errorMsg);
+            onError?.(err);
+            const params2 = new URLSearchParams();
+            params2.set("error", oauthError);
+            if (errorDescription) {
+              params2.set("error_description", errorDescription);
+            }
+            navigate6(`/?${params2.toString()}`);
+            return;
+          }
+          throw new Error("Invalid OAuth state - possible CSRF attack");
+        }
+        const { path, timestamp } = JSON.parse(storedData);
+        returnPath = path || "/";
+        const MAX_STATE_AGE = 6e5;
+        if (Date.now() - timestamp > MAX_STATE_AGE) {
+          sessionStorage.removeItem(`asgardeo_oauth_${state}`);
+          throw new Error("OAuth state expired - please try again");
+        }
+        sessionStorage.removeItem(`asgardeo_oauth_${state}`);
+        if (oauthError) {
+          const errorMsg = errorDescription || oauthError || "OAuth authentication failed";
+          const err = new Error(errorMsg);
+          onError?.(err);
+          const params2 = new URLSearchParams();
+          params2.set("error", oauthError);
+          if (errorDescription) {
+            params2.set("error_description", errorDescription);
+          }
+          navigate6(`${returnPath}?${params2.toString()}`);
+          return;
+        }
+        if (!code) {
+          throw new Error("Missing OAuth authorization code");
+        }
+        const params = new URLSearchParams();
+        params.set("code", code);
+        if (nonce) {
+          params.set("nonce", nonce);
+        }
+        navigate6(`${returnPath}?${params.toString()}`);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "OAuth callback processing failed";
+        console.error("OAuth callback error:", err);
+        onError?.(err instanceof Error ? err : new Error(errorMessage));
+        const params = new URLSearchParams();
+        params.set("error", "callback_error");
+        params.set("error_description", errorMessage);
+        navigate6(`${returnPath}?${params.toString()}`);
+      }
+    };
+    processOAuthCallback();
+  }, [onNavigate, onError]);
+  return null;
+};
+
 // src/components/presentation/User/BaseUser.tsx
 import { Fragment as Fragment13, jsx as jsx77 } from "react/jsx-runtime";
 var BaseUser = ({ user, children, fallback = null }) => {
@@ -14271,7 +14512,7 @@ var CreateOrganization = ({
 
 // src/components/presentation/OrganizationList/OrganizationList.tsx
 import { cx as cx33 } from "@emotion/css";
-import { useEffect as useEffect17, useState as useState29 } from "react";
+import { useEffect as useEffect19, useState as useState29 } from "react";
 
 // src/components/presentation/OrganizationList/BaseOrganizationList.tsx
 import { cx as cx32 } from "@emotion/css";
@@ -14729,7 +14970,7 @@ var OrganizationList = (props) => {
   const [allOrganizations, setAllOrganizations] = useState29({
     organizations: []
   });
-  useEffect17(() => {
+  useEffect19(() => {
     (async () => {
       setAllOrganizations(await getAllOrganizations2());
     })();
@@ -14750,7 +14991,7 @@ var OrganizationList_default = OrganizationList;
 
 // src/components/presentation/OrganizationProfile/OrganizationProfile.tsx
 import { createPackageComponentLogger as createPackageComponentLogger9 } from "@asgardeo/browser";
-import { useEffect as useEffect18, useState as useState32 } from "react";
+import { useEffect as useEffect20, useState as useState32 } from "react";
 
 // src/components/presentation/OrganizationProfile/BaseOrganizationProfile.tsx
 import { formatDate } from "@asgardeo/browser";
@@ -15661,7 +15902,7 @@ var OrganizationProfile = ({
       setOrganization(null);
     }
   };
-  useEffect18(() => {
+  useEffect20(() => {
     fetchOrganization();
   }, [baseUrl, organizationId]);
   const handleOrganizationUpdate = async (payload) => {
@@ -15811,7 +16052,7 @@ import {
   AsgardeoRuntimeError as AsgardeoRuntimeError9,
   http,
   getActiveTheme as getActiveTheme2,
-  navigate as navigate4,
+  navigate as navigate5,
   EmbeddedFlowComponentTypeV2,
   EmbeddedFlowActionVariantV2,
   EmbeddedFlowTextVariantV2,
@@ -15844,6 +16085,7 @@ export {
   BrandingProvider_default as BrandingProvider,
   BuildingAlt_default as BuildingAlt,
   Button_default as Button,
+  Callback,
   Card_default as Card,
   Checkbox_default as Checkbox,
   CircleAlert_default as CircleAlert,
@@ -15926,7 +16168,7 @@ export {
   getOrganization_default as getOrganization,
   getSchemas_default as getSchemas,
   http,
-  navigate4 as navigate,
+  navigate5 as navigate,
   updateMeProfile_default as updateMeProfile,
   updateOrganization_default as updateOrganization,
   useAsgardeo_default as useAsgardeo,