@asgardeo/javascript 0.0.1 → 0.1.0

package/dist/cjs/index.js

@@ -21,132 +21,183 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ASGARDEO_SESSION_ACTIVE: () => ASGARDEO_SESSION_ACTIVE,
+  ApplicationNativeAuthenticationAuthenticatorKnownIdPType: () => ApplicationNativeAuthenticationAuthenticatorKnownIdPType,
+  ApplicationNativeAuthenticationAuthenticatorParamType: () => ApplicationNativeAuthenticationAuthenticatorParamType,
+  ApplicationNativeAuthenticationAuthenticatorPromptType: () => ApplicationNativeAuthenticationAuthenticatorPromptType,
+  ApplicationNativeAuthenticationConstants: () => ApplicationNativeAuthenticationConstants_default,
+  ApplicationNativeAuthenticationFlowStatus: () => ApplicationNativeAuthenticationFlowStatus,
+  ApplicationNativeAuthenticationFlowType: () => ApplicationNativeAuthenticationFlowType,
+  ApplicationNativeAuthenticationStepType: () => ApplicationNativeAuthenticationStepType,
   AsgardeoAPIError: () => AsgardeoAPIError,
   AsgardeoAuthClient: () => AsgardeoAuthClient,
   AsgardeoAuthException: () => AsgardeoAuthException,
   AsgardeoError: () => AsgardeoError,
   AsgardeoJavaScriptClient: () => AsgardeoJavaScriptClient_default,
   AsgardeoRuntimeError: () => AsgardeoRuntimeError,
-  DataLayer: () => DataLayer,
+  FieldType: () => FieldType,
   IsomorphicCrypto: () => IsomorphicCrypto,
   OIDCRequestConstants: () => OIDCRequestConstants_default,
-  ResponseMode: () => ResponseMode,
+  StorageManager: () => StorageManager_default,
   TokenConstants: () => TokenConstants_default,
   WellKnownSchemaIds: () => WellKnownSchemaIds,
   createTheme: () => createTheme_default,
+  deepMerge: () => deepMerge_default,
   extractPkceStorageKeyFromState: () => extractPkceStorageKeyFromState_default,
   extractUserClaimsFromIdToken: () => extractUserClaimsFromIdToken_default,
+  flattenUserSchema: () => flattenUserSchema_default,
+  generateFlattenedUserProfile: () => generateFlattenedUserProfile_default,
+  generateUserProfile: () => generateUserProfile_default,
+  get: () => get_default,
+  getI18nBundles: () => getI18nBundles_default,
+  getLatestStateParam: () => getLatestStateParam_default,
   getUserInfo: () => getUserInfo_default,
-  removeTrailingSlash: () => removeTrailingSlash_default
+  handleApplicationNativeAuthentication: () => handleApplicationNativeAuthentication_default,
+  initializeApplicationNativeAuthentication: () => initializeApplicationNativeAuthentication_default,
+  processOpenIDScopes: () => processOpenIDScopes_default,
+  removeTrailingSlash: () => removeTrailingSlash_default,
+  resolveFieldName: () => resolveFieldName_default,
+  resolveFieldType: () => resolveFieldType_default,
+  set: () => set_default
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/constants/PKCEConstants.ts
-var PKCEConstants = {
-  /**
-   * Storage-related constants for managing PKCE state
-   */
-  Storage: {
-    /**
-     * Collection of storage keys used in PKCE implementation
-     */
-    StorageKeys: {
-      /**
-       * Key used to store the PKCE code verifier in temporary storage.
-       * The code verifier is a cryptographically random string that is
-       * used to generate the code challenge.
-       */
-      CODE_VERIFIER: "pkce_code_verifier",
-      /**
-       * Separator used in storage keys to create unique identifiers
-       * by combining different parts of the key.
-       */
-      SEPARATOR: "#"
+// src/StorageManager.ts
+var ASGARDEO_SESSION_ACTIVE = "asgardeo-session-active";
+var StorageManager = class {
+  constructor(instanceID, store) {
+    __publicField(this, "_id");
+    __publicField(this, "_store");
+    this._id = instanceID;
+    this._store = store;
+  }
+  async setDataInBulk(key, data) {
+    const existingDataJSON = await this._store.getData(key) ?? null;
+    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
+    const dataToBeSaved = { ...existingData, ...data };
+    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
+    await this._store.setData(key, dataToBeSavedJSON);
+  }
+  async setValue(key, attribute, value) {
+    const existingDataJSON = await this._store.getData(key) ?? null;
+    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
+    const dataToBeSaved = { ...existingData, [attribute]: value };
+    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
+    await this._store.setData(key, dataToBeSavedJSON);
+  }
+  async removeValue(key, attribute) {
+    const existingDataJSON = await this._store.getData(key) ?? null;
+    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
+    const dataToBeSaved = { ...existingData };
+    delete dataToBeSaved[attribute];
+    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
+    await this._store.setData(key, dataToBeSavedJSON);
+  }
+  _resolveKey(store, userId) {
+    return userId ? `${store}-${this._id}-${userId}` : `${store}-${this._id}`;
+  }
+  isLocalStorageAvailable() {
+    try {
+      const testValue = "__ASGARDEO_AUTH_CORE_LOCAL_STORAGE_TEST__";
+      localStorage.setItem(testValue, testValue);
+      localStorage.removeItem(testValue);
+      return true;
+    } catch (error) {
+      return false;
     }
   }
-};
-var PKCEConstants_default = PKCEConstants;
-
-// src/utils/extractPkceStorageKeyFromState.ts
-var extractPkceStorageKeyFromState = (state) => {
-  const index = parseInt(state.split("request_")[1]);
-  return `${PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER}${PKCEConstants_default.Storage.StorageKeys.SEPARATOR}${index}`;
-};
-var extractPkceStorageKeyFromState_default = extractPkceStorageKeyFromState;
-
-// src/utils/generateStateParamForRequestCorrelation.ts
-var generateStateParamForRequestCorrelation = (pkceKey, state) => {
-  const index = parseInt(pkceKey.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1]);
-  return state ? `${state}_request_${index}` : `request_${index}`;
-};
-var generateStateParamForRequestCorrelation_default = generateStateParamForRequestCorrelation;
-
-// src/__legacy__/exception/exception.ts
-var AsgardeoAuthException = class {
-  constructor(code, name, message) {
-    __publicField(this, "name");
-    __publicField(this, "code");
-    __publicField(this, "message");
-    this.message = message;
-    this.name = name;
-    this.code = code;
-    Object.setPrototypeOf(this, new.target.prototype);
+  async setConfigData(config) {
+    await this.setDataInBulk(this._resolveKey("config_data" /* ConfigData */), config);
+  }
+  async setOIDCProviderMetaData(oidcProviderMetaData) {
+    this.setDataInBulk(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), oidcProviderMetaData);
+  }
+  async setTemporaryData(temporaryData, userId) {
+    this.setDataInBulk(this._resolveKey("temporary_data" /* TemporaryData */, userId), temporaryData);
+  }
+  async setSessionData(sessionData, userId) {
+    this.setDataInBulk(this._resolveKey("session_data" /* SessionData */, userId), sessionData);
+  }
+  async setCustomData(key, customData, userId) {
+    this.setDataInBulk(this._resolveKey(key, userId), customData);
+  }
+  async getConfigData() {
+    return JSON.parse(await this._store.getData(this._resolveKey("config_data" /* ConfigData */)) ?? null);
+  }
+  async loadOpenIDProviderConfiguration() {
+    return JSON.parse(await this._store.getData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */)) ?? null);
+  }
+  async getTemporaryData(userId) {
+    return JSON.parse(await this._store.getData(this._resolveKey("temporary_data" /* TemporaryData */, userId)) ?? null);
+  }
+  async getSessionData(userId) {
+    return JSON.parse(await this._store.getData(this._resolveKey("session_data" /* SessionData */, userId)) ?? null);
+  }
+  async getCustomData(key, userId) {
+    return JSON.parse(await this._store.getData(this._resolveKey(key, userId)) ?? null);
+  }
+  setSessionStatus(status) {
+    this.isLocalStorageAvailable() && localStorage.setItem(`${ASGARDEO_SESSION_ACTIVE}`, status);
+  }
+  getSessionStatus() {
+    return this.isLocalStorageAvailable() ? localStorage.getItem(`${ASGARDEO_SESSION_ACTIVE}`) ?? "" : "";
+  }
+  removeSessionStatus() {
+    this.isLocalStorageAvailable() && localStorage.removeItem(`${ASGARDEO_SESSION_ACTIVE}`);
+  }
+  async removeConfigData() {
+    await this._store.removeData(this._resolveKey("config_data" /* ConfigData */));
+  }
+  async removeOIDCProviderMetaData() {
+    await this._store.removeData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */));
+  }
+  async removeTemporaryData(userId) {
+    await this._store.removeData(this._resolveKey("temporary_data" /* TemporaryData */, userId));
+  }
+  async removeSessionData(userId) {
+    await this._store.removeData(this._resolveKey("session_data" /* SessionData */, userId));
+  }
+  async getConfigDataParameter(key) {
+    const data = await this._store.getData(this._resolveKey("config_data" /* ConfigData */));
+    return data && JSON.parse(data)[key];
+  }
+  async getOIDCProviderMetaDataParameter(key) {
+    const data = await this._store.getData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */));
+    return data && JSON.parse(data)[key];
+  }
+  async getTemporaryDataParameter(key, userId) {
+    const data = await this._store.getData(this._resolveKey("temporary_data" /* TemporaryData */, userId));
+    return data && JSON.parse(data)[key];
+  }
+  async getSessionDataParameter(key, userId) {
+    const data = await this._store.getData(this._resolveKey("session_data" /* SessionData */, userId));
+    return data && JSON.parse(data)[key];
+  }
+  async setConfigDataParameter(key, value) {
+    await this.setValue(this._resolveKey("config_data" /* ConfigData */), key, value);
+  }
+  async setOIDCProviderMetaDataParameter(key, value) {
+    await this.setValue(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), key, value);
+  }
+  async setTemporaryDataParameter(key, value, userId) {
+    await this.setValue(this._resolveKey("temporary_data" /* TemporaryData */, userId), key, value);
+  }
+  async setSessionDataParameter(key, value, userId) {
+    await this.setValue(this._resolveKey("session_data" /* SessionData */, userId), key, value);
+  }
+  async removeConfigDataParameter(key) {
+    await this.removeValue(this._resolveKey("config_data" /* ConfigData */), key);
+  }
+  async removeOIDCProviderMetaDataParameter(key) {
+    await this.removeValue(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), key);
+  }
+  async removeTemporaryDataParameter(key, userId) {
+    await this.removeValue(this._resolveKey("temporary_data" /* TemporaryData */, userId), key);
+  }
+  async removeSessionDataParameter(key, userId) {
+    await this.removeValue(this._resolveKey("session_data" /* SessionData */, userId), key);
   }
 };
-
-// src/utils/extractTenantDomainFromIdTokenPayload.ts
-var extractTenantDomainFromIdTokenPayload = (payload, subjectSeparator = "@") => {
-  const uid = payload.sub;
-  if (!uid) return "";
-  const tokens = uid.split(subjectSeparator);
-  return tokens.length > 2 ? tokens[tokens.length - 1] : "";
-};
-var extractTenantDomainFromIdTokenPayload_default = extractTenantDomainFromIdTokenPayload;
-
-// src/utils/extractUserClaimsFromIdToken.ts
-var extractUserClaimsFromIdToken = (payload) => {
-  const filteredPayload = { ...payload };
-  const protocolClaims = [
-    "iss",
-    "aud",
-    "exp",
-    "iat",
-    "acr",
-    "amr",
-    "azp",
-    "auth_time",
-    "nonce",
-    "c_hash",
-    "at_hash",
-    "nbf",
-    "isk",
-    "sid",
-    "jti",
-    "sub"
-  ];
-  protocolClaims.forEach((claim) => {
-    delete filteredPayload[claim];
-  });
-  const userClaims = {};
-  Object.entries(filteredPayload).forEach(([key, value]) => {
-    const camelCasedKey = key.split("_").map((part, i) => i === 0 ? part : part[0].toUpperCase() + part.slice(1)).join("");
-    userClaims[camelCasedKey] = value;
-  });
-  return userClaims;
-};
-var extractUserClaimsFromIdToken_default = extractUserClaimsFromIdToken;
-
-// src/constants/ScopeConstants.ts
-var ScopeConstants = {
-  /**
-   * The base OpenID Connect scope.
-   * Required for all OpenID Connect flows. Indicates that the client
-   * is initiating an OpenID Connect authentication request.
-   */
-  OPENID: "openid"
-};
-var ScopeConstants_default = ScopeConstants;
+var StorageManager_default = StorageManager;
 
 // src/constants/OIDCDiscoveryConstants.ts
 var OIDCDiscoveryConstants = {
@@ -267,279 +318,53 @@ var OIDCDiscoveryConstants = {
 };
 var OIDCDiscoveryConstants_default = OIDCDiscoveryConstants;
 
-// src/constants/TokenExchangeConstants.ts
-var TokenExchangeConstants = {
+// src/constants/ScopeConstants.ts
+var ScopeConstants = {
   /**
-   * Collection of placeholder strings used in token exchange operations.
-   * These placeholders are replaced with actual values when processing
-   * token exchange requests.
+   * The base OpenID Connect scope.
+   * Required for all OpenID Connect flows. Indicates that the client
+   * is initiating an OpenID Connect authentication request.
    */
-  Placeholders: {
+  OPENID: "openid"
+};
+var ScopeConstants_default = ScopeConstants;
+
+// src/constants/OIDCRequestConstants.ts
+var OIDCRequestConstants = {
+  Params: {
     /**
-     * Placeholder for the token value in exchange requests.
-     * Usually replaced with an access token or refresh token.
+     * The authorization code returned from the authorization endpoint.
+     * Used in the authorization code flow.
      */
-    TOKEN: "{{token}}",
+    AUTHORIZATION_CODE: "code",
     /**
-     * Placeholder for the username in token exchange operations.
-     * Used when user identity needs to be included in the exchange.
+     * Session state parameter used for session management between the client and the OP.
      */
-    USERNAME: "{{username}}",
+    SESSION_STATE: "session_state",
     /**
-     * Placeholder for OAuth scopes in token exchange requests.
-     * Replaced with space-separated scope strings.
+     * State parameter used to maintain state between the request and the callback.
+     * Helps in preventing CSRF attacks.
      */
-    SCOPE: "{{scope}}",
+    STATE: "state",
     /**
-     * Placeholder for client ID in token exchange operations.
-     * Required for client authentication.
+     * Indicates whether sign-out was successful during the end-session flow.
+     * May be returned by the OP after a logout request.
      */
-    CLIENT_ID: "{{clientID}}",
+    SIGN_OUT_SUCCESS: "sign_out_success"
+  },
+  /**
+   * Constants related to the OpenID Connect (OIDC) sign-in flow.
+   */
+  SignIn: {
     /**
-     * Placeholder for client secret in token exchange operations.
-     * Used for client authentication in confidential client flows.
+     * Constants related to the payload of the OIDC sign-in request.
      */
-    CLIENT_SECRET: "{{clientSecret}}"
-  }
-};
-var TokenExchangeConstants_default = TokenExchangeConstants;
-
-// src/__legacy__/helpers/authentication-helper.ts
-var AuthenticationHelper = class {
-  constructor(dataLayer, cryptoHelper) {
-    __publicField(this, "_dataLayer");
-    __publicField(this, "_config");
-    __publicField(this, "_oidcProviderMetaData");
-    __publicField(this, "_cryptoHelper");
-    this._dataLayer = dataLayer;
-    this._config = async () => await this._dataLayer.getConfigData();
-    this._oidcProviderMetaData = async () => await this._dataLayer.getOIDCProviderMetaData();
-    this._cryptoHelper = cryptoHelper;
-  }
-  async resolveEndpoints(response) {
-    const oidcProviderMetaData = {};
-    const configData = await this._config();
-    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
-      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
-    });
-    return { ...response, ...oidcProviderMetaData };
-  }
-  async resolveEndpointsExplicitly() {
-    const oidcProviderMetaData = {};
-    const configData = await this._config();
-    const requiredEndpoints = [
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION,
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.END_SESSION,
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.JWKS,
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.SESSION_IFRAME,
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.REVOCATION,
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.TOKEN,
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.ISSUER,
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.USERINFO
-    ];
-    const isRequiredEndpointsContains = configData.endpoints ? requiredEndpoints.every((reqEndpointName) => {
-      return configData.endpoints ? Object.keys(configData.endpoints).some((endpointName) => {
-        const snakeCasedName = endpointName.replace(
-          /[A-Z]/g,
-          (letter) => `_${letter.toLowerCase()}`
-        );
-        return snakeCasedName === reqEndpointName;
-      }) : false;
-    }) : false;
-    if (!isRequiredEndpointsContains) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_HELPER-REE-NF01",
-        "Required endpoints missing",
-        "Some or all of the required endpoints are missing in the object passed to the `endpoints` attribute of the`AuthConfig` object."
-      );
-    }
-    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
-      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
-    });
-    return { ...oidcProviderMetaData };
-  }
-  async resolveEndpointsByBaseURL() {
-    const oidcProviderMetaData = {};
-    const configData = await this._config();
-    const baseUrl = configData.baseUrl;
-    if (!baseUrl) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_HELPER_REBO-NF01",
-        "Base URL not defined.",
-        "Base URL is not defined in AuthClient config."
-      );
-    }
-    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
-      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
-    });
-    const defaultEndpoints = {
-      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.AUTHORIZATION}`,
-      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.END_SESSION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.END_SESSION}`,
-      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.ISSUER]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.ISSUER}`,
-      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.JWKS]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.JWKS}`,
-      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.SESSION_IFRAME]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.SESSION_IFRAME}`,
-      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.REVOCATION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.REVOCATION}`,
-      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.TOKEN]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.TOKEN}`,
-      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.USERINFO]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.USERINFO}`
-    };
-    return { ...defaultEndpoints, ...oidcProviderMetaData };
-  }
-  async validateIdToken(idToken) {
-    const jwksEndpoint = (await this._dataLayer.getOIDCProviderMetaData()).jwks_uri;
-    const configData = await this._config();
-    if (!jwksEndpoint || jwksEndpoint.trim().length === 0) {
-      throw new AsgardeoAuthException(
-        "JS_AUTH_HELPER-VIT-NF01",
-        "JWKS endpoint not found.",
-        "No JWKS endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the JWKS endpoint passed to the SDK is empty."
-      );
-    }
-    let response;
-    try {
-      response = await fetch(jwksEndpoint, {
-        credentials: configData.sendCookiesInRequests ? "include" : "same-origin"
-      });
-    } catch (error) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_HELPER-VIT-NE02",
-        "Request to jwks endpoint failed.",
-        error ?? "The request sent to get the jwks from the server failed."
-      );
-    }
-    if (response.status !== 200 || !response.ok) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_HELPER-VIT-HE03",
-        `Invalid response status received for jwks request (${response.statusText}).`,
-        await response.json()
-      );
-    }
-    const issuer = (await this._oidcProviderMetaData()).issuer;
-    const { keys } = await response.json();
-    const jwk = await this._cryptoHelper.getJWKForTheIdToken(idToken.split(".")[0], keys);
-    return this._cryptoHelper.isValidIdToken(
-      idToken,
-      jwk,
-      (await this._config()).clientID,
-      issuer ?? "",
-      this._cryptoHelper.decodeIDToken(idToken).sub,
-      (await this._config()).clockTolerance,
-      (await this._config()).validateIDTokenIssuer ?? true
-    );
-  }
-  getAuthenticatedUserInfo(idToken) {
-    const payload = this._cryptoHelper.decodeIDToken(idToken);
-    const tenantDomain = extractTenantDomainFromIdTokenPayload_default(payload);
-    const username = payload?.["username"] ?? "";
-    const givenName = payload?.["given_name"] ?? "";
-    const familyName = payload?.["family_name"] ?? "";
-    const fullName = givenName && familyName ? `${givenName} ${familyName}` : givenName ? givenName : familyName ? familyName : "";
-    const displayName = payload.preferred_username ?? fullName;
-    return {
-      displayName,
-      tenantDomain,
-      username,
-      ...extractUserClaimsFromIdToken_default(payload)
-    };
-  }
-  async replaceCustomGrantTemplateTags(text, userID) {
-    let scope = ScopeConstants_default.OPENID;
-    const configData = await this._config();
-    const sessionData = await this._dataLayer.getSessionData(userID);
-    if (configData.scope && configData.scope.length > 0) {
-      if (!configData.scope.includes(ScopeConstants_default.OPENID)) {
-        configData.scope.push(ScopeConstants_default.OPENID);
-      }
-      scope = configData.scope.join(" ");
-    }
-    return text.replace(TokenExchangeConstants_default.Placeholders.TOKEN, sessionData.access_token).replace(
-      TokenExchangeConstants_default.Placeholders.USERNAME,
-      this.getAuthenticatedUserInfo(sessionData.id_token).username
-    ).replace(TokenExchangeConstants_default.Placeholders.SCOPE, scope).replace(TokenExchangeConstants_default.Placeholders.CLIENT_ID, configData.clientID).replace(TokenExchangeConstants_default.Placeholders.CLIENT_SECRET, configData.clientSecret ?? "");
-  }
-  async clearUserSessionData(userID) {
-    await this._dataLayer.removeTemporaryData(userID);
-    await this._dataLayer.removeSessionData(userID);
-  }
-  async handleTokenResponse(response, userID) {
-    if (response.status !== 200 || !response.ok) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_HELPER-HTR-NE01",
-        `Invalid response status received for token request (${response.statusText}).`,
-        await response.json()
-      );
-    }
-    const parsedResponse = await response.json();
-    parsedResponse.created_at = (/* @__PURE__ */ new Date()).getTime();
-    const shouldValidateIdToken = (await this._config()).validateIDToken;
-    if (shouldValidateIdToken) {
-      return this.validateIdToken(parsedResponse.id_token).then(async () => {
-        await this._dataLayer.setSessionData(parsedResponse, userID);
-        const tokenResponse = {
-          accessToken: parsedResponse.access_token,
-          createdAt: parsedResponse.created_at,
-          expiresIn: parsedResponse.expires_in,
-          idToken: parsedResponse.id_token,
-          refreshToken: parsedResponse.refresh_token,
-          scope: parsedResponse.scope,
-          tokenType: parsedResponse.token_type
-        };
-        return Promise.resolve(tokenResponse);
-      });
-    } else {
-      const tokenResponse = {
-        accessToken: parsedResponse.access_token,
-        createdAt: parsedResponse.created_at,
-        expiresIn: parsedResponse.expires_in,
-        idToken: parsedResponse.id_token,
-        refreshToken: parsedResponse.refresh_token,
-        scope: parsedResponse.scope,
-        tokenType: parsedResponse.token_type
-      };
-      await this._dataLayer.setSessionData(parsedResponse, userID);
-      return Promise.resolve(tokenResponse);
-    }
-  }
-};
-
-// src/utils/generatePkceStorageKey.ts
-var generatePkceStorageKey = (tempStore) => {
-  const keys = [];
-  Object.keys(tempStore).forEach((key) => {
-    if (key.startsWith(PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER)) {
-      keys.push(key);
+    Payload: {
+      /**
+       * The default scopes used in OIDC sign-in requests.
+       */
+      DEFAULT_SCOPES: [ScopeConstants_default.OPENID]
     }
-  });
-  const lastKey = keys.sort().pop();
-  const index = parseInt(lastKey?.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1] ?? "-1");
-  return `${PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER}${PKCEConstants_default.Storage.StorageKeys.SEPARATOR}${index + 1}`;
-};
-var generatePkceStorageKey_default = generatePkceStorageKey;
-
-// src/constants/OIDCRequestConstants.ts
-var OIDCRequestConstants = {
-  Params: {
-    /**
-     * The authorization code returned from the authorization endpoint.
-     * Used in the authorization code flow.
-     */
-    AUTHORIZATION_CODE: "code",
-    /**
-     * Session state parameter used for session management between the client and the OP.
-     */
-    SESSION_STATE: "session_state",
-    /**
-     * State parameter used to maintain state between the request and the callback.
-     * Helps in preventing CSRF attacks.
-     */
-    STATE: "state",
-    /**
-     * Indicates whether sign-out was successful during the end-session flow.
-     * May be returned by the OP after a logout request.
-     */
-    SIGN_OUT_SUCCESS: "sign_out_success"
   },
   /**
    * Sign-out related constants for managing the end-session flow in OIDC.
@@ -565,6 +390,19 @@ var OIDCRequestConstants = {
 };
 var OIDCRequestConstants_default = OIDCRequestConstants;
 
+// src/errors/exception.ts
+var AsgardeoAuthException = class {
+  constructor(code, name, message) {
+    __publicField(this, "name");
+    __publicField(this, "code");
+    __publicField(this, "message");
+    this.message = message;
+    this.name = name;
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
 // src/constants/TokenConstants.ts
 var TokenConstants = {
   /**
@@ -660,7 +498,7 @@ var IsomorphicCrypto = class {
    *
    * @param idToken - id_token received from the IdP.
    * @param jwk - public key used for signing.
-   * @param clientID - app identification.
+   * @param clientId - app identification.
    * @param issuer - id_token issuer.
    * @param username - Username.
    * @param clockTolerance - Allowed leeway for id_tokens (in seconds).
@@ -669,12 +507,12 @@ var IsomorphicCrypto = class {
    *
    * @throws
    */
-  isValidIdToken(idToken, jwk, clientID, issuer, username, clockTolerance, validateJwtIssuer) {
+  isValidIdToken(idToken, jwk, clientId, issuer, username, clockTolerance, validateJwtIssuer) {
     return this._cryptoUtils.verifyJwt(
       idToken,
       jwk,
       TokenConstants_default.SignatureValidation.SUPPORTED_ALGORITHMS,
-      clientID,
+      clientId,
       issuer,
       username,
       clockTolerance,
@@ -701,9 +539,9 @@ var IsomorphicCrypto = class {
    *
    * @throws
    */
-  decodeIDToken(idToken) {
+  decodeIdToken(idToken) {
     try {
-      const utf8String = this._cryptoUtils.base64URLDecode(idToken.split(".")[1]);
+      const utf8String = this._cryptoUtils.base64URLDecode(idToken?.split(".")[1]);
       const payload = JSON.parse(utf8String);
       return payload;
     } catch (error) {
@@ -712,644 +550,463 @@ var IsomorphicCrypto = class {
   }
 };
 
-// src/__legacy__/core/authentication-core.ts
-var AuthenticationCore = class {
-  constructor(dataLayer, cryptoUtils) {
-    __publicField(this, "_dataLayer");
-    __publicField(this, "_config");
-    __publicField(this, "_oidcProviderMetaData");
-    __publicField(this, "_authenticationHelper");
-    __publicField(this, "_cryptoUtils");
-    __publicField(this, "_cryptoHelper");
-    this._cryptoUtils = cryptoUtils;
-    this._cryptoHelper = new IsomorphicCrypto(cryptoUtils);
-    this._authenticationHelper = new AuthenticationHelper(dataLayer, this._cryptoHelper);
-    this._dataLayer = dataLayer;
-    this._config = async () => await this._dataLayer.getConfigData();
-    this._oidcProviderMetaData = async () => await this._dataLayer.getOIDCProviderMetaData();
-  }
-  async getAuthorizationURLParams(config, userID) {
-    const configData = await this._config();
-    const authorizeRequestParams = /* @__PURE__ */ new Map();
-    authorizeRequestParams.set("response_type", "code");
-    authorizeRequestParams.set("client_id", configData.clientID);
-    let scope = ScopeConstants_default.OPENID;
-    if (configData.scope && configData.scope.length > 0) {
-      if (!configData.scope.includes(ScopeConstants_default.OPENID)) {
-        configData.scope.push(ScopeConstants_default.OPENID);
-      }
-      scope = configData.scope.join(" ");
-    }
-    authorizeRequestParams.set("scope", scope);
-    authorizeRequestParams.set("redirect_uri", configData.signInRedirectURL);
-    if (configData.responseMode) {
-      authorizeRequestParams.set("response_mode", configData.responseMode);
-    }
-    const tempStore = await this._dataLayer.getTemporaryData(userID);
-    const pkceKey = await generatePkceStorageKey_default(tempStore);
-    if (configData.enablePKCE) {
-      const codeVerifier = this._cryptoHelper?.getCodeVerifier();
-      const codeChallenge = this._cryptoHelper?.getCodeChallenge(codeVerifier);
-      await this._dataLayer.setTemporaryDataParameter(pkceKey, codeVerifier, userID);
-      authorizeRequestParams.set("code_challenge_method", "S256");
-      authorizeRequestParams.set("code_challenge", codeChallenge);
-    }
-    if (configData.prompt) {
-      authorizeRequestParams.set("prompt", configData.prompt);
-    }
-    const customParams = config;
-    if (customParams) {
-      for (const [key, value] of Object.entries(customParams)) {
-        if (key != "" && value != "" && key !== OIDCRequestConstants_default.Params.STATE) {
-          authorizeRequestParams.set(key, value.toString());
-        }
-      }
-    }
-    authorizeRequestParams.set(
-      OIDCRequestConstants_default.Params.STATE,
-      generateStateParamForRequestCorrelation_default(
-        pkceKey,
-        customParams ? customParams[OIDCRequestConstants_default.Params.STATE]?.toString() : ""
-      )
-    );
-    return authorizeRequestParams;
-  }
-  async getAuthorizationURL(config, userID) {
-    const authorizeEndpoint = await this._dataLayer.getOIDCProviderMetaDataParameter(
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION
-    );
-    if (!authorizeEndpoint || authorizeEndpoint.trim().length === 0) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-GAU-NF01",
-        "No authorization endpoint found.",
-        "No authorization endpoint was found in the OIDC provider meta data from the well-known endpoint or the authorization endpoint passed to the SDK is empty."
-      );
-    }
-    const authorizeRequest = new URL(authorizeEndpoint);
-    const authorizeRequestParams = await this.getAuthorizationURLParams(config, userID);
-    for (const [key, value] of authorizeRequestParams.entries()) {
-      authorizeRequest.searchParams.append(key, value);
+// src/constants/PKCEConstants.ts
+var PKCEConstants = {
+  DEFAULT_CODE_CHALLENGE_METHOD: "S256",
+  /**
+   * Storage-related constants for managing PKCE state
+   */
+  Storage: {
+    /**
+     * Collection of storage keys used in PKCE implementation
+     */
+    StorageKeys: {
+      /**
+       * Key used to store the PKCE code verifier in temporary storage.
+       * The code verifier is a cryptographically random string that is
+       * used to generate the code challenge.
+       */
+      CODE_VERIFIER: "pkce_code_verifier",
+      /**
+       * Separator used in storage keys to create unique identifiers
+       * by combining different parts of the key.
+       */
+      SEPARATOR: "#"
     }
-    return authorizeRequest.toString();
   }
-  async requestAccessToken(authorizationCode, sessionState, state, userID, tokenRequestConfig) {
-    const tokenEndpoint = (await this._oidcProviderMetaData()).token_endpoint;
-    const configData = await this._config();
-    if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT1-NF01",
-        "Token endpoint not found.",
-        "No token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the token endpoint passed to the SDK is empty."
-      );
-    }
-    sessionState && await this._dataLayer.setSessionDataParameter(
-      OIDCRequestConstants_default.Params.SESSION_STATE,
-      sessionState,
-      userID
-    );
-    const body = new URLSearchParams();
-    body.set("client_id", configData.clientID);
-    if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
-      body.set("client_secret", configData.clientSecret);
-    }
-    const code = authorizationCode;
-    body.set("code", code);
-    body.set("grant_type", "authorization_code");
-    body.set("redirect_uri", configData.signInRedirectURL);
-    if (tokenRequestConfig?.params) {
-      Object.entries(tokenRequestConfig.params).forEach(([key, value]) => {
-        body.append(key, value);
-      });
-    }
-    if (configData.enablePKCE) {
-      body.set(
-        "code_verifier",
-        `${await this._dataLayer.getTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userID)}`
-      );
-      await this._dataLayer.removeTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userID);
-    }
-    let tokenResponse;
-    try {
-      tokenResponse = await fetch(tokenEndpoint, {
-        body,
-        credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        method: "POST"
-      });
-    } catch (error) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT1-NE02",
-        "Requesting access token failed",
-        error ?? "The request to get the access token from the server failed."
-      );
-    }
-    if (!tokenResponse.ok) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT1-HE03",
-        `Requesting access token failed with ${tokenResponse.statusText}`,
-        await tokenResponse.json()
-      );
-    }
-    return await this._authenticationHelper.handleTokenResponse(tokenResponse, userID);
+};
+var PKCEConstants_default = PKCEConstants;
+
+// src/utils/extractPkceStorageKeyFromState.ts
+var extractPkceStorageKeyFromState = (state) => {
+  const index = parseInt(state.split("request_")[1]);
+  return `${PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER}${PKCEConstants_default.Storage.StorageKeys.SEPARATOR}${index}`;
+};
+var extractPkceStorageKeyFromState_default = extractPkceStorageKeyFromState;
+
+// src/utils/extractUserClaimsFromIdToken.ts
+var extractUserClaimsFromIdToken = (payload) => {
+  const filteredPayload = { ...payload };
+  const protocolClaims = [
+    "iss",
+    "aud",
+    "exp",
+    "iat",
+    "acr",
+    "amr",
+    "azp",
+    "auth_time",
+    "nonce",
+    "c_hash",
+    "at_hash",
+    "nbf",
+    "isk",
+    "sid",
+    "jti",
+    "sub"
+  ];
+  protocolClaims.forEach((claim) => {
+    delete filteredPayload[claim];
+  });
+  const userClaims = {};
+  Object.entries(filteredPayload).forEach(([key, value]) => {
+    const camelCasedKey = key.split("_").map((part, i) => i === 0 ? part : part[0].toUpperCase() + part.slice(1)).join("");
+    userClaims[camelCasedKey] = value;
+  });
+  return userClaims;
+};
+var extractUserClaimsFromIdToken_default = extractUserClaimsFromIdToken;
+
+// src/constants/TokenExchangeConstants.ts
+var TokenExchangeConstants = {
+  /**
+   * Collection of placeholder strings used in token exchange operations.
+   * These placeholders are replaced with actual values when processing
+   * token exchange requests.
+   */
+  Placeholders: {
+    /**
+     * Placeholder for the token value in exchange requests.
+     * Usually replaced with an access token or refresh token.
+     */
+    TOKEN: "{{token}}",
+    /**
+     * Placeholder for the username in token exchange operations.
+     * Used when user identity needs to be included in the exchange.
+     */
+    USERNAME: "{{username}}",
+    /**
+     * Placeholder for OAuth scopes in token exchange requests.
+     * Replaced with space-separated scope strings.
+     */
+    SCOPE: "{{scope}}",
+    /**
+     * Placeholder for client ID in token exchange operations.
+     * Required for client authentication.
+     */
+    CLIENT_ID: "{{clientId}}",
+    /**
+     * Placeholder for client secret in token exchange operations.
+     * Used for client authentication in confidential client flows.
+     */
+    CLIENT_SECRET: "{{clientSecret}}"
   }
-  async refreshAccessToken(userID) {
-    const tokenEndpoint = (await this._oidcProviderMetaData()).token_endpoint;
-    const configData = await this._config();
-    const sessionData = await this._dataLayer.getSessionData(userID);
-    if (!sessionData.refresh_token) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT2-NF01",
-        "No refresh token found.",
-        "There was no refresh token found. Asgardeo doesn't return a refresh token if the refresh token grant is not enabled."
-      );
-    }
-    if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT2-NF02",
-        "No refresh token endpoint found.",
-        "No refresh token endpoint was in the OIDC provider meta data returned by the well-known endpoint or the refresh token endpoint passed to the SDK is empty."
-      );
-    }
-    const body = [];
-    body.push(`client_id=${configData.clientID}`);
-    body.push(`refresh_token=${sessionData.refresh_token}`);
-    body.push("grant_type=refresh_token");
-    if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
-      body.push(`client_secret=${configData.clientSecret}`);
-    }
-    let tokenResponse;
-    try {
-      tokenResponse = await fetch(tokenEndpoint, {
-        body: body.join("&"),
-        credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        method: "POST"
-      });
-    } catch (error) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT2-NR03",
-        "Refresh access token request failed.",
-        error ?? "The request to refresh the access token failed."
-      );
-    }
-    if (!tokenResponse.ok) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT2-HE04",
-        `Refreshing access token failed with ${tokenResponse.statusText}`,
-        await tokenResponse.json()
-      );
+};
+var TokenExchangeConstants_default = TokenExchangeConstants;
+
+// src/errors/AsgardeoError.ts
+var AsgardeoError = class _AsgardeoError extends Error {
+  constructor(message, code, origin) {
+    const _origin = _AsgardeoError.resolveOrigin(origin);
+    const prefix = `\u{1F6E1}\uFE0F Asgardeo - ${_origin}:`;
+    const regex = new RegExp(`\u{1F6E1}\uFE0F\\s*Asgardeo\\s*-\\s*${_origin}:`, "i");
+    const sanitized = message.replace(regex, "");
+    const _message = `${prefix} ${sanitized.trim()}
+
+(code="${code}")
+`;
+    super(_message);
+    __publicField(this, "code");
+    __publicField(this, "origin");
+    this.name = new.target.name;
+    this.code = code;
+    this.origin = _origin;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, new.target);
     }
-    return this._authenticationHelper.handleTokenResponse(tokenResponse, userID);
   }
-  async revokeAccessToken(userID) {
-    const revokeTokenEndpoint = (await this._oidcProviderMetaData()).revocation_endpoint;
-    const configData = await this._config();
-    if (!revokeTokenEndpoint || revokeTokenEndpoint.trim().length === 0) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT3-NF01",
-        "No revoke access token endpoint found.",
-        "No revoke access token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the revoke access token endpoint passed to the SDK is empty."
-      );
-    }
-    const body = [];
-    body.push(`client_id=${configData.clientID}`);
-    body.push(`token=${(await this._dataLayer.getSessionData(userID)).access_token}`);
-    body.push("token_type_hint=access_token");
-    if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
-      body.push(`client_secret=${configData.clientSecret}`);
-    }
-    let response;
-    try {
-      response = await fetch(revokeTokenEndpoint, {
-        body: body.join("&"),
-        credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        method: "POST"
-      });
-    } catch (error) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT3-NE02",
-        "The request to revoke access token failed.",
-        error ?? "The request sent to revoke the access token failed."
-      );
-    }
-    if (response.status !== 200 || !response.ok) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RAT3-HE03",
-        `Invalid response status received for revoke access token request (${response.statusText}).`,
-        await response.json()
-      );
+  static resolveOrigin(origin) {
+    if (!origin) {
+      return "@asgardeo/javascript";
     }
-    this._authenticationHelper.clearUserSessionData(userID);
-    return Promise.resolve(response);
+    return `@asgardeo/${origin}`;
   }
-  async requestCustomGrant(customGrantParams, userID) {
-    const oidcProviderMetadata = await this._oidcProviderMetaData();
-    const configData = await this._config();
-    let tokenEndpoint;
-    if (customGrantParams.tokenEndpoint && customGrantParams.tokenEndpoint.trim().length !== 0) {
-      tokenEndpoint = customGrantParams.tokenEndpoint;
-    } else {
-      tokenEndpoint = oidcProviderMetadata.token_endpoint;
-    }
-    if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RCG-NF01",
-        "Token endpoint not found.",
-        "No token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the token endpoint passed to the SDK is empty."
-      );
-    }
-    const data = await Promise.all(
-      Object.entries(customGrantParams.data).map(async ([key, value]) => {
-        const newValue = await this._authenticationHelper.replaceCustomGrantTemplateTags(
-          value,
-          userID
-        );
-        return `${key}=${newValue}`;
-      })
-    );
-    let requestHeaders = {
-      Accept: "application/json",
-      "Content-Type": "application/x-www-form-urlencoded"
-    };
-    if (customGrantParams.attachToken) {
-      requestHeaders = {
-        ...requestHeaders,
-        Authorization: `Bearer ${(await this._dataLayer.getSessionData(userID)).access_token}`
-      };
-    }
-    const requestConfig = {
-      body: data.join("&"),
-      credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
-      headers: new Headers(requestHeaders),
-      method: "POST"
-    };
-    let response;
-    try {
-      response = await fetch(tokenEndpoint, requestConfig);
-    } catch (error) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RCG-NE02",
-        "The custom grant request failed.",
-        error ?? "The request sent to get the custom grant failed."
-      );
-    }
-    if (response.status !== 200 || !response.ok) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-RCG-HE03",
-        `Invalid response status received for the custom grant request. (${response.statusText})`,
-        await response.json()
-      );
-    }
-    if (customGrantParams.returnsSession) {
-      return this._authenticationHelper.handleTokenResponse(response, userID);
-    } else {
-      return Promise.resolve(await response.json());
-    }
+  toString() {
+    return `[${this.name}]
+Message: ${this.message}`;
   }
-  async getBasicUserInfo(userID) {
-    const sessionData = await this._dataLayer.getSessionData(userID);
-    const authenticatedUser = this._authenticationHelper.getAuthenticatedUserInfo(
-      sessionData?.id_token
-    );
-    let basicUserInfo = {
-      allowedScopes: sessionData.scope,
-      sessionState: sessionData.session_state
-    };
-    Object.keys(authenticatedUser).forEach((key) => {
-      if (authenticatedUser[key] === void 0 || authenticatedUser[key] === "" || authenticatedUser[key] === null) {
-        delete authenticatedUser[key];
-      }
+};
+
+// src/errors/AsgardeoRuntimeError.ts
+var AsgardeoRuntimeError = class extends AsgardeoError {
+  /**
+   * Creates an instance of AsgardeoRuntimeError.
+   *
+   * @param message - Human-readable description of the error
+   * @param code - A unique error code that identifies the error type
+   * @param details - Additional details about the error that might be helpful for debugging
+   * @param origin - Optional. The SDK origin (e.g. 'react', 'vue'). Defaults to generic 'Asgardeo'
+   * @constructor
+   */
+  constructor(message, code, origin, details) {
+    super(message, code, origin);
+    this.details = details;
+    Object.defineProperty(this, "name", {
+      value: "AsgardeoRuntimeError",
+      configurable: true,
+      writable: true
     });
-    basicUserInfo = { ...basicUserInfo, ...authenticatedUser };
-    return basicUserInfo;
   }
-  async getDecodedIDToken(userID) {
-    const idToken = (await this._dataLayer.getSessionData(userID)).id_token;
-    const payload = this._cryptoHelper.decodeIDToken(idToken);
-    return payload;
+  /**
+   * Returns a string representation of the runtime error
+   * @returns Formatted error string with name, code, details, and message
+   */
+  toString() {
+    const details = this.details ? `
+Details: ${JSON.stringify(this.details, null, 2)}` : "";
+    return `[${this.name}] (code="${this.code}")${details}
+Message: ${this.message}`;
   }
-  async getCryptoHelper() {
-    return this._cryptoHelper;
+};
+
+// src/utils/processOpenIDScopes.ts
+var processOpenIDScopes = (scopes) => {
+  let processedScopes = [];
+  if (Array.isArray(scopes)) {
+    processedScopes = scopes;
+  } else if (typeof scopes === "string") {
+    processedScopes = scopes.split(" ");
+  } else {
+    throw new AsgardeoRuntimeError(
+      "Scopes must be a string or an array of strings.",
+      "processOpenIDScopes-Invalid-001",
+      "javascript",
+      "The provided scopes are not in the expected format. Please provide a string or an array of strings."
+    );
   }
-  async getIDToken(userID) {
-    return (await this._dataLayer.getSessionData(userID)).id_token;
+  OIDCRequestConstants_default.SignIn.Payload.DEFAULT_SCOPES.forEach((defaultScope) => {
+    if (!processedScopes.includes(defaultScope)) {
+      processedScopes.push(defaultScope);
+    }
+  });
+  return processedScopes.join(" ");
+};
+var processOpenIDScopes_default = processOpenIDScopes;
+
+// src/__legacy__/helpers/authentication-helper.ts
+var AuthenticationHelper = class {
+  constructor(storageManager, cryptoHelper) {
+    __publicField(this, "_storageManager");
+    __publicField(this, "_config");
+    __publicField(this, "_oidcProviderMetaData");
+    __publicField(this, "_cryptoHelper");
+    this._storageManager = storageManager;
+    this._config = async () => await this._storageManager.getConfigData();
+    this._oidcProviderMetaData = async () => await this._storageManager.loadOpenIDProviderConfiguration();
+    this._cryptoHelper = cryptoHelper;
   }
-  async getOIDCProviderMetaData(forceInit) {
+  async resolveEndpoints(response) {
+    const oidcProviderMetaData = {};
     const configData = await this._config();
-    if (!forceInit && await this._dataLayer.getTemporaryDataParameter(
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
-    )) {
-      return Promise.resolve();
-    }
-    const wellKnownEndpoint = configData.wellKnownEndpoint;
-    if (wellKnownEndpoint) {
-      let response;
-      try {
-        response = await fetch(wellKnownEndpoint);
-        if (response.status !== 200 || !response.ok) {
-          throw new Error();
-        }
-      } catch {
-        throw new AsgardeoAuthException(
-          "JS-AUTH_CORE-GOPMD-HE01",
-          "Invalid well-known response",
-          "The well known endpoint response has been failed with an error."
-        );
-      }
-      await this._dataLayer.setOIDCProviderMetaData(
-        await this._authenticationHelper.resolveEndpoints(await response.json())
-      );
-      await this._dataLayer.setTemporaryDataParameter(
-        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
-        true
-      );
-      return Promise.resolve();
-    } else if (configData.baseUrl) {
-      try {
-        await this._dataLayer.setOIDCProviderMetaData(await this._authenticationHelper.resolveEndpointsByBaseURL());
-      } catch (error) {
-        throw new AsgardeoAuthException(
-          "JS-AUTH_CORE-GOPMD-IV02",
-          "Resolving endpoints failed.",
-          error ?? "Resolving endpoints by base url failed."
+    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
+      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
+    });
+    return { ...response, ...oidcProviderMetaData };
+  }
+  async resolveEndpointsExplicitly() {
+    const oidcProviderMetaData = {};
+    const configData = await this._config();
+    const requiredEndpoints = [
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.END_SESSION,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.JWKS,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.SESSION_IFRAME,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.REVOCATION,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.TOKEN,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.ISSUER,
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.USERINFO
+    ];
+    const isRequiredEndpointsContains = configData.endpoints ? requiredEndpoints.every((reqEndpointName) => {
+      return configData.endpoints ? Object.keys(configData.endpoints).some((endpointName) => {
+        const snakeCasedName = endpointName.replace(
+          /[A-Z]/g,
+          (letter) => `_${letter.toLowerCase()}`
         );
-      }
-      await this._dataLayer.setTemporaryDataParameter(
-        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
-        true
-      );
-      return Promise.resolve();
-    } else {
-      await this._dataLayer.setOIDCProviderMetaData(await this._authenticationHelper.resolveEndpointsExplicitly());
-      await this._dataLayer.setTemporaryDataParameter(
-        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
-        true
+        return snakeCasedName === reqEndpointName;
+      }) : false;
+    }) : false;
+    if (!isRequiredEndpointsContains) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER-REE-NF01",
+        "Required endpoints missing",
+        "Some or all of the required endpoints are missing in the object passed to the `endpoints` attribute of the`AuthConfig` object."
       );
-      return Promise.resolve();
     }
+    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
+      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
+    });
+    return { ...oidcProviderMetaData };
   }
-  // TODO: Remove `Partial<OIDCEndpoints>` once the refactoring is done.
-  async getOIDCServiceEndpoints() {
-    const oidcProviderMetaData = await this._oidcProviderMetaData();
-    return {
-      authorizationEndpoint: oidcProviderMetaData.authorization_endpoint ?? "",
-      checkSessionIframe: oidcProviderMetaData.check_session_iframe ?? "",
-      endSessionEndpoint: oidcProviderMetaData.end_session_endpoint ?? "",
-      introspectionEndpoint: oidcProviderMetaData.introspection_endpoint ?? "",
-      issuer: oidcProviderMetaData.issuer ?? "",
-      jwksUri: oidcProviderMetaData.jwks_uri ?? "",
-      registrationEndpoint: oidcProviderMetaData.registration_endpoint ?? "",
-      revocationEndpoint: oidcProviderMetaData.revocation_endpoint ?? "",
-      tokenEndpoint: oidcProviderMetaData.token_endpoint ?? "",
-      userinfoEndpoint: oidcProviderMetaData.userinfo_endpoint ?? ""
+  async resolveEndpointsByBaseURL() {
+    const oidcProviderMetaData = {};
+    const configData = await this._config();
+    const baseUrl = configData.baseUrl;
+    if (!baseUrl) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER_REBO-NF01",
+        "Base URL not defined.",
+        "Base URL is not defined in AuthClient config."
+      );
+    }
+    configData.endpoints && Object.keys(configData.endpoints).forEach((endpointName) => {
+      const snakeCasedName = endpointName.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+      oidcProviderMetaData[snakeCasedName] = configData?.endpoints ? configData.endpoints[endpointName] : "";
+    });
+    const defaultEndpoints = {
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.AUTHORIZATION}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.END_SESSION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.END_SESSION}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.ISSUER]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.ISSUER}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.JWKS]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.JWKS}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.SESSION_IFRAME]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.SESSION_IFRAME}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.REVOCATION]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.REVOCATION}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.TOKEN]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.TOKEN}`,
+      [OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.USERINFO]: `${baseUrl}${OIDCDiscoveryConstants_default.Endpoints.USERINFO}`
     };
+    return { ...defaultEndpoints, ...oidcProviderMetaData };
   }
-  async getSignOutURL(userID) {
-    const logoutEndpoint = (await this._oidcProviderMetaData())?.end_session_endpoint;
+  async validateIdToken(idToken) {
+    const jwksEndpoint = (await this._storageManager.loadOpenIDProviderConfiguration()).jwks_uri;
     const configData = await this._config();
-    if (!logoutEndpoint || logoutEndpoint.trim().length === 0) {
+    if (!jwksEndpoint || jwksEndpoint.trim().length === 0) {
       throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-GSOU-NF01",
-        "Sign-out endpoint not found.",
-        "No sign-out endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the sign-out endpoint passed to the SDK is empty."
+        "JS_AUTH_HELPER-VIT-NF01",
+        "JWKS endpoint not found.",
+        "No JWKS endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the JWKS endpoint passed to the SDK is empty."
       );
     }
-    const callbackURL = configData?.signOutRedirectURL ?? configData?.signInRedirectURL;
-    if (!callbackURL || callbackURL.trim().length === 0) {
+    let response;
+    try {
+      response = await fetch(jwksEndpoint, {
+        credentials: configData.sendCookiesInRequests ? "include" : "same-origin"
+      });
+    } catch (error) {
       throw new AsgardeoAuthException(
-        "JS-AUTH_CORE-GSOU-NF03",
-        "No sign-out redirect URL found.",
-        "The sign-out redirect URL cannot be found or the URL passed to the SDK is empty. No sign-in redirect URL has been found either. "
+        "JS-AUTH_HELPER-VIT-NE02",
+        "Request to jwks endpoint failed.",
+        error ?? "The request sent to get the jwks from the server failed."
       );
     }
-    const queryParams = new URLSearchParams();
-    queryParams.set("post_logout_redirect_uri", callbackURL);
-    if (configData.sendIdTokenInLogoutRequest) {
-      const idToken = (await this._dataLayer.getSessionData(userID))?.id_token;
-      if (!idToken || idToken.trim().length === 0) {
-        throw new AsgardeoAuthException(
-          "JS-AUTH_CORE-GSOU-NF02",
-          "ID token not found.",
-          "No ID token could be found. Either the session information is lost or you have not signed in."
-        );
-      }
-      queryParams.set("id_token_hint", idToken);
-    } else {
-      queryParams.set("client_id", configData.clientID);
-    }
-    queryParams.set("state", OIDCRequestConstants_default.Params.SIGN_OUT_SUCCESS);
-    return `${logoutEndpoint}?${queryParams.toString()}`;
-  }
-  async clearUserSessionData(userID) {
-    await this._authenticationHelper.clearUserSessionData(userID);
-  }
-  async getAccessToken(userID) {
-    return (await this._dataLayer.getSessionData(userID))?.access_token;
-  }
-  /**
-   * The created timestamp of the token response in milliseconds.
-   *
-   * @param userID - User ID
-   * @returns Created at timestamp of the token response in milliseconds.
-   */
-  async getCreatedAt(userID) {
-    return (await this._dataLayer.getSessionData(userID))?.created_at;
-  }
-  /**
-   * The expires timestamp of the token response in seconds.
-   *
-   * @param userID - User ID
-   * @returns Expires in timestamp of the token response in seconds.
-   */
-  async getExpiresIn(userID) {
-    return (await this._dataLayer.getSessionData(userID))?.expires_in;
-  }
-  async isAuthenticated(userID) {
-    const isAccessTokenAvailable = Boolean(await this.getAccessToken(userID));
-    const createdAt = await this.getCreatedAt(userID);
-    const expiresInString = await this.getExpiresIn(userID);
-    if (!expiresInString) {
-      return false;
+    if (response.status !== 200 || !response.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER-VIT-HE03",
+        `Invalid response status received for jwks request (${response.statusText}).`,
+        await response.json()
+      );
     }
-    const expiresIn = parseInt(expiresInString) * 1e3;
-    const currentTime = (/* @__PURE__ */ new Date()).getTime();
-    const isAccessTokenValid = createdAt + expiresIn > currentTime;
-    const isAuthenticated = isAccessTokenAvailable && isAccessTokenValid;
-    return isAuthenticated;
-  }
-  async getPKCECode(state, userID) {
-    return await this._dataLayer.getTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userID);
-  }
-  async setPKCECode(pkce, state, userID) {
-    return await this._dataLayer.setTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), pkce, userID);
-  }
-  async updateConfig(config) {
-    await this._dataLayer.setConfigData(config);
-    await this.getOIDCProviderMetaData(true);
-  }
-};
-
-// src/__legacy__/data/data-layer.ts
-var ASGARDEO_SESSION_ACTIVE = "asgardeo-session-active";
-var DataLayer = class {
-  constructor(instanceID, store) {
-    __publicField(this, "_id");
-    __publicField(this, "_store");
-    this._id = instanceID;
-    this._store = store;
-  }
-  async setDataInBulk(key, data) {
-    const existingDataJSON = await this._store.getData(key) ?? null;
-    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
-    const dataToBeSaved = { ...existingData, ...data };
-    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
-    await this._store.setData(key, dataToBeSavedJSON);
+    const issuer = (await this._oidcProviderMetaData()).issuer;
+    const { keys } = await response.json();
+    const jwk = await this._cryptoHelper.getJWKForTheIdToken(idToken.split(".")[0], keys);
+    return this._cryptoHelper.isValidIdToken(
+      idToken,
+      jwk,
+      (await this._config()).clientId,
+      issuer ?? "",
+      this._cryptoHelper.decodeIdToken(idToken).sub,
+      (await this._config()).clockTolerance,
+      (await this._config()).validateIDTokenIssuer ?? true
+    );
   }
-  async setValue(key, attribute, value) {
-    const existingDataJSON = await this._store.getData(key) ?? null;
-    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
-    const dataToBeSaved = { ...existingData, [attribute]: value };
-    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
-    await this._store.setData(key, dataToBeSavedJSON);
+  getAuthenticatedUserInfo(idToken) {
+    const payload = this._cryptoHelper.decodeIdToken(idToken);
+    const username = payload?.["username"] ?? "";
+    const givenName = payload?.["given_name"] ?? "";
+    const familyName = payload?.["family_name"] ?? "";
+    const fullName = givenName && familyName ? `${givenName} ${familyName}` : givenName ? givenName : familyName ? familyName : "";
+    const displayName = payload.preferred_username ?? fullName;
+    return {
+      displayName,
+      username,
+      ...extractUserClaimsFromIdToken_default(payload)
+    };
   }
-  async removeValue(key, attribute) {
-    const existingDataJSON = await this._store.getData(key) ?? null;
-    const existingData = existingDataJSON && JSON.parse(existingDataJSON);
-    const dataToBeSaved = { ...existingData };
-    delete dataToBeSaved[attribute];
-    const dataToBeSavedJSON = JSON.stringify(dataToBeSaved);
-    await this._store.setData(key, dataToBeSavedJSON);
+  async replaceCustomGrantTemplateTags(text, userId) {
+    const configData = await this._config();
+    const sessionData = await this._storageManager.getSessionData(userId);
+    let scope = processOpenIDScopes_default(configData.scopes);
+    return text.replace(TokenExchangeConstants_default.Placeholders.TOKEN, sessionData.access_token).replace(
+      TokenExchangeConstants_default.Placeholders.USERNAME,
+      this.getAuthenticatedUserInfo(sessionData.id_token).username
+    ).replace(TokenExchangeConstants_default.Placeholders.SCOPE, scope).replace(TokenExchangeConstants_default.Placeholders.CLIENT_ID, configData.clientId).replace(TokenExchangeConstants_default.Placeholders.CLIENT_SECRET, configData.clientSecret ?? "");
   }
-  _resolveKey(store, userID) {
-    return userID ? `${store}-${this._id}-${userID}` : `${store}-${this._id}`;
+  async clearSession(userId) {
+    await this._storageManager.removeTemporaryData(userId);
+    await this._storageManager.removeSessionData(userId);
   }
-  isLocalStorageAvailable() {
-    try {
-      const testValue = "__ASGARDEO_AUTH_CORE_LOCAL_STORAGE_TEST__";
-      localStorage.setItem(testValue, testValue);
-      localStorage.removeItem(testValue);
-      return true;
-    } catch (error) {
-      return false;
+  async handleTokenResponse(response, userId) {
+    if (response.status !== 200 || !response.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER-HTR-NE01",
+        `Invalid response status received for token request (${response.statusText}).`,
+        await response.json()
+      );
+    }
+    const parsedResponse = await response.json();
+    parsedResponse.created_at = (/* @__PURE__ */ new Date()).getTime();
+    const shouldValidateIdToken = (await this._config()).validateIDToken;
+    if (shouldValidateIdToken) {
+      return this.validateIdToken(parsedResponse.id_token).then(async () => {
+        await this._storageManager.setSessionData(parsedResponse, userId);
+        const tokenResponse = {
+          accessToken: parsedResponse.access_token,
+          createdAt: parsedResponse.created_at,
+          expiresIn: parsedResponse.expires_in,
+          idToken: parsedResponse.id_token,
+          refreshToken: parsedResponse.refresh_token,
+          scope: parsedResponse.scope,
+          tokenType: parsedResponse.token_type
+        };
+        return Promise.resolve(tokenResponse);
+      });
+    } else {
+      const tokenResponse = {
+        accessToken: parsedResponse.access_token,
+        createdAt: parsedResponse.created_at,
+        expiresIn: parsedResponse.expires_in,
+        idToken: parsedResponse.id_token,
+        refreshToken: parsedResponse.refresh_token,
+        scope: parsedResponse.scope,
+        tokenType: parsedResponse.token_type
+      };
+      await this._storageManager.setSessionData(parsedResponse, userId);
+      return Promise.resolve(tokenResponse);
     }
   }
-  async setConfigData(config) {
-    await this.setDataInBulk(this._resolveKey("config_data" /* ConfigData */), config);
-  }
-  async setOIDCProviderMetaData(oidcProviderMetaData) {
-    this.setDataInBulk(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), oidcProviderMetaData);
-  }
-  async setTemporaryData(temporaryData, userID) {
-    this.setDataInBulk(this._resolveKey("temporary_data" /* TemporaryData */, userID), temporaryData);
-  }
-  async setSessionData(sessionData, userID) {
-    this.setDataInBulk(this._resolveKey("session_data" /* SessionData */, userID), sessionData);
-  }
-  async setCustomData(key, customData, userID) {
-    this.setDataInBulk(this._resolveKey(key, userID), customData);
-  }
-  async getConfigData() {
-    return JSON.parse(await this._store.getData(this._resolveKey("config_data" /* ConfigData */)) ?? null);
-  }
-  async getOIDCProviderMetaData() {
-    return JSON.parse(await this._store.getData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */)) ?? null);
-  }
-  async getTemporaryData(userID) {
-    return JSON.parse(await this._store.getData(this._resolveKey("temporary_data" /* TemporaryData */, userID)) ?? null);
-  }
-  async getSessionData(userID) {
-    return JSON.parse(await this._store.getData(this._resolveKey("session_data" /* SessionData */, userID)) ?? null);
-  }
-  async getCustomData(key, userID) {
-    return JSON.parse(await this._store.getData(this._resolveKey(key, userID)) ?? null);
-  }
-  setSessionStatus(status) {
-    this.isLocalStorageAvailable() && localStorage.setItem(`${ASGARDEO_SESSION_ACTIVE}`, status);
-  }
-  getSessionStatus() {
-    return this.isLocalStorageAvailable() ? localStorage.getItem(`${ASGARDEO_SESSION_ACTIVE}`) ?? "" : "";
-  }
-  removeSessionStatus() {
-    this.isLocalStorageAvailable() && localStorage.removeItem(`${ASGARDEO_SESSION_ACTIVE}`);
-  }
-  async removeConfigData() {
-    await this._store.removeData(this._resolveKey("config_data" /* ConfigData */));
-  }
-  async removeOIDCProviderMetaData() {
-    await this._store.removeData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */));
-  }
-  async removeTemporaryData(userID) {
-    await this._store.removeData(this._resolveKey("temporary_data" /* TemporaryData */, userID));
-  }
-  async removeSessionData(userID) {
-    await this._store.removeData(this._resolveKey("session_data" /* SessionData */, userID));
-  }
-  async getConfigDataParameter(key) {
-    const data = await this._store.getData(this._resolveKey("config_data" /* ConfigData */));
-    return data && JSON.parse(data)[key];
-  }
-  async getOIDCProviderMetaDataParameter(key) {
-    const data = await this._store.getData(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */));
-    return data && JSON.parse(data)[key];
-  }
-  async getTemporaryDataParameter(key, userID) {
-    const data = await this._store.getData(this._resolveKey("temporary_data" /* TemporaryData */, userID));
-    return data && JSON.parse(data)[key];
-  }
-  async getSessionDataParameter(key, userID) {
-    const data = await this._store.getData(this._resolveKey("session_data" /* SessionData */, userID));
-    return data && JSON.parse(data)[key];
-  }
-  async setConfigDataParameter(key, value) {
-    await this.setValue(this._resolveKey("config_data" /* ConfigData */), key, value);
-  }
-  async setOIDCProviderMetaDataParameter(key, value) {
-    await this.setValue(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), key, value);
-  }
-  async setTemporaryDataParameter(key, value, userID) {
-    await this.setValue(this._resolveKey("temporary_data" /* TemporaryData */, userID), key, value);
-  }
-  async setSessionDataParameter(key, value, userID) {
-    await this.setValue(this._resolveKey("session_data" /* SessionData */, userID), key, value);
-  }
-  async removeConfigDataParameter(key) {
-    await this.removeValue(this._resolveKey("config_data" /* ConfigData */), key);
-  }
-  async removeOIDCProviderMetaDataParameter(key) {
-    await this.removeValue(this._resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), key);
+};
+
+// src/utils/generatePkceStorageKey.ts
+var generatePkceStorageKey = (tempStore) => {
+  const keys = [];
+  Object.keys(tempStore).forEach((key) => {
+    if (key.startsWith(PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER)) {
+      keys.push(key);
+    }
+  });
+  const lastKey = keys.sort().pop();
+  const index = parseInt(lastKey?.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1] ?? "-1");
+  return `${PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER}${PKCEConstants_default.Storage.StorageKeys.SEPARATOR}${index + 1}`;
+};
+var generatePkceStorageKey_default = generatePkceStorageKey;
+
+// src/utils/generateStateParamForRequestCorrelation.ts
+var generateStateParamForRequestCorrelation = (pkceKey, state) => {
+  const index = parseInt(pkceKey.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1]);
+  return state ? `${state}_request_${index}` : `request_${index}`;
+};
+var generateStateParamForRequestCorrelation_default = generateStateParamForRequestCorrelation;
+
+// src/utils/getAuthorizeRequestUrlParams.ts
+var getAuthorizeRequestUrlParams = (options, pkceOptions, customParams) => {
+  const { redirectUri, clientId, scopes, responseMode, codeChallenge, codeChallengeMethod, prompt } = options;
+  const authorizeRequestParams = /* @__PURE__ */ new Map();
+  authorizeRequestParams.set("response_type", "code");
+  authorizeRequestParams.set("client_id", clientId);
+  authorizeRequestParams.set("scope", scopes);
+  authorizeRequestParams.set("redirect_uri", redirectUri);
+  if (responseMode) {
+    authorizeRequestParams.set("response_mode", responseMode);
+  }
+  const pkceKey = pkceOptions?.key;
+  if (codeChallenge) {
+    authorizeRequestParams.set("code_challenge", codeChallenge);
+    if (codeChallengeMethod) {
+      authorizeRequestParams.set("code_challenge_method", codeChallengeMethod);
+    } else {
+      throw new AsgardeoRuntimeError(
+        "Code challenge method is required when code challenge is provided.",
+        "getAuthorizeRequestUrlParams-ValidationError-001",
+        "javascript",
+        "When PKCE is enabled, the code challenge method must be provided along with the code challenge."
+      );
+    }
   }
-  async removeTemporaryDataParameter(key, userID) {
-    await this.removeValue(this._resolveKey("temporary_data" /* TemporaryData */, userID), key);
+  if (prompt) {
+    authorizeRequestParams.set("prompt", prompt);
   }
-  async removeSessionDataParameter(key, userID) {
-    await this.removeValue(this._resolveKey("session_data" /* SessionData */, userID), key);
+  if (customParams) {
+    for (const [key, value] of Object.entries(customParams)) {
+      if (key !== "" && value !== "" && key !== OIDCRequestConstants_default.Params.STATE) {
+        authorizeRequestParams.set(key, value.toString());
+      }
+    }
   }
+  authorizeRequestParams.set(
+    OIDCRequestConstants_default.Params.STATE,
+    generateStateParamForRequestCorrelation_default(
+      pkceKey,
+      customParams ? customParams[OIDCRequestConstants_default.Params.STATE]?.toString() : ""
+    )
+  );
+  return authorizeRequestParams;
 };
-
-// src/models/oauth-response.ts
-var ResponseMode = /* @__PURE__ */ ((ResponseMode2) => {
-  ResponseMode2["FormPost"] = "form_post";
-  ResponseMode2["Query"] = "query";
-  ResponseMode2["Direct"] = "direct";
-  return ResponseMode2;
-})(ResponseMode || {});
+var getAuthorizeRequestUrlParams_default = getAuthorizeRequestUrlParams;
 
 // src/__legacy__/client.ts
 var DefaultConfig = {
   clockTolerance: 300,
   enablePKCE: true,
-  responseMode: "query" /* Query */,
-  scope: [ScopeConstants_default.OPENID],
+  responseMode: "query",
   sendCookiesInRequests: true,
   validateIDToken: true,
   validateIDTokenIssuer: true
@@ -1371,8 +1028,12 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   constructor() {
-    __publicField(this, "_dataLayer");
-    __publicField(this, "_authenticationCore");
+    __publicField(this, "_storageManager");
+    __publicField(this, "_config");
+    __publicField(this, "_oidcProviderMetaData");
+    __publicField(this, "_authenticationHelper");
+    __publicField(this, "_cryptoUtils");
+    __publicField(this, "_cryptoHelper");
   }
   /**
    *
@@ -1382,8 +1043,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @example
    * const config = \{
-   *     signInRedirectURL: "http://localhost:3000/sign-in",
-   *     clientID: "client ID",
+   *     afterSignInUrl: "http://localhost:3000/sign-in",
+   *     clientId: "client ID",
    *     baseUrl: "https://localhost:9443"
    * \}
    *
@@ -1394,7 +1055,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async initialize(config, store, cryptoUtils, instanceID) {
-    const clientId = config.clientID;
+    const clientId = config.clientId;
     if (!_AsgardeoAuthClient._instanceID) {
       _AsgardeoAuthClient._instanceID = 0;
     } else {
@@ -1404,37 +1065,38 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
       _AsgardeoAuthClient._instanceID = instanceID;
     }
     if (!clientId) {
-      this._dataLayer = new DataLayer(`instance_${_AsgardeoAuthClient._instanceID}`, store);
+      this._storageManager = new StorageManager_default(`instance_${_AsgardeoAuthClient._instanceID}`, store);
     } else {
-      this._dataLayer = new DataLayer(`instance_${_AsgardeoAuthClient._instanceID}-${clientId}`, store);
+      this._storageManager = new StorageManager_default(`instance_${_AsgardeoAuthClient._instanceID}-${clientId}`, store);
     }
-    this._authenticationCore = new AuthenticationCore(this._dataLayer, cryptoUtils);
-    _AsgardeoAuthClient._authenticationCore = new AuthenticationCore(this._dataLayer, cryptoUtils);
-    await this._dataLayer.setConfigData({
+    this._cryptoUtils = cryptoUtils;
+    this._cryptoHelper = new IsomorphicCrypto(cryptoUtils);
+    this._authenticationHelper = new AuthenticationHelper(this._storageManager, this._cryptoHelper);
+    this._config = async () => await this._storageManager.getConfigData();
+    this._oidcProviderMetaData = async () => await this._storageManager.loadOpenIDProviderConfiguration();
+    _AsgardeoAuthClient._authenticationHelper = this._authenticationHelper;
+    await this._storageManager.setConfigData({
       ...DefaultConfig,
       ...config,
-      scope: [
-        ...DefaultConfig.scope ?? [],
-        ...config.scope?.filter((scope) => !DefaultConfig?.scope?.includes(scope)) ?? []
-      ]
+      scope: processOpenIDScopes_default(config.scopes)
     });
   }
   /**
-   * This method returns the `DataLayer` object that allows you to access authentication data.
+   * This method returns the `StorageManager` object that allows you to access authentication data.
    *
-   * @returns - The `DataLayer` object.
+   * @returns - The `StorageManager` object.
    *
    * @example
    * ```
-   * const data = auth.getDataLayer();
+   * const data = auth.getStorageManager();
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getDataLayer}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getStorageManager}
    *
    * @preserve
    */
-  getDataLayer() {
-    return this._dataLayer;
+  getStorageManager() {
+    return this._storageManager;
   }
   /**
    * This method returns the `instanceID` variable of the given instance.
@@ -1443,82 +1105,87 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @example
    * ```
-   * const instanceId = auth.getInstanceID();
+   * const instanceId = auth.getInstanceId();
    * ```
    *
    * @preserve
    */
-  getInstanceID() {
+  getInstanceId() {
     return _AsgardeoAuthClient._instanceID;
   }
-  /**
-   * This is an async method that returns a Promise that resolves with the authorization URL parameters.
-   *
-   * @param config - (Optional) A config object to force initialization and pass
-   * custom path parameters such as the `fidp` parameter.
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
-   * scenarios where each user should be uniquely identified.
-   *
-   * @returns - A promise that resolves with the authorization URL parameters.
-   *
-   * @example
-   * ```
-   * auth.getAuthorizationURLParams().then((params)=>{
-   *  // console.log(params);
-   * }).catch((error)=>{
-   *  // console.error(error);
-   * });
-   * ```
-   *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getAuthorizationURLParams}
-   *
-   * @preserve
-   */
-  async getAuthorizationURLParams(config, userID) {
-    const authRequestConfig = { ...config };
-    delete authRequestConfig?.forceInit;
-    if (await this._dataLayer.getTemporaryDataParameter(
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
-    )) {
-      return this._authenticationCore.getAuthorizationURLParams(authRequestConfig, userID);
-    }
-    return this._authenticationCore.getOIDCProviderMetaData(config?.forceInit).then(() => {
-      return this._authenticationCore.getAuthorizationURLParams(authRequestConfig, userID);
-    });
-  }
   /**
    * This is an async method that returns a Promise that resolves with the authorization URL.
    *
    * @param config - (Optional) A config object to force initialization and pass
    * custom path parameters such as the fidp parameter.
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A promise that resolves with the authorization URL.
    *
    * @example
    * ```
-   * auth.getAuthorizationURL().then((url)=>{
+   * auth.getSignInUrl().then((url)=>{
    *  // console.log(url);
    * }).catch((error)=>{
    *  // console.error(error);
    * });
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getAuthorizationURL}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getSignInUrl}
    *
    * @preserve
    */
-  async getAuthorizationURL(config, userID) {
-    const authRequestConfig = { ...config };
+  async getSignInUrl(requestConfig, userId) {
+    const authRequestConfig = { ...requestConfig };
     delete authRequestConfig?.forceInit;
-    if (await this._dataLayer.getTemporaryDataParameter(
+    const __TODO__ = async () => {
+      const authorizeEndpoint = await this._storageManager.getOIDCProviderMetaDataParameter(
+        OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION
+      );
+      if (!authorizeEndpoint || authorizeEndpoint.trim().length === 0) {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-GAU-NF01",
+          "No authorization endpoint found.",
+          "No authorization endpoint was found in the OIDC provider meta data from the well-known endpoint or the authorization endpoint passed to the SDK is empty."
+        );
+      }
+      const authorizeRequest = new URL(authorizeEndpoint);
+      const configData = await this._config();
+      const tempStore = await this._storageManager.getTemporaryData(userId);
+      const pkceKey = await generatePkceStorageKey_default(tempStore);
+      let codeVerifier;
+      let codeChallenge;
+      if (configData.enablePKCE) {
+        codeVerifier = this._cryptoHelper?.getCodeVerifier();
+        codeChallenge = this._cryptoHelper?.getCodeChallenge(codeVerifier);
+        await this._storageManager.setTemporaryDataParameter(pkceKey, codeVerifier, userId);
+      }
+      const authorizeRequestParams = getAuthorizeRequestUrlParams_default(
+        {
+          redirectUri: configData.afterSignInUrl,
+          clientId: configData.clientId,
+          scopes: processOpenIDScopes_default(configData.scopes),
+          responseMode: configData.responseMode,
+          codeChallengeMethod: PKCEConstants_default.DEFAULT_CODE_CHALLENGE_METHOD,
+          codeChallenge,
+          prompt: configData.prompt
+        },
+        { key: pkceKey },
+        authRequestConfig
+      );
+      for (const [key, value] of authorizeRequestParams.entries()) {
+        authorizeRequest.searchParams.append(key, value);
+      }
+      return authorizeRequest.toString();
+    };
+    if (await this._storageManager.getTemporaryDataParameter(
       OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
     )) {
-      return this._authenticationCore.getAuthorizationURL(authRequestConfig, userID);
+      return __TODO__();
     }
-    return this._authenticationCore.getOIDCProviderMetaData(config?.forceInit).then(() => {
-      return this._authenticationCore.getAuthorizationURL(authRequestConfig, userID);
+    return this.loadOpenIDProviderConfiguration(requestConfig?.forceInit).then(() => {
+      return __TODO__();
     });
   }
   /**
@@ -1527,7 +1194,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @param authorizationCode - The authorization code.
    * @param sessionState - The session state.
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A Promise that resolves with the token response.
@@ -1546,32 +1213,139 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  async requestAccessToken(authorizationCode, sessionState, state, userID, tokenRequestConfig) {
-    if (await this._dataLayer.getTemporaryDataParameter(
-      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
-    )) {
-      return this._authenticationCore.requestAccessToken(
-        authorizationCode,
+  async requestAccessToken(authorizationCode, sessionState, state, userId, tokenRequestConfig) {
+    const __TODO__ = async () => {
+      const tokenEndpoint = (await this._oidcProviderMetaData()).token_endpoint;
+      const configData = await this._config();
+      if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-RAT1-NF01",
+          "Token endpoint not found.",
+          "No token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the token endpoint passed to the SDK is empty."
+        );
+      }
+      sessionState && await this._storageManager.setSessionDataParameter(
+        OIDCRequestConstants_default.Params.SESSION_STATE,
         sessionState,
-        state,
-        userID,
-        tokenRequestConfig
+        userId
       );
+      const body = new URLSearchParams();
+      body.set("client_id", configData.clientId);
+      if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
+        body.set("client_secret", configData.clientSecret);
+      }
+      const code = authorizationCode;
+      body.set("code", code);
+      body.set("grant_type", "authorization_code");
+      body.set("redirect_uri", configData.afterSignInUrl);
+      if (tokenRequestConfig?.params) {
+        Object.entries(tokenRequestConfig.params).forEach(([key, value]) => {
+          body.append(key, value);
+        });
+      }
+      if (configData.enablePKCE) {
+        body.set(
+          "code_verifier",
+          `${await this._storageManager.getTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userId)}`
+        );
+        await this._storageManager.removeTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userId);
+      }
+      let tokenResponse;
+      try {
+        tokenResponse = await fetch(tokenEndpoint, {
+          body,
+          credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/x-www-form-urlencoded"
+          },
+          method: "POST"
+        });
+      } catch (error) {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-RAT1-NE02",
+          "Requesting access token failed",
+          error ?? "The request to get the access token from the server failed."
+        );
+      }
+      if (!tokenResponse.ok) {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-RAT1-HE03",
+          `Requesting access token failed with ${tokenResponse.statusText}`,
+          await tokenResponse.json()
+        );
+      }
+      return await this._authenticationHelper.handleTokenResponse(tokenResponse, userId);
+    };
+    if (await this._storageManager.getTemporaryDataParameter(
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
+    )) {
+      return __TODO__();
     }
-    return this._authenticationCore.getOIDCProviderMetaData(false).then(() => {
-      return this._authenticationCore.requestAccessToken(
-        authorizationCode,
-        sessionState,
-        state,
-        userID,
-        tokenRequestConfig
-      );
+    return this.loadOpenIDProviderConfiguration(false).then(() => {
+      return __TODO__();
     });
   }
+  async loadOpenIDProviderConfiguration(forceInit) {
+    const configData = await this._config();
+    if (!forceInit && await this._storageManager.getTemporaryDataParameter(
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
+    )) {
+      return Promise.resolve();
+    }
+    const wellKnownEndpoint = configData.wellKnownEndpoint;
+    if (wellKnownEndpoint) {
+      let response;
+      try {
+        response = await fetch(wellKnownEndpoint);
+        if (response.status !== 200 || !response.ok) {
+          throw new Error();
+        }
+      } catch {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-GOPMD-HE01",
+          "Invalid well-known response",
+          "The well known endpoint response has been failed with an error."
+        );
+      }
+      await this._storageManager.setOIDCProviderMetaData(
+        await this._authenticationHelper.resolveEndpoints(await response.json())
+      );
+      await this._storageManager.setTemporaryDataParameter(
+        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
+        true
+      );
+      return Promise.resolve();
+    } else if (configData.baseUrl) {
+      try {
+        await this._storageManager.setOIDCProviderMetaData(
+          await this._authenticationHelper.resolveEndpointsByBaseURL()
+        );
+      } catch (error) {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-GOPMD-IV02",
+          "Resolving endpoints failed.",
+          error ?? "Resolving endpoints by base url failed."
+        );
+      }
+      await this._storageManager.setTemporaryDataParameter(
+        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
+        true
+      );
+      return Promise.resolve();
+    } else {
+      await this._storageManager.setOIDCProviderMetaData(await this._authenticationHelper.resolveEndpointsExplicitly());
+      await this._storageManager.setTemporaryDataParameter(
+        OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
+        true
+      );
+      return Promise.resolve();
+    }
+  }
   /**
    * This method returns the sign-out URL.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * **This doesn't clear the authentication data.**
@@ -1580,15 +1354,48 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @example
    * ```
-   * const signOutUrl = await auth.getSignOutURL();
+   * const signOutUrl = await auth.getSignOutUrl();
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getSignOutURL}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getSignOutUrl}
    *
    * @preserve
    */
-  async getSignOutURL(userID) {
-    return this._authenticationCore.getSignOutURL(userID);
+  async getSignOutUrl(userId) {
+    const logoutEndpoint = (await this._oidcProviderMetaData())?.end_session_endpoint;
+    const configData = await this._config();
+    if (!logoutEndpoint || logoutEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-GSOU-NF01",
+        "Sign-out endpoint not found.",
+        "No sign-out endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the sign-out endpoint passed to the SDK is empty."
+      );
+    }
+    const callbackURL = configData?.afterSignOutUrl ?? configData?.afterSignInUrl;
+    if (!callbackURL || callbackURL.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-GSOU-NF03",
+        "No sign-out redirect URL found.",
+        "The sign-out redirect URL cannot be found or the URL passed to the SDK is empty. No sign-in redirect URL has been found either. "
+      );
+    }
+    const queryParams = new URLSearchParams();
+    queryParams.set("post_logout_redirect_uri", callbackURL);
+    if (configData.sendIdTokenInLogoutRequest) {
+      const idToken = (await this._storageManager.getSessionData(userId))?.id_token;
+      if (!idToken || idToken.trim().length === 0) {
+        throw new AsgardeoAuthException(
+          "JS-AUTH_CORE-GSOU-NF02",
+          "ID token not found.",
+          "No ID token could be found. Either the session information is lost or you have not signed in."
+        );
+      }
+      queryParams.set("id_token_hint", idToken);
+    } else {
+      queryParams.set("client_id", configData.clientId);
+    }
+    queryParams.set("state", OIDCRequestConstants_default.Params.SIGN_OUT_SUCCESS);
+    return `${logoutEndpoint}?${queryParams.toString()}`;
   }
   /**
    * This method returns OIDC service endpoints that are fetched from the `.well-known` endpoint.
@@ -1597,75 +1404,103 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @example
    * ```
-   * const endpoints = await auth.getOIDCServiceEndpoints();
+   * const endpoints = await auth.getOpenIDProviderEndpoints();
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getOIDCServiceEndpoints}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getOpenIDProviderEndpoints}
    *
    * @preserve
    */
-  async getOIDCServiceEndpoints() {
-    return this._authenticationCore.getOIDCServiceEndpoints();
+  async getOpenIDProviderEndpoints() {
+    const oidcProviderMetaData = await this._oidcProviderMetaData();
+    return {
+      authorizationEndpoint: oidcProviderMetaData.authorization_endpoint ?? "",
+      checkSessionIframe: oidcProviderMetaData.check_session_iframe ?? "",
+      endSessionEndpoint: oidcProviderMetaData.end_session_endpoint ?? "",
+      introspectionEndpoint: oidcProviderMetaData.introspection_endpoint ?? "",
+      issuer: oidcProviderMetaData.issuer ?? "",
+      jwksUri: oidcProviderMetaData.jwks_uri ?? "",
+      registrationEndpoint: oidcProviderMetaData.registration_endpoint ?? "",
+      revocationEndpoint: oidcProviderMetaData.revocation_endpoint ?? "",
+      tokenEndpoint: oidcProviderMetaData.token_endpoint ?? "",
+      userinfoEndpoint: oidcProviderMetaData.userinfo_endpoint ?? ""
+    };
   }
   /**
    * This method decodes the payload of the ID token and returns it.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A Promise that resolves with the decoded ID token payload.
    *
    * @example
    * ```
-   * const decodedIdToken = await auth.getDecodedIDToken();
+   * const decodedIdToken = await auth.getDecodedIdToken();
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getDecodedIDToken}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getDecodedIdToken}
    *
    * @preserve
    */
-  async getDecodedIDToken(userID) {
-    return this._authenticationCore.getDecodedIDToken(userID);
+  async getDecodedIdToken(userId) {
+    const idToken = (await this._storageManager.getSessionData(userId)).id_token;
+    const payload = this._cryptoHelper.decodeIdToken(idToken);
+    return payload;
   }
   /**
    * This method returns the ID token.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A Promise that resolves with the ID token.
    *
    * @example
    * ```
-   * const idToken = await auth.getIDToken();
+   * const idToken = await auth.getIdToken();
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getIDToken}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getIdToken}
    *
    * @preserve
    */
-  async getIDToken(userID) {
-    return this._authenticationCore.getIDToken(userID);
+  async getIdToken(userId) {
+    return (await this._storageManager.getSessionData(userId)).id_token;
   }
   /**
    * This method returns the basic user information obtained from the ID token.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A Promise that resolves with an object containing the basic user information.
    *
    * @example
    * ```
-   * const userInfo = await auth.getBasicUserInfo();
+   * const userInfo = await auth.getUser();
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getBasicUserInfo}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getUser}
    *
    * @preserve
    */
-  async getBasicUserInfo(userID) {
-    return this._authenticationCore.getBasicUserInfo(userID);
+  async getUser(userId) {
+    const sessionData = await this._storageManager.getSessionData(userId);
+    const authenticatedUser = this._authenticationHelper.getAuthenticatedUserInfo(sessionData?.id_token);
+    Object.keys(authenticatedUser).forEach((key) => {
+      if (authenticatedUser[key] === void 0 || authenticatedUser[key] === "" || authenticatedUser[key] === null) {
+        delete authenticatedUser[key];
+      }
+    });
+    return authenticatedUser;
+  }
+  async getUserSession(userId) {
+    const sessionData = await this._storageManager.getSessionData(userId);
+    return {
+      scopes: sessionData?.scope?.split(" "),
+      sessionState: sessionData?.session_state ?? ""
+    };
   }
   /**
    * This method returns the crypto helper object.
@@ -1677,17 +1512,17 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * const cryptoHelper = await auth.IsomorphicCrypto();
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getCryptoHelper}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getCrypto}
    *
    * @preserve
    */
-  async getCryptoHelper() {
-    return this._authenticationCore.getCryptoHelper();
+  async getCrypto() {
+    return this._cryptoHelper;
   }
   /**
    * This method revokes the access token.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * **This method also clears the authentication data.**
@@ -1707,14 +1542,56 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  revokeAccessToken(userID) {
-    return this._authenticationCore.revokeAccessToken(userID);
+  async revokeAccessToken(userId) {
+    const revokeTokenEndpoint = (await this._oidcProviderMetaData()).revocation_endpoint;
+    const configData = await this._config();
+    if (!revokeTokenEndpoint || revokeTokenEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT3-NF01",
+        "No revoke access token endpoint found.",
+        "No revoke access token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the revoke access token endpoint passed to the SDK is empty."
+      );
+    }
+    const body = [];
+    body.push(`client_id=${configData.clientId}`);
+    body.push(`token=${(await this._storageManager.getSessionData(userId)).access_token}`);
+    body.push("token_type_hint=access_token");
+    if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
+      body.push(`client_secret=${configData.clientSecret}`);
+    }
+    let response;
+    try {
+      response = await fetch(revokeTokenEndpoint, {
+        body: body.join("&"),
+        credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        method: "POST"
+      });
+    } catch (error) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT3-NE02",
+        "The request to revoke access token failed.",
+        error ?? "The request sent to revoke the access token failed."
+      );
+    }
+    if (response.status !== 200 || !response.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT3-HE03",
+        `Invalid response status received for revoke access token request (${response.statusText}).`,
+        await response.json()
+      );
+    }
+    this._authenticationHelper.clearSession(userId);
+    return Promise.resolve(response);
   }
   /**
    * This method refreshes the access token and returns a Promise that resolves with the new access
    * token and other relevant data.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A Promise that resolves with the token response.
@@ -1732,13 +1609,62 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  refreshAccessToken(userID) {
-    return this._authenticationCore.refreshAccessToken(userID);
+  async refreshAccessToken(userId) {
+    const tokenEndpoint = (await this._oidcProviderMetaData()).token_endpoint;
+    const configData = await this._config();
+    const sessionData = await this._storageManager.getSessionData(userId);
+    if (!sessionData.refresh_token) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT2-NF01",
+        "No refresh token found.",
+        "There was no refresh token found. Asgardeo doesn't return a refresh token if the refresh token grant is not enabled."
+      );
+    }
+    if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT2-NF02",
+        "No refresh token endpoint found.",
+        "No refresh token endpoint was in the OIDC provider meta data returned by the well-known endpoint or the refresh token endpoint passed to the SDK is empty."
+      );
+    }
+    const body = [];
+    body.push(`client_id=${configData.clientId}`);
+    body.push(`refresh_token=${sessionData.refresh_token}`);
+    body.push("grant_type=refresh_token");
+    if (configData.clientSecret && configData.clientSecret.trim().length > 0) {
+      body.push(`client_secret=${configData.clientSecret}`);
+    }
+    let tokenResponse;
+    try {
+      tokenResponse = await fetch(tokenEndpoint, {
+        body: body.join("&"),
+        credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        method: "POST"
+      });
+    } catch (error) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT2-NR03",
+        "Refresh access token request failed.",
+        error ?? "The request to refresh the access token failed."
+      );
+    }
+    if (!tokenResponse.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RAT2-HE04",
+        `Refreshing access token failed with ${tokenResponse.statusText}`,
+        await tokenResponse.json()
+      );
+    }
+    return this._authenticationHelper.handleTokenResponse(tokenResponse, userId);
   }
   /**
    * This method returns the access token.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A Promise that resolves with the access token.
@@ -1752,15 +1678,15 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  async getAccessToken(userID) {
-    return this._authenticationCore.getAccessToken(userID);
+  async getAccessToken(userId) {
+    return (await this._storageManager.getSessionData(userId))?.access_token;
   }
   /**
    * This method sends a custom-grant request and returns a Promise that resolves with the response
    * depending on the config passed.
    *
    * @param config - A config object containing the custom grant configurations.
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A Promise that resolves with the response depending
@@ -1771,7 +1697,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * const config = {
    *   attachToken: false,
    *   data: {
-   *       client_id: "{{clientID}}",
+   *       client_id: "{{clientId}}",
    *       grant_type: "account_switch",
    *       scope: "{{scope}}",
    *       token: "{{token}}",
@@ -1782,44 +1708,115 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *   signInRequired: true
    * }
    *
-   * auth.requestCustomGrant(config).then((response)=>{
+   * auth.exchangeToken(config).then((response)=>{
    *  // console.log(response);
    * }).catch((error)=>{
    *  // console.error(error);
    * });
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#requestCustomGrant}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#exchangeToken}
    *
    * @preserve
    */
-  requestCustomGrant(config, userID) {
-    return this._authenticationCore.requestCustomGrant(config, userID);
+  async exchangeToken(config, userId) {
+    const oidcProviderMetadata = await this._oidcProviderMetaData();
+    const configData = await this._config();
+    let tokenEndpoint;
+    if (config.tokenEndpoint && config.tokenEndpoint.trim().length !== 0) {
+      tokenEndpoint = config.tokenEndpoint;
+    } else {
+      tokenEndpoint = oidcProviderMetadata.token_endpoint;
+    }
+    if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RCG-NF01",
+        "Token endpoint not found.",
+        "No token endpoint was found in the OIDC provider meta data returned by the well-known endpoint or the token endpoint passed to the SDK is empty."
+      );
+    }
+    const data = await Promise.all(
+      Object.entries(config.data).map(async ([key, value]) => {
+        const newValue = await this._authenticationHelper.replaceCustomGrantTemplateTags(
+          value,
+          userId
+        );
+        return `${key}=${newValue}`;
+      })
+    );
+    let requestHeaders = {
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded"
+    };
+    if (config.attachToken) {
+      requestHeaders = {
+        ...requestHeaders,
+        Authorization: `Bearer ${(await this._storageManager.getSessionData(userId)).access_token}`
+      };
+    }
+    const requestConfig = {
+      body: data.join("&"),
+      credentials: configData.sendCookiesInRequests ? "include" : "same-origin",
+      headers: new Headers(requestHeaders),
+      method: "POST"
+    };
+    let response;
+    try {
+      response = await fetch(tokenEndpoint, requestConfig);
+    } catch (error) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RCG-NE02",
+        "The custom grant request failed.",
+        error ?? "The request sent to get the custom grant failed."
+      );
+    }
+    if (response.status !== 200 || !response.ok) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_CORE-RCG-HE03",
+        `Invalid response status received for the custom grant request. (${response.statusText})`,
+        await response.json()
+      );
+    }
+    if (config.returnsSession) {
+      return this._authenticationHelper.handleTokenResponse(response, userId);
+    } else {
+      return Promise.resolve(await response.json());
+    }
   }
   /**
    * This method returns if the user is authenticated or not.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @returns - A Promise that resolves with `true` if the user is authenticated, `false` otherwise.
    *
    * @example
    * ```
-   * await auth.isAuthenticated();
+   * await auth.isSignedIn();
    * ```
    *
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#isAuthenticated}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#isSignedIn}
    *
    * @preserve
    */
-  async isAuthenticated(userID) {
-    return this._authenticationCore.isAuthenticated(userID);
+  async isSignedIn(userId) {
+    const isAccessTokenAvailable = Boolean(await this.getAccessToken(userId));
+    const createdAt = (await this._storageManager.getSessionData(userId))?.created_at;
+    const expiresInString = (await this._storageManager.getSessionData(userId))?.expires_in;
+    if (!expiresInString) {
+      return false;
+    }
+    const expiresIn = parseInt(expiresInString) * 1e3;
+    const currentTime = (/* @__PURE__ */ new Date()).getTime();
+    const isAccessTokenValid = createdAt + expiresIn > currentTime;
+    const isSignedIn = isAccessTokenAvailable && isAccessTokenValid;
+    return isSignedIn;
   }
   /**
    * This method returns the PKCE code generated during the generation of the authentication URL.
    *
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    * @param state - The state parameter that was passed in the authentication URL.
    *
@@ -1834,15 +1831,18 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  async getPKCECode(state, userID) {
-    return this._authenticationCore.getPKCECode(state, userID);
+  async getPKCECode(state, userId) {
+    return await this._storageManager.getTemporaryDataParameter(
+      extractPkceStorageKeyFromState_default(state),
+      userId
+    );
   }
   /**
    * This method sets the PKCE code to the data store.
    *
    * @param pkce - The PKCE code.
    * @param state - The state parameter that was passed in the authentication URL.
-   * @param userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * @param userId - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
    * scenarios where each user should be uniquely identified.
    *
    * @example
@@ -1854,15 +1854,15 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  async setPKCECode(pkce, state, userID) {
-    await this._authenticationCore.setPKCECode(pkce, state, userID);
+  async setPKCECode(pkce, state, userId) {
+    return await this._storageManager.setTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), pkce, userId);
   }
   /**
    * This method returns if the sign-out is successful or not.
    *
    * @param signOutRedirectUrl - The URL to which the user has been redirected to after signing-out.
    *
-   * **The server appends path parameters to the `signOutRedirectURL` and these path parameters
+   * **The server appends path parameters to the `afterSignOutUrl` and these path parameters
    *  are required for this method to function.**
    *
    * @returns - `true` if successful, `false` otherwise.
@@ -1871,8 +1871,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  static isSignOutSuccessful(signOutRedirectURL) {
-    const url = new URL(signOutRedirectURL);
+  static isSignOutSuccessful(afterSignOutUrl) {
+    const url = new URL(afterSignOutUrl);
     const stateParam = url.searchParams.get(OIDCRequestConstants_default.Params.STATE);
     const error = Boolean(url.searchParams.get("error"));
     return stateParam ? stateParam === OIDCRequestConstants_default.Params.SIGN_OUT_SUCCESS && !error : false;
@@ -1882,7 +1882,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @param signOutRedirectUrl - The URL to which the user has been redirected to after signing-out.
    *
-   * **The server appends path parameters to the `signOutRedirectURL` and these path parameters
+   * **The server appends path parameters to the `afterSignOutUrl` and these path parameters
    *  are required for this method to function.**
    *
    * @returns - `true` if successful, `false` otherwise.
@@ -1891,8 +1891,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  static didSignOutFail(signOutRedirectURL) {
-    const url = new URL(signOutRedirectURL);
+  static didSignOutFail(afterSignOutUrl) {
+    const url = new URL(afterSignOutUrl);
     const stateParam = url.searchParams.get(OIDCRequestConstants_default.Params.STATE);
     const error = Boolean(url.searchParams.get("error"));
     return stateParam ? stateParam === OIDCRequestConstants_default.Params.SIGN_OUT_SUCCESS && error : false;
@@ -1905,61 +1905,31 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @example
    * ```
    * const config = {
-   *     signInRedirectURL: "http://localhost:3000/sign-in",
-   *     clientID: "client ID",
+   *     afterSignInUrl: "http://localhost:3000/sign-in",
+   *     clientId: "client ID",
    *     baseUrl: "https://localhost:9443"
    * }
    *
-   * await auth.updateConfig(config);
+   * await auth.reInitialize(config);
    * ```
-   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#updateConfig}
+   * {@link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#reInitialize}
    *
    * @preserve
    */
-  async updateConfig(config) {
-    await this._authenticationCore.updateConfig(config);
+  async reInitialize(config) {
+    await this._storageManager.setConfigData(config);
+    await this.loadOpenIDProviderConfiguration(true);
   }
-  static async clearUserSessionData(userID) {
-    await this._authenticationCore.clearUserSessionData(userID);
+  static async clearSession(userId) {
+    await this._authenticationHelper.clearSession(userId);
   }
 };
 __publicField(_AsgardeoAuthClient, "_instanceID");
-__publicField(_AsgardeoAuthClient, "_authenticationCore");
+// FIXME: Validate this.
+// Ref: https://github.com/asgardeo/asgardeo-auth-js-core/pull/205
+__publicField(_AsgardeoAuthClient, "_authenticationHelper");
 var AsgardeoAuthClient = _AsgardeoAuthClient;
 
-// src/errors/AsgardeoError.ts
-var AsgardeoError = class _AsgardeoError extends Error {
-  constructor(message, code, origin) {
-    const _origin = _AsgardeoError.resolveOrigin(origin);
-    const prefix = `\u{1F6E1}\uFE0F Asgardeo - ${_origin}:`;
-    const regex = new RegExp(`\u{1F6E1}\uFE0F\\s*Asgardeo\\s*-\\s*${_origin}:`, "i");
-    const sanitized = message.replace(regex, "");
-    const _message = `${prefix} ${sanitized.trim()}
-
-(code="${code}")
-`;
-    super(_message);
-    __publicField(this, "code");
-    __publicField(this, "origin");
-    this.name = new.target.name;
-    this.code = code;
-    this.origin = _origin;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, new.target);
-    }
-  }
-  static resolveOrigin(origin) {
-    if (!origin) {
-      return "@asgardeo/javascript";
-    }
-    return `@asgardeo/${origin}`;
-  }
-  toString() {
-    return `[${this.name}]
-Message: ${this.message}`;
-  }
-};
-
 // src/errors/AsgardeoAPIError.ts
 var AsgardeoAPIError = class extends AsgardeoError {
   /**
@@ -1993,7 +1963,95 @@ Message: ${this.message}`;
   }
 };
 
-// src/api/oidc/getUserInfo.ts
+// src/api/initializeApplicationNativeAuthentication.ts
+var initializeApplicationNativeAuthentication = async ({
+  url,
+  baseUrl,
+  payload,
+  ...requestConfig
+}) => {
+  if (!payload) {
+    throw new AsgardeoAPIError(
+      "Authorization payload is required",
+      "initializeApplicationNativeAuthentication-ValidationError-002",
+      "javascript",
+      400,
+      "If an authorization payload is not provided, the request cannot be constructed correctly."
+    );
+  }
+  const searchParams = new URLSearchParams();
+  Object.entries(payload).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) {
+      searchParams.append(key, String(value));
+    }
+  });
+  const { headers: customHeaders, ...otherConfig } = requestConfig;
+  const response = await fetch(url ?? `${baseUrl}/oauth2/authorize`, {
+    method: requestConfig.method || "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json",
+      ...customHeaders
+    },
+    body: searchParams.toString(),
+    ...otherConfig
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new AsgardeoAPIError(
+      `Authorization request failed: ${errorText}`,
+      "initializeApplicationNativeAuthentication-ResponseError-001",
+      "javascript",
+      response.status,
+      response.statusText
+    );
+  }
+  return await response.json();
+};
+var initializeApplicationNativeAuthentication_default = initializeApplicationNativeAuthentication;
+
+// src/api/handleApplicationNativeAuthentication.ts
+var handleApplicationNativeAuthentication = async ({
+  url,
+  baseUrl,
+  payload,
+  ...requestConfig
+}) => {
+  if (!payload) {
+    throw new AsgardeoAPIError(
+      "Authorization payload is required",
+      "handleApplicationNativeAuthentication-ValidationError-002",
+      "javascript",
+      400,
+      "If an authorization payload is not provided, the request cannot be constructed correctly."
+    );
+  }
+  const { headers: customHeaders, ...otherConfig } = requestConfig;
+  const response = await fetch(url ?? `${baseUrl}/oauth2/authn`, {
+    method: requestConfig.method || "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...customHeaders
+    },
+    body: JSON.stringify(payload),
+    ...otherConfig
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new AsgardeoAPIError(
+      `Authorization request failed: ${errorText}`,
+      "initializeApplicationNativeAuthentication-ResponseError-001",
+      "javascript",
+      response.status,
+      response.statusText
+    );
+  }
+  return await response.json();
+};
+var handleApplicationNativeAuthentication_default = handleApplicationNativeAuthentication;
+
+// src/api/getUserInfo.ts
 var getUserInfo = async ({ url, ...requestConfig }) => {
   try {
     new URL(url);
@@ -2028,37 +2086,60 @@ var getUserInfo = async ({ url, ...requestConfig }) => {
 };
 var getUserInfo_default = getUserInfo;
 
-// src/errors/AsgardeoRuntimeError.ts
-var AsgardeoRuntimeError = class extends AsgardeoError {
-  /**
-   * Creates an instance of AsgardeoRuntimeError.
-   *
-   * @param message - Human-readable description of the error
-   * @param code - A unique error code that identifies the error type
-   * @param details - Additional details about the error that might be helpful for debugging
-   * @param origin - Optional. The SDK origin (e.g. 'react', 'vue'). Defaults to generic 'Asgardeo'
-   * @constructor
-   */
-  constructor(message, code, origin, details) {
-    super(message, code, origin);
-    this.details = details;
-    Object.defineProperty(this, "name", {
-      value: "AsgardeoRuntimeError",
-      configurable: true,
-      writable: true
-    });
-  }
-  /**
-   * Returns a string representation of the runtime error
-   * @returns Formatted error string with name, code, details, and message
-   */
-  toString() {
-    const details = this.details ? `
-Details: ${JSON.stringify(this.details, null, 2)}` : "";
-    return `[${this.name}] (code="${this.code}")${details}
-Message: ${this.message}`;
+// src/constants/ApplicationNativeAuthenticationConstants.ts
+var ApplicationNativeAuthenticationConstants = {
+  SupportedAuthenticators: {
+    IdentifierFirst: "SWRlbnRpZmllckV4ZWN1dG9yOkxPQ0FM",
+    EmailOtp: "ZW1haWwtb3RwLWF1dGhlbnRpY2F0b3I6TE9DQUw",
+    Totp: "dG90cDpMT0NBTA",
+    UsernamePassword: "QmFzaWNBdXRoZW50aWNhdG9yOkxPQ0FM",
+    PushNotification: "cHVzaC1ub3RpZmljYXRpb24tYXV0aGVudGljYXRvcjpMT0NBTA",
+    Passkey: "RklET0F1dGhlbnRpY2F0b3I6TE9DQUw",
+    SmsOtp: "c21zLW90cC1hdXRoZW50aWNhdG9yOkxPQ0FM",
+    MagicLink: "TWFnaWNMaW5rQXV0aGVudGljYXRvcjpMT0NBTA",
+    Google: "R29vZ2xlT0lEQ0F1dGhlbnRpY2F0b3I6R29vZ2xl",
+    GitHub: "R2l0aHViQXV0aGVudGljYXRvcjpHaXRIdWI",
+    Microsoft: "T3BlbklEQ29ubmVjdEF1dGhlbnRpY2F0b3I6TWljcm9zb2Z0",
+    Facebook: "RmFjZWJvb2tBdXRoZW50aWNhdG9yOkZhY2Vib29r",
+    LinkedIn: "TGlua2VkSW5PSURDOkxpbmtlZElu",
+    SignInWithEthereum: "T3BlbklEQ29ubmVjdEF1dGhlbnRpY2F0b3I6U2lnbiBJbiBXaXRoIEV0aGVyZXVt"
   }
 };
+var ApplicationNativeAuthenticationConstants_default = ApplicationNativeAuthenticationConstants;
+
+// src/models/application-native-authentication.ts
+var ApplicationNativeAuthenticationFlowStatus = /* @__PURE__ */ ((ApplicationNativeAuthenticationFlowStatus2) => {
+  ApplicationNativeAuthenticationFlowStatus2["SuccessCompleted"] = "SUCCESS_COMPLETED";
+  ApplicationNativeAuthenticationFlowStatus2["FailCompleted"] = "FAIL_COMPLETED";
+  ApplicationNativeAuthenticationFlowStatus2["FailIncomplete"] = "FAIL_INCOMPLETE";
+  ApplicationNativeAuthenticationFlowStatus2["Incomplete"] = "INCOMPLETE";
+  return ApplicationNativeAuthenticationFlowStatus2;
+})(ApplicationNativeAuthenticationFlowStatus || {});
+var ApplicationNativeAuthenticationFlowType = /* @__PURE__ */ ((ApplicationNativeAuthenticationFlowType2) => {
+  ApplicationNativeAuthenticationFlowType2["Authentication"] = "AUTHENTICATION";
+  return ApplicationNativeAuthenticationFlowType2;
+})(ApplicationNativeAuthenticationFlowType || {});
+var ApplicationNativeAuthenticationStepType = /* @__PURE__ */ ((ApplicationNativeAuthenticationStepType2) => {
+  ApplicationNativeAuthenticationStepType2["AuthenticatorPrompt"] = "AUTHENTICATOR_PROMPT";
+  ApplicationNativeAuthenticationStepType2["MultOptionsPrompt"] = "MULTI_OPTIONS_PROMPT";
+  return ApplicationNativeAuthenticationStepType2;
+})(ApplicationNativeAuthenticationStepType || {});
+var ApplicationNativeAuthenticationAuthenticatorParamType = /* @__PURE__ */ ((ApplicationNativeAuthenticationAuthenticatorParamType2) => {
+  ApplicationNativeAuthenticationAuthenticatorParamType2["String"] = "STRING";
+  ApplicationNativeAuthenticationAuthenticatorParamType2["Integer"] = "INTEGER";
+  ApplicationNativeAuthenticationAuthenticatorParamType2["MultiValued"] = "MULTI_VALUED";
+  return ApplicationNativeAuthenticationAuthenticatorParamType2;
+})(ApplicationNativeAuthenticationAuthenticatorParamType || {});
+var ApplicationNativeAuthenticationAuthenticatorKnownIdPType = /* @__PURE__ */ ((ApplicationNativeAuthenticationAuthenticatorKnownIdPType2) => {
+  ApplicationNativeAuthenticationAuthenticatorKnownIdPType2["Local"] = "LOCAL";
+  return ApplicationNativeAuthenticationAuthenticatorKnownIdPType2;
+})(ApplicationNativeAuthenticationAuthenticatorKnownIdPType || {});
+var ApplicationNativeAuthenticationAuthenticatorPromptType = /* @__PURE__ */ ((ApplicationNativeAuthenticationAuthenticatorPromptType2) => {
+  ApplicationNativeAuthenticationAuthenticatorPromptType2["UserPrompt"] = "USER_PROMPT";
+  ApplicationNativeAuthenticationAuthenticatorPromptType2["InternalPrompt"] = "INTERNAL_PROMPT";
+  ApplicationNativeAuthenticationAuthenticatorPromptType2["RedirectionPrompt"] = "REDIRECTION_PROMPT";
+  return ApplicationNativeAuthenticationAuthenticatorPromptType2;
+})(ApplicationNativeAuthenticationAuthenticatorPromptType || {});
 
 // src/models/scim2-schema.ts
 var WellKnownSchemaIds = /* @__PURE__ */ ((WellKnownSchemaIds2) => {
@@ -2070,6 +2151,22 @@ var WellKnownSchemaIds = /* @__PURE__ */ ((WellKnownSchemaIds2) => {
   return WellKnownSchemaIds2;
 })(WellKnownSchemaIds || {});
 
+// src/models/field.ts
+var FieldType = /* @__PURE__ */ ((FieldType2) => {
+  FieldType2["Text"] = "TEXT";
+  FieldType2["Password"] = "PASSWORD";
+  FieldType2["Email"] = "EMAIL";
+  FieldType2["Number"] = "NUMBER";
+  FieldType2["Select"] = "SELECT";
+  FieldType2["Checkbox"] = "CHECKBOX";
+  FieldType2["Radio"] = "RADIO";
+  FieldType2["Otp"] = "OTP";
+  FieldType2["Date"] = "DATE";
+  FieldType2["Time"] = "TIME";
+  FieldType2["Textarea"] = "TEXTAREA";
+  return FieldType2;
+})(FieldType || {});
+
 // src/AsgardeoJavaScriptClient.ts
 var AsgardeoJavaScriptClient = class {
 };
@@ -2087,7 +2184,7 @@ var lightTheme = {
       contrastText: "#ffffff"
     },
     background: {
-      surface: "#f5f5f5",
+      surface: "#ffffff",
       disabled: "#f0f0f0",
       body: {
         main: "#1a1a1a"
@@ -2097,7 +2194,6 @@ var lightTheme = {
       main: "#d32f2f",
       contrastText: "#ffffff"
     },
-    surface: "#f5f5f5",
     text: {
       primary: "#1a1a1a",
       secondary: "#666666"
@@ -2134,7 +2230,6 @@ var darkTheme = {
       main: "#d32f2f",
       contrastText: "#ffffff"
     },
-    surface: "#2d2d2d",
     text: {
       primary: "#ffffff",
       secondary: "#b3b3b3"
@@ -2161,7 +2256,6 @@ var toCssVariables = (theme) => {
   cssVars["--asgardeo-color-background-body-main"] = theme.colors.background.body.main;
   cssVars["--asgardeo-color-error-main"] = theme.colors.error.main;
   cssVars["--asgardeo-color-error-contrastText"] = theme.colors.error.contrastText;
-  cssVars["--asgardeo-color-surface"] = theme.colors.surface;
   cssVars["--asgardeo-color-text-primary"] = theme.colors.text.primary;
   cssVars["--asgardeo-color-text-secondary"] = theme.colors.text.secondary;
   cssVars["--asgardeo-color-border"] = theme.colors.border;
@@ -2200,28 +2294,327 @@ var createTheme = (config = {}, isDark = false) => {
 };
 var createTheme_default = createTheme;
 
+// src/utils/deepMerge.ts
+var isPlainObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && Object.prototype.toString.call(value) === "[object Object]";
+};
+var deepMerge = (target, ...sources) => {
+  if (!target || typeof target !== "object") {
+    throw new Error("Target must be an object");
+  }
+  const result = { ...target };
+  sources.forEach((source) => {
+    if (!source || typeof source !== "object") {
+      return;
+    }
+    Object.keys(source).forEach((key) => {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+        result[key] = deepMerge(targetValue, sourceValue);
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    });
+  });
+  return result;
+};
+var deepMerge_default = deepMerge;
+
+// src/utils/flattenUserSchema.ts
+var flattenUserSchema = (schemas) => {
+  const flattenedAttributes = [];
+  schemas.forEach((schema) => {
+    if (schema.attributes && Array.isArray(schema.attributes)) {
+      schema.attributes.forEach((attribute) => {
+        if (attribute.subAttributes && Array.isArray(attribute.subAttributes)) {
+          attribute.subAttributes.forEach((subAttribute) => {
+            flattenedAttributes.push({
+              ...subAttribute,
+              name: `${attribute.name}.${subAttribute.name}`,
+              schemaId: schema.id
+            });
+          });
+        } else {
+          flattenedAttributes.push({
+            ...attribute,
+            schemaId: schema.id
+          });
+        }
+      });
+    }
+  });
+  return flattenedAttributes;
+};
+var flattenUserSchema_default = flattenUserSchema;
+
+// src/utils/get.ts
+var get = (object, path, defaultValue) => {
+  if (!object || !path) return defaultValue;
+  const pathArray = Array.isArray(path) ? path : path.split(".");
+  const result = pathArray.reduce((current, key) => {
+    return current?.[key];
+  }, object);
+  return result !== void 0 ? result : defaultValue;
+};
+var get_default = get;
+
+// src/utils/set.ts
+var set = (object, path, value) => {
+  if (!object || !path) return object;
+  const pathArray = Array.isArray(path) ? path : path.split(".");
+  const lastIndex = pathArray.length - 1;
+  pathArray.reduce((current, key, index) => {
+    if (index === lastIndex) {
+      current[key] = value;
+    } else {
+      if (!(key in current) || typeof current[key] !== "object" || current[key] === null) {
+        const nextKey = pathArray[index + 1];
+        current[key] = /^\d+$/.test(nextKey) ? [] : {};
+      }
+    }
+    return current[key];
+  }, object);
+  return object;
+};
+var set_default = set;
+
+// src/utils/generateUserProfile.ts
+var generateUserProfile = (meResponse, processedSchemas) => {
+  const profile = {};
+  processedSchemas.forEach((schema) => {
+    const { name, type, multiValued } = schema;
+    if (!name) return;
+    let value = get_default(meResponse, name);
+    if (value !== void 0) {
+      if (multiValued && !Array.isArray(value)) {
+        value = [value];
+      }
+    } else {
+      if (multiValued) {
+        value = void 0;
+      } else if (type === "STRING") {
+        value = "";
+      } else {
+        value = void 0;
+      }
+    }
+    set_default(profile, name, value);
+  });
+  return profile;
+};
+var generateUserProfile_default = generateUserProfile;
+
+// src/utils/getLatestStateParam.ts
+var getLatestPkceStorageKey = (tempStore) => {
+  const keys = [];
+  Object.keys(tempStore).forEach((key) => {
+    if (key.startsWith(PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER)) {
+      keys.push(key);
+    }
+  });
+  const lastKey = keys.sort().pop();
+  return lastKey ?? null;
+};
+var getLatestStateParam = (tempStore, state) => {
+  const latestPkceKey = getLatestPkceStorageKey(tempStore);
+  if (!latestPkceKey) {
+    return null;
+  }
+  return generateStateParamForRequestCorrelation_default(latestPkceKey, state);
+};
+var getLatestStateParam_default = getLatestStateParam;
+
+// src/utils/generateFlattenedUserProfile.ts
+var generateFlattenedUserProfile = (meResponse, processedSchemas) => {
+  const profile = {};
+  const allSchemaNames = processedSchemas.map((schema) => schema.name).filter(Boolean);
+  processedSchemas.forEach((schema) => {
+    const { name, type, multiValued } = schema;
+    if (!name) return;
+    const hasChildProperties = allSchemaNames.some(
+      (schemaName) => schemaName !== name && schemaName.startsWith(name + ".")
+    );
+    if (hasChildProperties) {
+      return;
+    }
+    let value = get_default(meResponse, name);
+    if (value !== void 0) {
+      if (multiValued && !Array.isArray(value)) {
+        value = [value];
+      }
+    } else {
+      if (multiValued) {
+        value = void 0;
+      } else if (type === "STRING") {
+        value = "";
+      } else {
+        value = void 0;
+      }
+    }
+    profile[name] = value;
+  });
+  return profile;
+};
+var generateFlattenedUserProfile_default = generateFlattenedUserProfile;
+
+// src/i18n/index.ts
+var i18n_exports = {};
+__export(i18n_exports, {
+  en_US: () => en_US_default
+});
+
+// src/i18n/en-US.ts
+var translations = {
+  /* |---------------------------------------------------------------| */
+  /* |                        Elements                               | */
+  /* |---------------------------------------------------------------| */
+  //* Buttons */
+  "elements.buttons.signIn": "Sign In",
+  "elements.buttons.signOut": "Sign Out",
+  "elements.buttons.signUp": "Sign Up",
+  "elements.buttons.facebook": "Continue with Facebook",
+  "elements.buttons.google": "Continue with Google",
+  "elements.buttons.github": "Continue with GitHub",
+  "elements.buttons.microsoft": "Continue with Microsoft",
+  "elements.buttons.linkedin": "Continue with LinkedIn",
+  "elements.buttons.ethereum": "Continue with Sign In Ethereum",
+  "elements.buttons.multi.option": "Continue with {connection}",
+  "elements.buttons.social": "Continue with {connection}",
+  /* Fields */
+  "elements.fields.placeholder": "Enter your {field}",
+  /* |---------------------------------------------------------------| */
+  /* |                        Widgets                                | */
+  /* |---------------------------------------------------------------| */
+  /* Base Sign In */
+  "signin.title": "Sign In",
+  /* Email OTP */
+  "email.otp.title": "OTP Verification",
+  "email.otp.subtitle": "Enter the code sent to your email address.",
+  "email.otp.submit.button": "Continue",
+  /* Identifier First */
+  "identifier.first.title": "Sign In",
+  "identifier.first.subtitle": "Enter your username or email address.",
+  "identifier.first.submit.button": "Continue",
+  /* SMS OTP */
+  "sms.otp.title": "OTP Verification",
+  "sms.otp.subtitle": "Enter the code sent to your phone number.",
+  "sms.otp.submit.button": "Continue",
+  /* TOTP */
+  "totp.title": "Verify Your Identity",
+  "totp.subtitle": "Enter the code from your authenticator app.",
+  "totp.submit.button": "Continue",
+  /* Username Password */
+  "username.password.submit.button": "Continue",
+  "username.password.title": "Sign In",
+  "username.password.subtitle": "Enter your username and password to continue.",
+  /* |---------------------------------------------------------------| */
+  /* |                        Messages                               | */
+  /* |---------------------------------------------------------------| */
+  "messages.loading": "Loading...",
+  /* |---------------------------------------------------------------| */
+  /* |                        Errors                                 | */
+  /* |---------------------------------------------------------------| */
+  "errors.title": "Error",
+  "errors.sign.in.initialization": "An error occurred while initializing. Please try again later.",
+  "errors.sign.in.flow.failure": "An error occurred during the sign-in flow. Please try again later.",
+  "errors.sign.in.flow.completion.failure": "An error occurred while completing the sign-in flow. Please try again later.",
+  "errors.sign.in.flow.passkeys.failure": "An error occurred while signing in with passkeys. Please try again later.",
+  "errors.sign.in.flow.passkeys.completion.failure": "An error occurred while completing the passkeys sign-in flow. Please try again later."
+};
+var metadata = {
+  localeCode: "en-US",
+  countryCode: "US",
+  languageCode: "en",
+  displayName: "English (United States)",
+  direction: "ltr"
+};
+var en_US = {
+  metadata,
+  translations
+};
+var en_US_default = en_US;
+
+// src/utils/getI18nBundles.ts
+var getI18nBundles = () => {
+  return i18n_exports;
+};
+var getI18nBundles_default = getI18nBundles;
+
 // src/utils/removeTrailingSlash.ts
 var removeTrailingSlash = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
 var removeTrailingSlash_default = removeTrailingSlash;
+
+// src/utils/resolveFieldType.ts
+var resolveFieldType = (field) => {
+  if (field.type === "STRING" /* String */) {
+    if (field.param === "OTPCode" /* Otp */) {
+      return "OTP" /* Otp */;
+    } else if (field?.confidential) {
+      return "PASSWORD" /* Password */;
+    }
+    return "TEXT" /* Text */;
+  }
+  throw new AsgardeoRuntimeError(
+    "Field type is not supported: " + field.type,
+    "resolveFieldType-Invalid-001",
+    "javascript",
+    "The provided field type is not supported. Please check the field configuration."
+  );
+};
+var resolveFieldType_default = resolveFieldType;
+
+// src/utils/resolveFieldName.ts
+var resolveFieldName = (field) => {
+  if (field.param) {
+    return field.param;
+  }
+  throw new AsgardeoRuntimeError(
+    "Field name is not supported: ",
+    "resolveFieldName-Invalid-001",
+    "javascript",
+    "The provided field name is not supported. Please check the field configuration."
+  );
+};
+var resolveFieldName_default = resolveFieldName;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ASGARDEO_SESSION_ACTIVE,
+  ApplicationNativeAuthenticationAuthenticatorKnownIdPType,
+  ApplicationNativeAuthenticationAuthenticatorParamType,
+  ApplicationNativeAuthenticationAuthenticatorPromptType,
+  ApplicationNativeAuthenticationConstants,
+  ApplicationNativeAuthenticationFlowStatus,
+  ApplicationNativeAuthenticationFlowType,
+  ApplicationNativeAuthenticationStepType,
   AsgardeoAPIError,
   AsgardeoAuthClient,
   AsgardeoAuthException,
   AsgardeoError,
   AsgardeoJavaScriptClient,
   AsgardeoRuntimeError,
-  DataLayer,
+  FieldType,
   IsomorphicCrypto,
   OIDCRequestConstants,
-  ResponseMode,
+  StorageManager,
   TokenConstants,
   WellKnownSchemaIds,
   createTheme,
+  deepMerge,
   extractPkceStorageKeyFromState,
   extractUserClaimsFromIdToken,
+  flattenUserSchema,
+  generateFlattenedUserProfile,
+  generateUserProfile,
+  get,
+  getI18nBundles,
+  getLatestStateParam,
   getUserInfo,
-  removeTrailingSlash
+  handleApplicationNativeAuthentication,
+  initializeApplicationNativeAuthentication,
+  processOpenIDScopes,
+  removeTrailingSlash,
+  resolveFieldName,
+  resolveFieldType,
+  set
 });
 //# sourceMappingURL=index.js.map