@asgardeo/javascript 0.7.0 → 0.7.2

package/dist/cjs/index.js

@@ -112,144 +112,6 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// 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 (error2) {
-      return false;
-    }
-  }
-  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(userId) {
-    return JSON.parse(await this._store.getData(this._resolveKey("config_data" /* ConfigData */, userId)) ?? 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);
-  }
-};
-var StorageManager_default = StorageManager;
-
 // src/constants/OIDCDiscoveryConstants.ts
 var OIDCDiscoveryConstants = {
   /**
@@ -263,11 +125,6 @@ var OIDCDiscoveryConstants = {
      * This endpoint is used to request authorization and receive an authorization code.
      */
     AUTHORIZATION: "/oauth2/authorize",
-    /**
-     * Session check iframe endpoint for session management.
-     * Used to monitor the user's session state through a hidden iframe.
-     */
-    SESSION_IFRAME: "/oidc/checksession",
     /**
      * End session endpoint for logout functionality.
      * Used to terminate the user's session and perform logout operations.
@@ -288,6 +145,11 @@ var OIDCDiscoveryConstants = {
      * Used to invalidate access or refresh tokens before they expire.
      */
     REVOCATION: "/oauth2/revoke",
+    /**
+     * Session check iframe endpoint for session management.
+     * Used to monitor the user's session state through a hidden iframe.
+     */
+    SESSION_IFRAME: "/oidc/checksession",
     /**
      * Token endpoint for obtaining access tokens.
      * Used to exchange authorization codes for access tokens and refresh tokens.
@@ -322,36 +184,36 @@ var OIDCDiscoveryConstants = {
          * Used to store the URL where authorization requests should be sent.
          */
         AUTHORIZATION: "authorization_endpoint",
-        /**
-         * Storage key for the token endpoint URL.
-         * Used to store the URL where token requests should be sent.
-         */
-        TOKEN: "token_endpoint",
-        /**
-         * Storage key for the revocation endpoint URL.
-         * Used to store the URL where token revocation requests should be sent.
-         */
-        REVOCATION: "revocation_endpoint",
         /**
          * Storage key for the end session endpoint URL.
          * Used to store the URL where logout requests should be sent.
          */
         END_SESSION: "end_session_endpoint",
+        /**
+         * Storage key for the issuer identifier URL.
+         * Used to store the URL that identifies the OpenID Provider.
+         */
+        ISSUER: "issuer",
         /**
          * Storage key for the JWKS URI endpoint URL.
          * Used to store the URL where JSON Web Key Sets can be retrieved.
          */
         JWKS: "jwks_uri",
+        /**
+         * Storage key for the revocation endpoint URL.
+         * Used to store the URL where token revocation requests should be sent.
+         */
+        REVOCATION: "revocation_endpoint",
         /**
          * Storage key for the session check iframe URL.
          * Used to store the URL of the iframe used for session state monitoring.
          */
         SESSION_IFRAME: "check_session_iframe",
         /**
-         * Storage key for the issuer identifier URL.
-         * Used to store the URL that identifies the OpenID Provider.
+         * Storage key for the token endpoint URL.
+         * Used to store the URL where token requests should be sent.
          */
-        ISSUER: "issuer",
+        TOKEN: "token_endpoint",
         /**
          * Storage key for the userinfo endpoint URL.
          * Used to store the URL where user information can be retrieved.
@@ -369,6 +231,93 @@ var OIDCDiscoveryConstants = {
 };
 var OIDCDiscoveryConstants_default = OIDCDiscoveryConstants;
 
+// 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.
+     */
+    ACCESS_TOKEN: "{{accessToken}}",
+    /**
+     * 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}}",
+    /**
+     * Placeholder for OAuth scopes in token exchange requests.
+     * Replaced with space-separated scope strings.
+     */
+    SCOPES: "{{scopes}}",
+    /**
+     * Placeholder for the username in token exchange operations.
+     * Used when user identity needs to be included in the exchange.
+     */
+    USERNAME: "{{username}}"
+  }
+};
+var TokenExchangeConstants_default = TokenExchangeConstants;
+
+// 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/models/platforms.ts
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["Asgardeo"] = "ASGARDEO";
+  Platform2["AsgardeoV2"] = "AsgardeoV2";
+  Platform2["IdentityServer"] = "IDENTITY_SERVER";
+  Platform2["Unknown"] = "UNKNOWN";
+  return Platform2;
+})(Platform || {});
+
+// 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];
+  });
+  return filteredPayload;
+};
+var extractUserClaimsFromIdToken_default = extractUserClaimsFromIdToken;
+
 // src/constants/ScopeConstants.ts
 var ScopeConstants = {
   /**
@@ -404,16 +353,16 @@ var OIDCRequestConstants = {
      * 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_SUCCESS: "sign_out_success",
+    /**
+     * State parameter used to maintain state between the request and the callback.
+     * Helps in preventing CSRF attacks.
+     */
+    STATE: "state"
   },
   /**
    * Constants related to the OpenID Connect (OIDC) sign-in flow.
@@ -453,22 +402,327 @@ var OIDCRequestConstants = {
 };
 var OIDCRequestConstants_default = OIDCRequestConstants;
 
-// src/errors/exception.ts
-var AsgardeoAuthException = class {
-  constructor(code, name, message) {
-    __publicField(this, "name");
+// src/errors/AsgardeoError.ts
+var AsgardeoError = class _AsgardeoError extends Error {
+  constructor(message, code, origin) {
+    const resolvedOrigin = _AsgardeoError.resolveOrigin(origin);
+    super(message);
     __publicField(this, "code");
-    __publicField(this, "message");
-    this.message = message;
-    this.name = name;
+    __publicField(this, "origin");
+    this.name = new.target.name;
     this.code = code;
-    Object.setPrototypeOf(this, new.target.prototype);
+    this.origin = resolvedOrigin;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, new.target);
+    }
+  }
+  static resolveOrigin(origin) {
+    if (!origin) {
+      return "@asgardeo/javascript";
+    }
+    return `@asgardeo/${origin}`;
+  }
+  toString() {
+    const prefix = `\u{1F6E1}\uFE0F Asgardeo - ${this.origin}:`;
+    return `[${this.name}]
+${prefix} ${this.message}
+(code="${this.code}")`;
   }
 };
 
-// src/constants/TokenConstants.ts
-var TokenConstants = {
-  /**
+// 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", {
+      configurable: true,
+      value: "AsgardeoRuntimeError",
+      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/utils/processOpenIDScopes.ts
+var processOpenIDScopes = (scopes) => {
+  let processedScopes = [];
+  if (scopes) {
+    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."
+      );
+    }
+  }
+  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(storageManagerInstance, cryptoHelperInstance) {
+    __publicField(this, "storageManager");
+    __publicField(this, "config");
+    __publicField(this, "oidcProviderMetaData");
+    __publicField(this, "cryptoHelper");
+    this.storageManager = storageManagerInstance;
+    this.config = async () => this.storageManager.getConfigData();
+    this.oidcProviderMetaData = async () => this.storageManager.loadOpenIDProviderConfiguration();
+    this.cryptoHelper = cryptoHelperInstance;
+  }
+  async resolveEndpoints(response) {
+    const oidcProviderMetaData = {};
+    const configData = await this.config();
+    if (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) => 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."
+      );
+    }
+    if (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;
+    if (!baseUrl) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER_REBO-NF01",
+        "Base URL not defined.",
+        "Base URL is not defined in AuthClient config."
+      );
+    }
+    if (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 endpointKeys = OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints;
+    const endpointPaths = OIDCDiscoveryConstants_default.Endpoints;
+    const defaultEndpoints = {
+      [endpointKeys.AUTHORIZATION]: `${baseUrl}${endpointPaths.AUTHORIZATION}`,
+      [endpointKeys.END_SESSION]: `${baseUrl}${endpointPaths.END_SESSION}`,
+      [endpointKeys.ISSUER]: `${baseUrl}${endpointPaths.ISSUER}`,
+      [endpointKeys.JWKS]: `${baseUrl}${endpointPaths.JWKS}`,
+      [endpointKeys.SESSION_IFRAME]: `${baseUrl}${endpointPaths.SESSION_IFRAME}`,
+      [endpointKeys.REVOCATION]: `${baseUrl}${endpointPaths.REVOCATION}`,
+      [endpointKeys.TOKEN]: `${baseUrl}${endpointPaths.TOKEN}`,
+      [endpointKeys.USERINFO]: `${baseUrl}${endpointPaths.USERINFO}`
+    };
+    if (configData.platform === "AsgardeoV2" /* AsgardeoV2 */) {
+      defaultEndpoints[OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.ISSUER] = `${baseUrl}`;
+    }
+    return { ...defaultEndpoints, ...oidcProviderMetaData };
+  }
+  async validateIdToken(idToken) {
+    const jwksEndpoint = (await this.storageManager.loadOpenIDProviderConfiguration()).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 (error2) {
+      throw new AsgardeoAuthException(
+        "JS-AUTH_HELPER-VIT-NE02",
+        "Request to jwks endpoint failed.",
+        error2 ?? "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();
+    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.decodeJwtToken(idToken).sub,
+      (await this.config()).tokenValidation?.idToken?.clockTolerance,
+      (await this.config()).tokenValidation?.idToken?.validateIssuer ?? true
+    );
+  }
+  getAuthenticatedUserInfo(idToken) {
+    const payload = this.cryptoHelper.decodeJwtToken(idToken);
+    const username = payload?.["username"] ?? "";
+    const givenName = payload?.["given_name"] ?? "";
+    const familyName = payload?.["family_name"] ?? "";
+    const fullName = givenName && familyName ? `${givenName} ${familyName}` : givenName || familyName || "";
+    const displayName = payload.preferred_username ?? fullName;
+    return {
+      displayName,
+      username,
+      ...extractUserClaimsFromIdToken_default(payload)
+    };
+  }
+  async replaceCustomGrantTemplateTags(text, userId) {
+    const configData = await this.config();
+    const sessionData = await this.storageManager.getSessionData(userId);
+    const scope = processOpenIDScopes_default(configData.scopes);
+    if (typeof text !== "string") {
+      return text;
+    }
+    return text.replace(TokenExchangeConstants_default.Placeholders.ACCESS_TOKEN, sessionData.access_token).replace(
+      TokenExchangeConstants_default.Placeholders.USERNAME,
+      this.getAuthenticatedUserInfo(sessionData.id_token).username
+    ).replace(TokenExchangeConstants_default.Placeholders.SCOPES, scope).replace(TokenExchangeConstants_default.Placeholders.CLIENT_ID, configData.clientId).replace(TokenExchangeConstants_default.Placeholders.CLIENT_SECRET, configData.clientSecret ?? "");
+  }
+  async clearSession(userId) {
+    await this.storageManager.removeTemporaryData(userId);
+    await this.storageManager.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()).tokenValidation?.idToken?.validate;
+    if (shouldValidateIdToken) {
+      return this.validateIdToken(parsedResponse.id_token).then(async () => {
+        await this.storageManager.setSessionData(parsedResponse, userId);
+        const tokenResponse2 = {
+          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(tokenResponse2);
+      });
+    }
+    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);
+  }
+};
+
+// 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: "#"
+    }
+  }
+};
+var PKCEConstants_default = PKCEConstants;
+
+// src/constants/TokenConstants.ts
+var TokenConstants = {
+  /**
    * Token signature validation constants.
    * Contains configurations related to token signature verification.
    */
@@ -511,8 +765,8 @@ var TokenConstants_default = TokenConstants;
 // src/IsomorphicCrypto.ts
 var IsomorphicCrypto = class {
   constructor(cryptoUtils) {
-    __publicField(this, "_cryptoUtils");
-    this._cryptoUtils = cryptoUtils;
+    __publicField(this, "cryptoUtils");
+    this.cryptoUtils = cryptoUtils;
   }
   /**
    * Generate code verifier.
@@ -520,7 +774,7 @@ var IsomorphicCrypto = class {
    * @returns code verifier.
    */
   getCodeVerifier() {
-    return this._cryptoUtils.base64URLEncode(this._cryptoUtils.generateRandomBytes(32));
+    return this.cryptoUtils.base64URLEncode(this.cryptoUtils.generateRandomBytes(32));
   }
   /**
    * Derive code challenge from the code verifier.
@@ -530,7 +784,7 @@ var IsomorphicCrypto = class {
    * @returns - code challenge.
    */
   getCodeChallenge(verifier) {
-    return this._cryptoUtils.base64URLEncode(this._cryptoUtils.hashSha256(verifier));
+    return this.cryptoUtils.base64URLEncode(this.cryptoUtils.hashSha256(verifier));
   }
   /**
    * Get JWK used for the id_token
@@ -544,16 +798,17 @@ var IsomorphicCrypto = class {
    */
   /* eslint-disable @typescript-eslint/no-explicit-any */
   getJWKForTheIdToken(jwtHeader, keys) {
-    const headerJSON = JSON.parse(this._cryptoUtils.base64URLDecode(jwtHeader));
-    for (const key of keys) {
-      if (headerJSON["kid"] === key.kid) {
-        return key;
-      }
+    const headerJSON = JSON.parse(this.cryptoUtils.base64URLDecode(jwtHeader));
+    const matchingKey = keys.find(
+      (key) => headerJSON["kid"] === key.kid
+    );
+    if (matchingKey) {
+      return matchingKey;
     }
     throw new AsgardeoAuthException(
       "JS-CRYPTO_UTIL-GJFTIT-IV01",
       "kid not found.",
-      "Failed to find the 'kid' specified in the id_token. 'kid' found in the header : " + headerJSON["kid"] + ", Expected values: " + keys.map((key) => key.kid).join(", ")
+      `Failed to find the 'kid' specified in the id_token. 'kid' found in the header : ${headerJSON["kid"]}, Expected values: ${keys.map((key) => key.kid).join(", ")}`
     );
   }
   /**
@@ -571,7 +826,7 @@ var IsomorphicCrypto = class {
    * @throws
    */
   isValidIdToken(idToken, jwk, clientId, issuer, username, clockTolerance, validateJwtIssuer) {
-    return this._cryptoUtils.verifyJwt(
+    return this.cryptoUtils.verifyJwt(
       idToken,
       jwk,
       TokenConstants_default.SignatureValidation.SUPPORTED_ALGORITHMS,
@@ -583,419 +838,178 @@ var IsomorphicCrypto = class {
     ).then((response) => {
       if (response) {
         return Promise.resolve(true);
-      }
-      return Promise.reject(
-        new AsgardeoAuthException(
-          "JS-CRYPTO_HELPER-IVIT-IV01",
-          "Invalid ID token.",
-          "ID token validation returned false"
-        )
-      );
-    }).catch((error2) => {
-      return Promise.reject(error2);
-    });
-  }
-  decodeJwtToken(token) {
-    try {
-      const utf8String = this._cryptoUtils.base64URLDecode(token?.split(".")[1]);
-      const payload = JSON.parse(utf8String);
-      return payload;
-    } catch (error2) {
-      throw new AsgardeoAuthException("JS-CRYPTO_UTIL-DIT-IV02", "Decoding token failed.", error2);
-    }
-  }
-};
-
-// 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: "#"
-    }
-  }
-};
-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/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.
-     */
-    ACCESS_TOKEN: "{{accessToken}}",
-    /**
-     * 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.
-     */
-    SCOPES: "{{scopes}}",
-    /**
-     * 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}}"
-  }
-};
-var TokenExchangeConstants_default = TokenExchangeConstants;
-
-// src/models/platforms.ts
-var Platform = /* @__PURE__ */ ((Platform2) => {
-  Platform2["Asgardeo"] = "ASGARDEO";
-  Platform2["IdentityServer"] = "IDENTITY_SERVER";
-  Platform2["AsgardeoV2"] = "AsgardeoV2";
-  Platform2["Unknown"] = "UNKNOWN";
-  return Platform2;
-})(Platform || {});
-
-// 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];
-  });
-  return filteredPayload;
-};
-var extractUserClaimsFromIdToken_default = extractUserClaimsFromIdToken;
-
-// src/errors/AsgardeoError.ts
-var AsgardeoError = class _AsgardeoError extends Error {
-  constructor(message, code, origin) {
-    const _origin = _AsgardeoError.resolveOrigin(origin);
-    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() {
-    const prefix = `\u{1F6E1}\uFE0F Asgardeo - ${this.origin}:`;
-    return `[${this.name}]
-${prefix} ${this.message}
-(code="${this.code}")`;
-  }
-};
-
-// 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/utils/processOpenIDScopes.ts
-var processOpenIDScopes = (scopes) => {
-  let processedScopes = [];
-  if (scopes) {
-    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."
-      );
-    }
-  }
-  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 () => this._storageManager.getConfigData();
-    this._oidcProviderMetaData = async () => this._storageManager.loadOpenIDProviderConfiguration();
-    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) => 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."
+      }
+      return Promise.reject(
+        new AsgardeoAuthException(
+          "JS-CRYPTO_HELPER-IVIT-IV01",
+          "Invalid ID token.",
+          "ID token validation returned false"
+        )
       );
-    }
-    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 };
+    }).catch((error2) => Promise.reject(error2));
   }
-  async resolveEndpointsByBaseURL() {
-    const oidcProviderMetaData = {};
-    const configData = await this._config();
-    const { baseUrl } = configData;
-    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}`
-    };
-    if (configData.platform === "AsgardeoV2" /* AsgardeoV2 */) {
-      defaultEndpoints[OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.ISSUER] = `${baseUrl}`;
+  decodeJwtToken(token) {
+    try {
+      const utf8String = this.cryptoUtils.base64URLDecode(token?.split(".")[1]);
+      const payload = JSON.parse(utf8String);
+      return payload;
+    } catch (error2) {
+      throw new AsgardeoAuthException("JS-CRYPTO_UTIL-DIT-IV02", "Decoding token failed.", error2);
     }
-    return { ...defaultEndpoints, ...oidcProviderMetaData };
   }
-  async validateIdToken(idToken) {
-    const jwksEndpoint = (await this._storageManager.loadOpenIDProviderConfiguration()).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;
+};
+
+// src/StorageManager.ts
+var ASGARDEO_SESSION_ACTIVE = "asgardeo-session-active";
+var StorageManager = class _StorageManager {
+  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}`;
+  }
+  static isLocalStorageAvailable() {
     try {
-      response = await fetch(jwksEndpoint, {
-        credentials: configData.sendCookiesInRequests ? "include" : "same-origin"
-      });
+      const testValue = "__ASGARDEO_AUTH_CORE_LOCAL_STORAGE_TEST__";
+      localStorage.setItem(testValue, testValue);
+      localStorage.removeItem(testValue);
+      return true;
     } catch (error2) {
-      throw new AsgardeoAuthException(
-        "JS-AUTH_HELPER-VIT-NE02",
-        "Request to jwks endpoint failed.",
-        error2 ?? "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()
-      );
+      return false;
     }
-    const { issuer } = await this._oidcProviderMetaData();
-    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.decodeJwtToken(idToken).sub,
-      (await this._config()).tokenValidation?.idToken?.clockTolerance,
-      (await this._config()).tokenValidation?.idToken?.validateIssuer ?? true
-    );
   }
-  getAuthenticatedUserInfo(idToken) {
-    const payload = this._cryptoHelper.decodeJwtToken(idToken);
-    const username = payload?.["username"] ?? "";
-    const givenName = payload?.["given_name"] ?? "";
-    const familyName = payload?.["family_name"] ?? "";
-    const fullName = givenName && familyName ? `${givenName} ${familyName}` : givenName || familyName || "";
-    const displayName = payload.preferred_username ?? fullName;
-    return {
-      displayName,
-      username,
-      ...extractUserClaimsFromIdToken_default(payload)
-    };
+  async setConfigData(config) {
+    await this.setDataInBulk(this.resolveKey("config_data" /* ConfigData */), config);
   }
-  async replaceCustomGrantTemplateTags(text, userId) {
-    const configData = await this._config();
-    const sessionData = await this._storageManager.getSessionData(userId);
-    const scope = processOpenIDScopes_default(configData.scopes);
-    if (typeof text !== "string") {
-      return text;
-    }
-    return text.replace(TokenExchangeConstants_default.Placeholders.ACCESS_TOKEN, sessionData.access_token).replace(
-      TokenExchangeConstants_default.Placeholders.USERNAME,
-      this.getAuthenticatedUserInfo(sessionData.id_token).username
-    ).replace(TokenExchangeConstants_default.Placeholders.SCOPES, scope).replace(TokenExchangeConstants_default.Placeholders.CLIENT_ID, configData.clientId).replace(TokenExchangeConstants_default.Placeholders.CLIENT_SECRET, configData.clientSecret ?? "");
+  async setOIDCProviderMetaData(oidcProviderMetaData) {
+    this.setDataInBulk(this.resolveKey("oidc_provider_meta_data" /* OIDCProviderMetaData */), oidcProviderMetaData);
   }
-  async clearSession(userId) {
-    await this._storageManager.removeTemporaryData(userId);
-    await this._storageManager.removeSessionData(userId);
+  async setTemporaryData(temporaryData, userId) {
+    this.setDataInBulk(this.resolveKey("temporary_data" /* TemporaryData */, userId), temporaryData);
   }
-  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()
-      );
+  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(userId) {
+    return JSON.parse(await this.store.getData(this.resolveKey("config_data" /* ConfigData */, userId)) ?? 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);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  setSessionStatus(status) {
+    if (_StorageManager.isLocalStorageAvailable()) {
+      localStorage.setItem(`${ASGARDEO_SESSION_ACTIVE}`, status);
     }
-    const parsedResponse = await response.json();
-    parsedResponse.created_at = (/* @__PURE__ */ new Date()).getTime();
-    const shouldValidateIdToken = (await this._config()).tokenValidation?.idToken?.validate;
-    if (shouldValidateIdToken) {
-      return this.validateIdToken(parsedResponse.id_token).then(async () => {
-        await this._storageManager.setSessionData(parsedResponse, userId);
-        const tokenResponse2 = {
-          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(tokenResponse2);
-      });
+  }
+  // eslint-disable-next-line class-methods-use-this
+  getSessionStatus() {
+    return _StorageManager.isLocalStorageAvailable() ? localStorage.getItem(`${ASGARDEO_SESSION_ACTIVE}`) ?? "" : "";
+  }
+  // eslint-disable-next-line class-methods-use-this
+  removeSessionStatus() {
+    if (_StorageManager.isLocalStorageAvailable()) {
+      localStorage.removeItem(`${ASGARDEO_SESSION_ACTIVE}`);
     }
-    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 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);
   }
 };
+var StorageManager_default = StorageManager;
+
+// src/utils/extractPkceStorageKeyFromState.ts
+var extractPkceStorageKeyFromState = (state) => {
+  const index = parseInt(state.split("request_")[1], 10);
+  return `${PKCEConstants_default.Storage.StorageKeys.CODE_VERIFIER}${PKCEConstants_default.Storage.StorageKeys.SEPARATOR}${index}`;
+};
+var extractPkceStorageKeyFromState_default = extractPkceStorageKeyFromState;
 
 // src/utils/generatePkceStorageKey.ts
 var generatePkceStorageKey = (tempStore) => {
@@ -1006,21 +1020,21 @@ var generatePkceStorageKey = (tempStore) => {
     }
   });
   const lastKey = keys.sort().pop();
-  const index = parseInt(lastKey?.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1] ?? "-1");
+  const index = parseInt(lastKey?.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1] ?? "-1", 10);
   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]);
+  const index = parseInt(pkceKey.split(PKCEConstants_default.Storage.StorageKeys.SEPARATOR)[1], 10);
   return state ? `${state}_request_${index}` : `request_${index}`;
 };
 var generateStateParamForRequestCorrelation_default = generateStateParamForRequestCorrelation;
 
 // src/utils/getAuthorizeRequestUrlParams.ts
 var getAuthorizeRequestUrlParams = (options, pkceOptions, customParams) => {
-  const { redirectUri, clientId, clientSecret, scopes, responseMode, codeChallenge, codeChallengeMethod, prompt } = options;
+  const { redirectUri, clientId, scopes, responseMode, codeChallenge, codeChallengeMethod, prompt } = options;
   const authorizeRequestParams = /* @__PURE__ */ new Map();
   authorizeRequestParams.set("response_type", "code");
   authorizeRequestParams.set("client_id", clientId);
@@ -1047,11 +1061,11 @@ var getAuthorizeRequestUrlParams = (options, pkceOptions, customParams) => {
     authorizeRequestParams.set("prompt", prompt);
   }
   if (customParams) {
-    for (const [key, value] of Object.entries(customParams)) {
+    Object.entries(customParams).forEach(([key, value]) => {
       if (key !== "" && value !== "" && key !== OIDCRequestConstants_default.Params.STATE) {
         authorizeRequestParams.set(key, value.toString());
       }
-    }
+    });
   }
   authorizeRequestParams.set(
     OIDCRequestConstants_default.Params.STATE,
@@ -1066,16 +1080,16 @@ var getAuthorizeRequestUrlParams_default = getAuthorizeRequestUrlParams;
 
 // src/__legacy__/client.ts
 var DefaultConfig = {
+  enablePKCE: true,
+  responseMode: "query",
+  sendCookiesInRequests: true,
   tokenValidation: {
     idToken: {
+      clockTolerance: 300,
       validate: true,
-      validateIssuer: true,
-      clockTolerance: 300
+      validateIssuer: true
     }
-  },
-  enablePKCE: true,
-  responseMode: "query",
-  sendCookiesInRequests: true
+  }
 };
 var _AsgardeoAuthClient = class _AsgardeoAuthClient {
   /**
@@ -1094,12 +1108,12 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   constructor() {
-    __publicField(this, "_storageManager");
-    __publicField(this, "_config");
-    __publicField(this, "_oidcProviderMetaData");
-    __publicField(this, "_authenticationHelper");
-    __publicField(this, "_cryptoUtils");
-    __publicField(this, "_cryptoHelper");
+    __publicField(this, "storageManager");
+    __publicField(this, "configProvider");
+    __publicField(this, "oidcProviderMetaDataProvider");
+    __publicField(this, "authHelper");
+    __publicField(this, "cryptoUtils");
+    __publicField(this, "cryptoHelper");
   }
   /**
    *
@@ -1120,28 +1134,28 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
-  async initialize(config, store, cryptoUtils, instanceID) {
-    const clientId = config.clientId;
-    if (!_AsgardeoAuthClient._instanceID) {
-      _AsgardeoAuthClient._instanceID = 0;
+  async initialize(config, store, inputCryptoUtils, instanceID) {
+    const { clientId } = config;
+    if (!_AsgardeoAuthClient.instanceIdValue) {
+      _AsgardeoAuthClient.instanceIdValue = 0;
     } else {
-      _AsgardeoAuthClient._instanceID += 1;
+      _AsgardeoAuthClient.instanceIdValue += 1;
     }
     if (instanceID) {
-      _AsgardeoAuthClient._instanceID = instanceID;
+      _AsgardeoAuthClient.instanceIdValue = instanceID;
     }
     if (!clientId) {
-      this._storageManager = new StorageManager_default(`instance_${_AsgardeoAuthClient._instanceID}`, store);
+      this.storageManager = new StorageManager_default(`instance_${_AsgardeoAuthClient.instanceIdValue}`, store);
     } else {
-      this._storageManager = new StorageManager_default(`instance_${_AsgardeoAuthClient._instanceID}-${clientId}`, store);
+      this.storageManager = new StorageManager_default(`instance_${_AsgardeoAuthClient.instanceIdValue}-${clientId}`, store);
     }
-    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({
+    this.cryptoUtils = inputCryptoUtils;
+    this.cryptoHelper = new IsomorphicCrypto(inputCryptoUtils);
+    this.authHelper = new AuthenticationHelper(this.storageManager, this.cryptoHelper);
+    this.configProvider = async () => this.storageManager.getConfigData();
+    this.oidcProviderMetaDataProvider = async () => this.storageManager.loadOpenIDProviderConfiguration();
+    _AsgardeoAuthClient.authHelperInstance = this.authHelper;
+    await this.storageManager.setConfigData({
       ...DefaultConfig,
       ...config,
       scope: processOpenIDScopes_default(config.scopes)
@@ -1162,7 +1176,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   getStorageManager() {
-    return this._storageManager;
+    return this.storageManager;
   }
   /**
    * This method returns the `instanceID` variable of the given instance.
@@ -1176,8 +1190,9 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    *
    * @preserve
    */
+  // eslint-disable-next-line class-methods-use-this
   getInstanceId() {
-    return _AsgardeoAuthClient._instanceID;
+    return _AsgardeoAuthClient.instanceIdValue;
   }
   /**
    * This is an async method that returns a Promise that resolves with the authorization URL.
@@ -1205,8 +1220,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
   async getSignInUrl(requestConfig, userId) {
     const authRequestConfig = { ...requestConfig };
     delete authRequestConfig?.forceInit;
-    const __TODO__ = async () => {
-      const authorizeEndpoint = await this._storageManager.getOIDCProviderMetaDataParameter(
+    const buildSignInUrl = async () => {
+      const authorizeEndpoint = await this.storageManager.getOIDCProviderMetaDataParameter(
         OIDCDiscoveryConstants_default.Storage.StorageKeys.Endpoints.AUTHORIZATION
       );
       if (!authorizeEndpoint || authorizeEndpoint.trim().length === 0) {
@@ -1217,45 +1232,43 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
         );
       }
       const authorizeRequest = new URL(authorizeEndpoint);
-      const configData = await this._config();
-      const tempStore = await this._storageManager.getTemporaryData(userId);
+      const configData = await this.configProvider();
+      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);
+        codeVerifier = this.cryptoHelper?.getCodeVerifier();
+        codeChallenge = this.cryptoHelper?.getCodeChallenge(codeVerifier);
+        await this.storageManager.setTemporaryDataParameter(pkceKey, codeVerifier, userId);
       }
       if (authRequestConfig["client_secret"]) {
         authRequestConfig["client_secret"] = configData.clientSecret;
       }
       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
+          codeChallengeMethod: PKCEConstants_default.DEFAULT_CODE_CHALLENGE_METHOD,
+          prompt: configData.prompt,
+          redirectUri: configData.afterSignInUrl,
+          responseMode: configData.responseMode,
+          scopes: processOpenIDScopes_default(configData.scopes)
         },
         { key: pkceKey },
         authRequestConfig
       );
-      for (const [key, value] of authorizeRequestParams.entries()) {
-        authorizeRequest.searchParams.append(key, value);
-      }
+      Array.from(authorizeRequestParams.entries()).forEach(([paramKey, paramValue]) => {
+        authorizeRequest.searchParams.append(paramKey, paramValue);
+      });
       return authorizeRequest.toString();
     };
-    if (await this._storageManager.getTemporaryDataParameter(
+    if (await this.storageManager.getTemporaryDataParameter(
       OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
     )) {
-      return __TODO__();
+      return buildSignInUrl();
     }
-    return this.loadOpenIDProviderConfiguration(requestConfig?.forceInit).then(() => {
-      return __TODO__();
-    });
+    return this.loadOpenIDProviderConfiguration(requestConfig?.forceInit).then(() => buildSignInUrl());
   }
   /**
    * This is an async method that sends a request to obtain the access token and returns a Promise
@@ -1283,9 +1296,9 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async requestAccessToken(authorizationCode, sessionState, state, userId, tokenRequestConfig) {
-    const __TODO__ = async () => {
-      const tokenEndpoint = (await this._oidcProviderMetaData()).token_endpoint;
-      const configData = await this._config();
+    const performTokenRequest = async () => {
+      const tokenEndpoint = (await this.oidcProviderMetaDataProvider()).token_endpoint;
+      const configData = await this.configProvider();
       if (!tokenEndpoint || tokenEndpoint.trim().length === 0) {
         throw new AsgardeoAuthException(
           "JS-AUTH_CORE-RAT1-NF01",
@@ -1293,11 +1306,13 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
           "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,
-        userId
-      );
+      if (sessionState) {
+        await this.storageManager.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) {
@@ -1315,9 +1330,9 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
       if (configData.enablePKCE) {
         body.set(
           "code_verifier",
-          `${await this._storageManager.getTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userId)}`
+          `${await this.storageManager.getTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userId)}`
         );
-        await this._storageManager.removeTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userId);
+        await this.storageManager.removeTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), userId);
       }
       let tokenResponse;
       try {
@@ -1344,25 +1359,23 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
           await tokenResponse.json()
         );
       }
-      return await this._authenticationHelper.handleTokenResponse(tokenResponse, userId);
+      return this.authHelper.handleTokenResponse(tokenResponse, userId);
     };
-    if (await this._storageManager.getTemporaryDataParameter(
+    if (await this.storageManager.getTemporaryDataParameter(
       OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
     )) {
-      return __TODO__();
+      return performTokenRequest();
     }
-    return this.loadOpenIDProviderConfiguration(false).then(() => {
-      return __TODO__();
-    });
+    return this.loadOpenIDProviderConfiguration(false).then(() => performTokenRequest());
   }
   async loadOpenIDProviderConfiguration(forceInit) {
-    const configData = await this._config();
-    if (!forceInit && await this._storageManager.getTemporaryDataParameter(
+    const configData = await this.configProvider();
+    if (!forceInit && await this.storageManager.getTemporaryDataParameter(
       OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED
     )) {
       return Promise.resolve();
     }
-    const wellKnownEndpoint = configData.wellKnownEndpoint;
+    const { wellKnownEndpoint } = configData;
     if (wellKnownEndpoint) {
       let response;
       try {
@@ -1377,19 +1390,16 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
           "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(
+      await this.storageManager.setOIDCProviderMetaData(await this.authHelper.resolveEndpoints(await response.json()));
+      await this.storageManager.setTemporaryDataParameter(
         OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
         true
       );
       return Promise.resolve();
-    } else if (configData.baseUrl) {
+    }
+    if (configData.baseUrl) {
       try {
-        await this._storageManager.setOIDCProviderMetaData(
-          await this._authenticationHelper.resolveEndpointsByBaseURL()
-        );
+        await this.storageManager.setOIDCProviderMetaData(await this.authHelper.resolveEndpointsByBaseURL());
       } catch (error2) {
         throw new AsgardeoAuthException(
           "JS-AUTH_CORE-GOPMD-IV02",
@@ -1397,19 +1407,18 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
           error2 ?? "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(
+      await this.storageManager.setTemporaryDataParameter(
         OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
         true
       );
       return Promise.resolve();
     }
+    await this.storageManager.setOIDCProviderMetaData(await this.authHelper.resolveEndpointsExplicitly());
+    await this.storageManager.setTemporaryDataParameter(
+      OIDCDiscoveryConstants_default.Storage.StorageKeys.OPENID_PROVIDER_CONFIG_INITIATED,
+      true
+    );
+    return Promise.resolve();
   }
   /**
    * This method returns the sign-out URL.
@@ -1431,8 +1440,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async getSignOutUrl(userId) {
-    const logoutEndpoint = (await this._oidcProviderMetaData())?.end_session_endpoint;
-    const configData = await this._config();
+    const logoutEndpoint = (await this.oidcProviderMetaDataProvider())?.end_session_endpoint;
+    const configData = await this.configProvider();
     if (!logoutEndpoint || logoutEndpoint.trim().length === 0) {
       throw new AsgardeoAuthException(
         "JS-AUTH_CORE-GSOU-NF01",
@@ -1451,7 +1460,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
     const queryParams = new URLSearchParams();
     queryParams.set("post_logout_redirect_uri", callbackURL);
     if (configData.sendIdTokenInLogoutRequest) {
-      const idToken = (await this._storageManager.getSessionData(userId))?.id_token;
+      const idToken = (await this.storageManager.getSessionData(userId))?.id_token;
       if (!idToken || idToken.trim().length === 0) {
         throw new AsgardeoAuthException(
           "JS-AUTH_CORE-GSOU-NF02",
@@ -1481,7 +1490,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async getOpenIDProviderEndpoints() {
-    const oidcProviderMetaData = await this._oidcProviderMetaData();
+    const oidcProviderMetaData = await this.oidcProviderMetaDataProvider();
     return {
       authorizationEndpoint: oidcProviderMetaData.authorization_endpoint ?? "",
       checkSessionIframe: oidcProviderMetaData.check_session_iframe ?? "",
@@ -1507,7 +1516,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * ```
    */
   async decodeJwtToken(token) {
-    return this._cryptoHelper.decodeJwtToken(token);
+    return this.cryptoHelper.decodeJwtToken(token);
   }
   /**
    * This method decodes the payload of the ID token and returns it.
@@ -1527,8 +1536,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async getDecodedIdToken(userId, idToken) {
-    const _idToken = (await this._storageManager.getSessionData(userId)).id_token;
-    const payload = this._cryptoHelper.decodeJwtToken(_idToken ?? idToken);
+    const storedIdToken = (await this.storageManager.getSessionData(userId)).id_token;
+    const payload = this.cryptoHelper.decodeJwtToken(storedIdToken ?? idToken);
     return payload;
   }
   /**
@@ -1549,7 +1558,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async getIdToken(userId) {
-    return (await this._storageManager.getSessionData(userId)).id_token;
+    return (await this.storageManager.getSessionData(userId)).id_token;
   }
   /**
    * This method returns the basic user information obtained from the ID token.
@@ -1569,8 +1578,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async getUser(userId) {
-    const sessionData = await this._storageManager.getSessionData(userId);
-    const authenticatedUser = this._authenticationHelper.getAuthenticatedUserInfo(sessionData?.id_token);
+    const sessionData = await this.storageManager.getSessionData(userId);
+    const authenticatedUser = this.authHelper.getAuthenticatedUserInfo(sessionData?.id_token);
     Object.keys(authenticatedUser).forEach((key) => {
       if (authenticatedUser[key] === void 0 || authenticatedUser[key] === "" || authenticatedUser[key] === null) {
         delete authenticatedUser[key];
@@ -1579,7 +1588,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
     return authenticatedUser;
   }
   async getUserSession(userId) {
-    const sessionData = await this._storageManager.getSessionData(userId);
+    const sessionData = await this.storageManager.getSessionData(userId);
     return {
       scopes: sessionData?.scope?.split(" "),
       sessionState: sessionData?.session_state ?? ""
@@ -1600,7 +1609,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async getCrypto() {
-    return this._cryptoHelper;
+    return this.cryptoHelper;
   }
   /**
    * This method revokes the access token.
@@ -1626,8 +1635,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async revokeAccessToken(userId) {
-    const revokeTokenEndpoint = (await this._oidcProviderMetaData()).revocation_endpoint;
-    const configData = await this._config();
+    const revokeTokenEndpoint = (await this.oidcProviderMetaDataProvider()).revocation_endpoint;
+    const configData = await this.configProvider();
     if (!revokeTokenEndpoint || revokeTokenEndpoint.trim().length === 0) {
       throw new AsgardeoAuthException(
         "JS-AUTH_CORE-RAT3-NF01",
@@ -1637,7 +1646,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
     }
     const body = [];
     body.push(`client_id=${configData.clientId}`);
-    body.push(`token=${(await this._storageManager.getSessionData(userId)).access_token}`);
+    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}`);
@@ -1667,7 +1676,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
         await response.json()
       );
     }
-    this._authenticationHelper.clearSession(userId);
+    this.authHelper.clearSession(userId);
     return Promise.resolve(response);
   }
   /**
@@ -1693,9 +1702,9 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async refreshAccessToken(userId) {
-    const tokenEndpoint = (await this._oidcProviderMetaData()).token_endpoint;
-    const configData = await this._config();
-    const sessionData = await this._storageManager.getSessionData(userId);
+    const tokenEndpoint = (await this.oidcProviderMetaDataProvider()).token_endpoint;
+    const configData = await this.configProvider();
+    const sessionData = await this.storageManager.getSessionData(userId);
     if (!sessionData.refresh_token) {
       throw new AsgardeoAuthException(
         "JS-AUTH_CORE-RAT2-NF01",
@@ -1742,7 +1751,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
         await tokenResponse.json()
       );
     }
-    return this._authenticationHelper.handleTokenResponse(tokenResponse, userId);
+    return this.authHelper.handleTokenResponse(tokenResponse, userId);
   }
   /**
    * This method returns the access token.
@@ -1762,7 +1771,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async getAccessToken(userId) {
-    return (await this._storageManager.getSessionData(userId))?.access_token;
+    return (await this.storageManager.getSessionData(userId))?.access_token;
   }
   /**
    * This method sends a custom-grant request and returns a Promise that resolves with the response
@@ -1803,8 +1812,8 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async exchangeToken(config, userId) {
-    const oidcProviderMetadata = await this._oidcProviderMetaData();
-    const configData = await this._config();
+    const oidcProviderMetadata = await this.oidcProviderMetaDataProvider();
+    const configData = await this.configProvider();
     let tokenEndpoint;
     if (config.tokenEndpoint && config.tokenEndpoint.trim().length !== 0) {
       tokenEndpoint = config.tokenEndpoint;
@@ -1820,10 +1829,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
     }
     const data = await Promise.all(
       Object.entries(config.data).map(async ([key, value]) => {
-        const newValue = await this._authenticationHelper.replaceCustomGrantTemplateTags(
-          value,
-          userId
-        );
+        const newValue = await this.authHelper.replaceCustomGrantTemplateTags(value, userId);
         return `${key}=${newValue}`;
       })
     );
@@ -1834,7 +1840,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
     if (config.attachToken) {
       requestHeaders = {
         ...requestHeaders,
-        Authorization: `Bearer ${(await this._storageManager.getSessionData(userId)).access_token}`
+        Authorization: `Bearer ${(await this.storageManager.getSessionData(userId)).access_token}`
       };
     }
     const requestConfig = {
@@ -1861,10 +1867,9 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
       );
     }
     if (config.returnsSession) {
-      return this._authenticationHelper.handleTokenResponse(response, userId);
-    } else {
-      return Promise.resolve(await response.json());
+      return this.authHelper.handleTokenResponse(response, userId);
     }
+    return Promise.resolve(await response.json());
   }
   /**
    * This method returns if the user is authenticated or not.
@@ -1885,12 +1890,12 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    */
   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;
+    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 expiresIn = parseInt(expiresInString, 10) * 1e3;
     const currentTime = (/* @__PURE__ */ new Date()).getTime();
     const isAccessTokenValid = createdAt + expiresIn > currentTime;
     const isSignedIn = isAccessTokenAvailable && isAccessTokenValid;
@@ -1915,7 +1920,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async getPKCECode(state, userId) {
-    return await this._storageManager.getTemporaryDataParameter(
+    return await this.storageManager.getTemporaryDataParameter(
       extractPkceStorageKeyFromState_default(state),
       userId
     );
@@ -1938,7 +1943,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async setPKCECode(pkce, state, userId) {
-    return await this._storageManager.setTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), pkce, userId);
+    return this.storageManager.setTemporaryDataParameter(extractPkceStorageKeyFromState_default(state), pkce, userId);
   }
   /**
    * This method returns if the sign-out is successful or not.
@@ -2000,17 +2005,17 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async reInitialize(config) {
-    await this._storageManager.setConfigData(config);
+    await this.storageManager.setConfigData(config);
     await this.loadOpenIDProviderConfiguration(true);
   }
   static async clearSession(userId) {
-    await this._authenticationHelper.clearSession(userId);
+    await this.authHelperInstance.clearSession(userId);
   }
 };
-__publicField(_AsgardeoAuthClient, "_instanceID");
+__publicField(_AsgardeoAuthClient, "instanceIdValue");
 // FIXME: Validate this.
 // Ref: https://github.com/asgardeo/asgardeo-auth-js-core/pull/205
-__publicField(_AsgardeoAuthClient, "_authenticationHelper");
+__publicField(_AsgardeoAuthClient, "authHelperInstance");
 var AsgardeoAuthClient = _AsgardeoAuthClient;
 
 // src/errors/AsgardeoAPIError.ts
@@ -2030,8 +2035,8 @@ var AsgardeoAPIError = class extends AsgardeoError {
     this.statusCode = statusCode;
     this.statusText = statusText;
     Object.defineProperty(this, "name", {
-      value: "AsgardeoAPIError",
       configurable: true,
+      value: "AsgardeoAPIError",
       writable: true
     });
   }
@@ -2082,13 +2087,13 @@ var initializeEmbeddedSignInFlow = async ({
   try {
     const response = await fetch(url ?? `${baseUrl}/oauth2/authorize`, {
       ...requestConfig,
-      method: requestConfig.method || "POST",
+      body: searchParams.toString(),
       headers: {
         ...requestConfig.headers,
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json"
+        Accept: "application/json",
+        "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: searchParams.toString()
+      method: requestConfig.method || "POST"
     });
     if (!response.ok) {
       const errorText = await response.text();
@@ -2146,13 +2151,13 @@ var executeEmbeddedSignInFlow = async ({
   try {
     const response = await fetch(url ?? `${baseUrl}/oauth2/authn`, {
       ...requestConfig,
-      method: requestConfig.method || "POST",
+      body: JSON.stringify(payload),
       headers: {
-        "Content-Type": "application/json",
         Accept: "application/json",
+        "Content-Type": "application/json",
         ...requestConfig.headers
       },
-      body: JSON.stringify(payload)
+      method: requestConfig.method || "POST"
     });
     if (!response.ok) {
       const errorText = await response.text();
@@ -2240,16 +2245,16 @@ var executeEmbeddedSignUpFlow = async ({
   try {
     const response = await fetch(url ?? `${baseUrl}/api/server/v1/flow/execute`, {
       ...requestConfig,
-      method: requestConfig.method || "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        ...requestConfig.headers
-      },
       body: JSON.stringify({
         ...payload ?? {},
         flowType: "REGISTRATION" /* Registration */
-      })
+      }),
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...requestConfig.headers
+      },
+      method: requestConfig.method || "POST"
     });
     if (!response.ok) {
       const errorText = await response.text();
@@ -2293,12 +2298,12 @@ var getUserInfo = async ({ url, ...requestConfig }) => {
   try {
     const response = await fetch(url, {
       ...requestConfig,
-      method: "GET",
       headers: {
-        "Content-Type": "application/json",
         Accept: "application/json",
+        "Content-Type": "application/json",
         ...requestConfig.headers
-      }
+      },
+      method: "GET"
     });
     if (!response.ok) {
       const errorText = await response.text();
@@ -2369,12 +2374,12 @@ var getScim2Me = async ({ url, baseUrl, fetcher, ...requestConfig }) => {
   const resolvedUrl = url ?? `${baseUrl}/scim2/Me`;
   const requestInit = {
     ...requestConfig,
-    method: "GET",
     headers: {
-      "Content-Type": "application/scim+json",
       Accept: "application/json",
+      "Content-Type": "application/scim+json",
       ...requestConfig.headers
-    }
+    },
+    method: "GET"
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2422,12 +2427,12 @@ var getSchemas = async ({ url, baseUrl, fetcher, ...requestConfig }) => {
   const resolvedUrl = url ?? `${baseUrl}/scim2/Schemas`;
   const requestInit = {
     ...requestConfig,
-    method: "GET",
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
-    }
+    },
+    method: "GET"
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2490,12 +2495,12 @@ var getAllOrganizations = async ({
   const resolvedUrl = `${baseUrl}/api/server/v1/organizations?${queryParams.toString()}`;
   const requestInit = {
     ...requestConfig,
-    method: "GET",
     headers: {
       ...requestConfig.headers,
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    }
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    method: "GET"
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2566,13 +2571,13 @@ var createOrganization = async ({
   const resolvedUrl = `${baseUrl}/api/server/v1/organizations`;
   const requestInit = {
     ...requestConfig,
-    method: "POST",
+    body: JSON.stringify(organizationPayload),
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
     },
-    body: JSON.stringify(organizationPayload)
+    method: "POST"
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2641,12 +2646,12 @@ var getMeOrganizations = async ({
   const resolvedUrl = `${baseUrl}/api/users/v1/me/organizations?${queryParams.toString()}`;
   const requestInit = {
     ...requestConfig,
-    method: "GET",
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
-    }
+    },
+    method: "GET"
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2661,7 +2666,7 @@ var getMeOrganizations = async ({
       );
     }
     const data = await response.json();
-    return data.organizations || [];
+    return data["organizations"] || [];
   } catch (error2) {
     if (error2 instanceof AsgardeoAPIError) {
       throw error2;
@@ -2708,12 +2713,12 @@ var getOrganization = async ({
   const resolvedUrl = `${baseUrl}/api/server/v1/organizations/${organizationId}`;
   const requestInit = {
     ...requestConfig,
-    method: "GET",
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
-    }
+    },
+    method: "GET"
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2802,13 +2807,13 @@ var updateOrganization = async ({
   const resolvedUrl = `${baseUrl}/api/server/v1/organizations/${organizationId}`;
   const requestInit = {
     ...requestConfig,
-    method: "PATCH",
+    body: JSON.stringify(operations),
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
     },
-    body: JSON.stringify(operations)
+    method: "PATCH"
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2836,21 +2841,19 @@ var updateOrganization = async ({
     );
   }
 };
-var createPatchOperations = (payload) => {
-  return Object.entries(payload).map(([key, value]) => {
-    if (isEmpty_default(value)) {
-      return {
-        operation: "REMOVE",
-        path: `/${key}`
-      };
-    }
+var createPatchOperations = (payload) => Object.entries(payload).map(([key, value]) => {
+  if (isEmpty_default(value)) {
     return {
-      operation: "REPLACE",
-      path: `/${key}`,
-      value
+      operation: "REMOVE",
+      path: `/${key}`
     };
-  });
-};
+  }
+  return {
+    operation: "REPLACE",
+    path: `/${key}`,
+    value
+  };
+});
 var updateOrganization_default = updateOrganization;
 
 // src/api/updateMeProfile.ts
@@ -2886,12 +2889,12 @@ var updateMeProfile = async ({
   const requestInit = {
     method: "PATCH",
     ...requestConfig,
+    body: JSON.stringify(data),
     headers: {
       ...requestConfig.headers,
-      "Content-Type": "application/scim+json",
-      Accept: "application/json"
-    },
-    body: JSON.stringify(data)
+      Accept: "application/json",
+      "Content-Type": "application/scim+json"
+    }
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2954,12 +2957,12 @@ var getBrandingPreference = async ({
   const resolvedUrl = `${baseUrl}/api/server/v1/branding-preference/resolve${queryParams.toString() ? `?${queryParams.toString()}` : ""}`;
   const requestInit = {
     ...requestConfig,
-    method: "GET",
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
-    }
+    },
+    method: "GET"
   };
   try {
     const response = await fetchFn(resolvedUrl, requestInit);
@@ -2993,8 +2996,8 @@ var getBrandingPreference_default = getBrandingPreference;
 // src/models/v2/embedded-signin-flow-v2.ts
 var EmbeddedSignInFlowStatus = /* @__PURE__ */ ((EmbeddedSignInFlowStatus3) => {
   EmbeddedSignInFlowStatus3["Complete"] = "COMPLETE";
-  EmbeddedSignInFlowStatus3["Incomplete"] = "INCOMPLETE";
   EmbeddedSignInFlowStatus3["Error"] = "ERROR";
+  EmbeddedSignInFlowStatus3["Incomplete"] = "INCOMPLETE";
   return EmbeddedSignInFlowStatus3;
 })(EmbeddedSignInFlowStatus || {});
 var EmbeddedSignInFlowType = /* @__PURE__ */ ((EmbeddedSignInFlowType3) => {
@@ -3020,20 +3023,20 @@ var executeEmbeddedSignInFlowV2 = async ({
       "If an authorization payload is not provided, the request cannot be constructed correctly."
     );
   }
-  let endpoint = url ?? `${baseUrl}/flow/execute`;
+  const endpoint = url ?? `${baseUrl}/flow/execute`;
   const cleanPayload = typeof payload === "object" && payload !== null ? Object.fromEntries(Object.entries(payload).filter(([key]) => key !== "verbose")) : payload;
   const hasOnlyAppIdAndFlowType = typeof cleanPayload === "object" && cleanPayload !== null && "applicationId" in cleanPayload && "flowType" in cleanPayload && Object.keys(cleanPayload).length === 2;
   const hasOnlyFlowId = typeof cleanPayload === "object" && cleanPayload !== null && "flowId" in cleanPayload && Object.keys(cleanPayload).length === 1;
   const requestPayload = hasOnlyAppIdAndFlowType || hasOnlyFlowId ? { ...cleanPayload, verbose: true } : cleanPayload;
   const response = await fetch(endpoint, {
     ...requestConfig,
-    method: requestConfig.method || "POST",
+    body: JSON.stringify(requestPayload),
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
     },
-    body: JSON.stringify(requestPayload)
+    method: requestConfig.method || "POST"
   });
   if (!response.ok) {
     const errorText = await response.text();
@@ -3049,17 +3052,17 @@ var executeEmbeddedSignInFlowV2 = async ({
   if (flowResponse.flowStatus === "COMPLETE" /* Complete */ && flowResponse.assertion && authId) {
     try {
       const oauth2Response = await fetch(`${baseUrl}/oauth2/auth/callback`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          ...requestConfig.headers
-        },
         body: JSON.stringify({
           assertion: flowResponse.assertion,
           authId
         }),
-        credentials: "include"
+        credentials: "include",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          ...requestConfig.headers
+        },
+        method: "POST"
       });
       if (!oauth2Response.ok) {
         const oauth2ErrorText = await oauth2Response.text();
@@ -3074,7 +3077,7 @@ var executeEmbeddedSignInFlowV2 = async ({
       const oauth2Result = await oauth2Response.json();
       return {
         flowStatus: flowResponse.flowStatus,
-        redirectUrl: oauth2Result.redirect_uri
+        redirectUrl: oauth2Result["redirect_uri"]
       };
     } catch (authError) {
       throw new AsgardeoAPIError(
@@ -3093,8 +3096,8 @@ var executeEmbeddedSignInFlowV2_default = executeEmbeddedSignInFlowV2;
 // src/models/v2/embedded-signup-flow-v2.ts
 var EmbeddedSignUpFlowStatus = /* @__PURE__ */ ((EmbeddedSignUpFlowStatus2) => {
   EmbeddedSignUpFlowStatus2["Complete"] = "COMPLETE";
-  EmbeddedSignUpFlowStatus2["Incomplete"] = "INCOMPLETE";
   EmbeddedSignUpFlowStatus2["Error"] = "ERROR";
+  EmbeddedSignUpFlowStatus2["Incomplete"] = "INCOMPLETE";
   return EmbeddedSignUpFlowStatus2;
 })(EmbeddedSignUpFlowStatus || {});
 var EmbeddedSignUpFlowType = /* @__PURE__ */ ((EmbeddedSignUpFlowType2) => {
@@ -3120,20 +3123,20 @@ var executeEmbeddedSignUpFlowV2 = async ({
       "If a registration payload is not provided, the request cannot be constructed correctly."
     );
   }
-  let endpoint = url ?? `${baseUrl}/flow/execute`;
+  const endpoint = url ?? `${baseUrl}/flow/execute`;
   const cleanPayload = typeof payload === "object" && payload !== null ? Object.fromEntries(Object.entries(payload).filter(([key]) => key !== "verbose")) : payload;
   const hasOnlyAppIdAndFlowType = typeof cleanPayload === "object" && cleanPayload !== null && "applicationId" in cleanPayload && "flowType" in cleanPayload && Object.keys(cleanPayload).length === 2;
   const hasOnlyFlowId = typeof cleanPayload === "object" && cleanPayload !== null && "flowId" in cleanPayload && Object.keys(cleanPayload).length === 1;
   const requestPayload = hasOnlyAppIdAndFlowType || hasOnlyFlowId ? { ...cleanPayload, verbose: true } : cleanPayload;
   const response = await fetch(endpoint, {
     ...requestConfig,
-    method: requestConfig.method || "POST",
+    body: JSON.stringify(requestPayload),
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
     },
-    body: JSON.stringify(requestPayload)
+    method: requestConfig.method || "POST"
   });
   if (!response.ok) {
     const errorText = await response.text();
@@ -3149,17 +3152,17 @@ var executeEmbeddedSignUpFlowV2 = async ({
   if (flowResponse.flowStatus === "COMPLETE" /* Complete */ && flowResponse.assertion && authId) {
     try {
       const oauth2Response = await fetch(`${baseUrl}/oauth2/auth/callback`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          ...requestConfig.headers
-        },
         body: JSON.stringify({
           assertion: flowResponse.assertion,
           authId
         }),
-        credentials: "include"
+        credentials: "include",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          ...requestConfig.headers
+        },
+        method: "POST"
       });
       if (!oauth2Response.ok) {
         const oauth2ErrorText = await oauth2Response.text();
@@ -3174,7 +3177,7 @@ var executeEmbeddedSignUpFlowV2 = async ({
       const oauth2Result = await oauth2Response.json();
       return {
         flowStatus: flowResponse.flowStatus,
-        redirectUrl: oauth2Result.redirect_uri
+        redirectUrl: oauth2Result["redirect_uri"]
       };
     } catch (authError) {
       throw new AsgardeoAPIError(
@@ -3217,13 +3220,13 @@ var executeEmbeddedUserOnboardingFlowV2 = async ({
   }
   const response = await fetch(endpoint, {
     ...requestConfig,
-    method: requestConfig.method || "POST",
+    body: JSON.stringify(requestPayload),
     headers: {
-      "Content-Type": "application/json",
       Accept: "application/json",
+      "Content-Type": "application/json",
       ...requestConfig.headers
     },
-    body: JSON.stringify(requestPayload)
+    method: requestConfig.method || "POST"
   });
   if (!response.ok) {
     const errorText = await response.text();
@@ -3243,20 +3246,20 @@ var executeEmbeddedUserOnboardingFlowV2_default = executeEmbeddedUserOnboardingF
 // 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",
+    GitHub: "R2l0aHViQXV0aGVudGljYXRvcjpHaXRIdWI",
+    Google: "R29vZ2xlT0lEQ0F1dGhlbnRpY2F0b3I6R29vZ2xl",
+    IdentifierFirst: "SWRlbnRpZmllckV4ZWN1dG9yOkxPQ0FM",
     LinkedIn: "TGlua2VkSW5PSURDOkxpbmtlZElu",
-    SignInWithEthereum: "T3BlbklEQ29ubmVjdEF1dGhlbnRpY2F0b3I6U2lnbiBJbiBXaXRoIEV0aGVyZXVt"
+    MagicLink: "TWFnaWNMaW5rQXV0aGVudGljYXRvcjpMT0NBTA",
+    Microsoft: "T3BlbklEQ29ubmVjdEF1dGhlbnRpY2F0b3I6TWljcm9zb2Z0",
+    Passkey: "RklET0F1dGhlbnRpY2F0b3I6TE9DQUw",
+    PushNotification: "cHVzaC1ub3RpZmljYXRpb24tYXV0aGVudGljYXRvcjpMT0NBTA",
+    SignInWithEthereum: "T3BlbklEQ29ubmVjdEF1dGhlbnRpY2F0b3I6U2lnbiBJbiBXaXRoIEV0aGVyZXVt",
+    SmsOtp: "c21zLW90cC1hdXRoZW50aWNhdG9yOkxPQ0FM",
+    Totp: "dG90cDpMT0NBTA",
+    UsernamePassword: "QmFzaWNBdXRoZW50aWNhdG9yOkxPQ0FM"
   }
 };
 var ApplicationNativeAuthenticationConstants_default = ApplicationNativeAuthenticationConstants;
@@ -3306,53 +3309,53 @@ var EmbeddedSignInFlowAuthenticatorPromptType = /* @__PURE__ */ ((EmbeddedSignIn
 
 // src/models/v2/embedded-flow-v2.ts
 var EmbeddedFlowComponentType2 = /* @__PURE__ */ ((EmbeddedFlowComponentType3) => {
-  EmbeddedFlowComponentType3["TextInput"] = "TEXT_INPUT";
-  EmbeddedFlowComponentType3["PasswordInput"] = "PASSWORD_INPUT";
-  EmbeddedFlowComponentType3["EmailInput"] = "EMAIL_INPUT";
-  EmbeddedFlowComponentType3["OtpInput"] = "OTP_INPUT";
-  EmbeddedFlowComponentType3["PhoneInput"] = "PHONE_INPUT";
-  EmbeddedFlowComponentType3["Text"] = "TEXT";
   EmbeddedFlowComponentType3["Action"] = "ACTION";
   EmbeddedFlowComponentType3["Block"] = "BLOCK";
   EmbeddedFlowComponentType3["Divider"] = "DIVIDER";
+  EmbeddedFlowComponentType3["EmailInput"] = "EMAIL_INPUT";
+  EmbeddedFlowComponentType3["OtpInput"] = "OTP_INPUT";
+  EmbeddedFlowComponentType3["PasswordInput"] = "PASSWORD_INPUT";
+  EmbeddedFlowComponentType3["PhoneInput"] = "PHONE_INPUT";
   EmbeddedFlowComponentType3["Select"] = "SELECT";
+  EmbeddedFlowComponentType3["Text"] = "TEXT";
+  EmbeddedFlowComponentType3["TextInput"] = "TEXT_INPUT";
   return EmbeddedFlowComponentType3;
 })(EmbeddedFlowComponentType2 || {});
 var EmbeddedFlowActionVariant = /* @__PURE__ */ ((EmbeddedFlowActionVariant2) => {
-  EmbeddedFlowActionVariant2["Primary"] = "PRIMARY";
-  EmbeddedFlowActionVariant2["Secondary"] = "SECONDARY";
-  EmbeddedFlowActionVariant2["Tertiary"] = "TERTIARY";
   EmbeddedFlowActionVariant2["Danger"] = "DANGER";
-  EmbeddedFlowActionVariant2["Success"] = "SUCCESS";
   EmbeddedFlowActionVariant2["Info"] = "INFO";
-  EmbeddedFlowActionVariant2["Warning"] = "WARNING";
   EmbeddedFlowActionVariant2["Link"] = "LINK";
+  EmbeddedFlowActionVariant2["Primary"] = "PRIMARY";
+  EmbeddedFlowActionVariant2["Secondary"] = "SECONDARY";
   EmbeddedFlowActionVariant2["Social"] = "SOCIAL";
+  EmbeddedFlowActionVariant2["Success"] = "SUCCESS";
+  EmbeddedFlowActionVariant2["Tertiary"] = "TERTIARY";
+  EmbeddedFlowActionVariant2["Warning"] = "WARNING";
   return EmbeddedFlowActionVariant2;
 })(EmbeddedFlowActionVariant || {});
 var EmbeddedFlowTextVariant = /* @__PURE__ */ ((EmbeddedFlowTextVariant2) => {
+  EmbeddedFlowTextVariant2["Body1"] = "BODY_1";
+  EmbeddedFlowTextVariant2["Body2"] = "BODY_2";
+  EmbeddedFlowTextVariant2["ButtonText"] = "BUTTON_TEXT";
+  EmbeddedFlowTextVariant2["Caption"] = "CAPTION";
   EmbeddedFlowTextVariant2["Heading1"] = "HEADING_1";
   EmbeddedFlowTextVariant2["Heading2"] = "HEADING_2";
   EmbeddedFlowTextVariant2["Heading3"] = "HEADING_3";
   EmbeddedFlowTextVariant2["Heading4"] = "HEADING_4";
   EmbeddedFlowTextVariant2["Heading5"] = "HEADING_5";
   EmbeddedFlowTextVariant2["Heading6"] = "HEADING_6";
+  EmbeddedFlowTextVariant2["Overline"] = "OVERLINE";
   EmbeddedFlowTextVariant2["Subtitle1"] = "SUBTITLE_1";
   EmbeddedFlowTextVariant2["Subtitle2"] = "SUBTITLE_2";
-  EmbeddedFlowTextVariant2["Body1"] = "BODY_1";
-  EmbeddedFlowTextVariant2["Body2"] = "BODY_2";
-  EmbeddedFlowTextVariant2["Caption"] = "CAPTION";
-  EmbeddedFlowTextVariant2["Overline"] = "OVERLINE";
-  EmbeddedFlowTextVariant2["ButtonText"] = "BUTTON_TEXT";
   return EmbeddedFlowTextVariant2;
 })(EmbeddedFlowTextVariant || {});
 var EmbeddedFlowEventType = /* @__PURE__ */ ((EmbeddedFlowEventType2) => {
-  EmbeddedFlowEventType2["Trigger"] = "TRIGGER";
-  EmbeddedFlowEventType2["Submit"] = "SUBMIT";
-  EmbeddedFlowEventType2["Navigate"] = "NAVIGATE";
+  EmbeddedFlowEventType2["Back"] = "BACK";
   EmbeddedFlowEventType2["Cancel"] = "CANCEL";
+  EmbeddedFlowEventType2["Navigate"] = "NAVIGATE";
   EmbeddedFlowEventType2["Reset"] = "RESET";
-  EmbeddedFlowEventType2["Back"] = "BACK";
+  EmbeddedFlowEventType2["Submit"] = "SUBMIT";
+  EmbeddedFlowEventType2["Trigger"] = "TRIGGER";
   return EmbeddedFlowEventType2;
 })(EmbeddedFlowEventType || {});
 
@@ -3366,26 +3369,26 @@ var FlowMode = /* @__PURE__ */ ((FlowMode2) => {
 // src/models/scim2-schema.ts
 var WellKnownSchemaIds = /* @__PURE__ */ ((WellKnownSchemaIds2) => {
   WellKnownSchemaIds2["Core"] = "urn:ietf:params:scim:schemas:core:2.0";
-  WellKnownSchemaIds2["User"] = "urn:ietf:params:scim:schemas:core:2.0:User";
+  WellKnownSchemaIds2["CustomUser"] = "urn:scim:schemas:extension:custom:User";
   WellKnownSchemaIds2["EnterpriseUser"] = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User";
   WellKnownSchemaIds2["SystemUser"] = "urn:scim:wso2:schema";
-  WellKnownSchemaIds2["CustomUser"] = "urn:scim:schemas:extension:custom:User";
+  WellKnownSchemaIds2["User"] = "urn:ietf:params:scim:schemas:core:2.0:User";
   return WellKnownSchemaIds2;
 })(WellKnownSchemaIds || {});
 
 // src/models/field.ts
 var FieldType = /* @__PURE__ */ ((FieldType2) => {
-  FieldType2["Text"] = "TEXT";
-  FieldType2["Password"] = "PASSWORD";
+  FieldType2["Checkbox"] = "CHECKBOX";
+  FieldType2["Date"] = "DATE";
   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["Password"] = "PASSWORD";
+  FieldType2["Radio"] = "RADIO";
+  FieldType2["Select"] = "SELECT";
+  FieldType2["Text"] = "TEXT";
   FieldType2["Textarea"] = "TEXTAREA";
+  FieldType2["Time"] = "TIME";
   return FieldType2;
 })(FieldType || {});
 
@@ -3396,221 +3399,221 @@ var AsgardeoJavaScriptClient_default = AsgardeoJavaScriptClient;
 
 // src/theme/createTheme.ts
 var lightTheme = {
+  borderRadius: {
+    large: "16px",
+    medium: "8px",
+    small: "4px"
+  },
   colors: {
     action: {
+      activatedOpacity: 0.12,
       active: "rgba(0, 0, 0, 0.54)",
-      hover: "rgba(0, 0, 0, 0.04)",
-      hoverOpacity: 0.04,
-      selected: "rgba(0, 0, 0, 0.08)",
-      selectedOpacity: 0.08,
       disabled: "rgba(0, 0, 0, 0.26)",
       disabledBackground: "rgba(0, 0, 0, 0.12)",
       disabledOpacity: 0.38,
       focus: "rgba(0, 0, 0, 0.12)",
       focusOpacity: 0.12,
-      activatedOpacity: 0.12
-    },
-    primary: {
-      main: "#1a73e8",
-      contrastText: "#ffffff",
-      dark: "#174ea6"
-    },
-    secondary: {
-      main: "#424242",
-      contrastText: "#ffffff",
-      dark: "#212121"
+      hover: "rgba(0, 0, 0, 0.04)",
+      hoverOpacity: 0.04,
+      selected: "rgba(0, 0, 0, 0.08)",
+      selectedOpacity: 0.08
     },
     background: {
-      surface: "#ffffff",
-      disabled: "#f0f0f0",
-      dark: "#212121",
       body: {
-        main: "#1a1a1a",
-        dark: "#212121"
-      }
+        dark: "#212121",
+        main: "#1a1a1a"
+      },
+      dark: "#212121",
+      disabled: "#f0f0f0",
+      surface: "#ffffff"
     },
+    border: "#e0e0e0",
     error: {
-      main: "#d32f2f",
       contrastText: "#d52828",
-      dark: "#b71c1c"
+      dark: "#b71c1c",
+      main: "#d32f2f"
     },
     info: {
-      main: "#bbebff",
       contrastText: "#43aeda",
-      dark: "#01579b"
+      dark: "#01579b",
+      main: "#bbebff"
+    },
+    primary: {
+      contrastText: "#ffffff",
+      dark: "#174ea6",
+      main: "#1a73e8"
+    },
+    secondary: {
+      contrastText: "#ffffff",
+      dark: "#212121",
+      main: "#424242"
     },
     success: {
-      main: "#4caf50",
       contrastText: "#00a807",
-      dark: "#388e3c"
-    },
-    warning: {
-      main: "#ff9800",
-      contrastText: "#be7100",
-      dark: "#f57c00"
+      dark: "#388e3c",
+      main: "#4caf50"
     },
     text: {
+      dark: "#212121",
       primary: "#1a1a1a",
-      secondary: "#666666",
-      dark: "#212121"
+      secondary: "#666666"
     },
-    border: "#e0e0e0"
-  },
-  spacing: {
-    unit: 8
+    warning: {
+      contrastText: "#be7100",
+      dark: "#f57c00",
+      main: "#ff9800"
+    }
   },
-  borderRadius: {
-    small: "4px",
-    medium: "8px",
-    large: "16px"
+  images: {
+    favicon: {},
+    logo: {}
   },
   shadows: {
-    small: "0 2px 8px rgba(0, 0, 0, 0.1)",
+    large: "0 8px 32px rgba(0, 0, 0, 0.2)",
     medium: "0 4px 16px rgba(0, 0, 0, 0.15)",
-    large: "0 8px 32px rgba(0, 0, 0, 0.2)"
+    small: "0 2px 8px rgba(0, 0, 0, 0.1)"
+  },
+  spacing: {
+    unit: 8
   },
   typography: {
     fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
     fontSizes: {
-      xs: "0.75rem",
-      // 12px
-      sm: "0.875rem",
-      // 14px
-      md: "1rem",
-      // 16px
+      "2xl": "1.5rem",
+      // 24px
+      "3xl": "2.125rem",
+      // 34px
       lg: "1.125rem",
       // 18px
+      md: "1rem",
+      // 16px
+      sm: "0.875rem",
+      // 14px
       xl: "1.25rem",
       // 20px
-      "2xl": "1.5rem",
-      // 24px
-      "3xl": "2.125rem"
-      // 34px
+      xs: "0.75rem"
+      // 12px
     },
     fontWeights: {
-      normal: 400,
+      bold: 700,
       medium: 500,
-      semibold: 600,
-      bold: 700
+      normal: 400,
+      semibold: 600
     },
     lineHeights: {
-      tight: 1.2,
       normal: 1.4,
-      relaxed: 1.6
+      relaxed: 1.6,
+      tight: 1.2
     }
-  },
-  images: {
-    favicon: {},
-    logo: {}
   }
 };
 var darkTheme = {
+  borderRadius: {
+    large: "16px",
+    medium: "8px",
+    small: "4px"
+  },
   colors: {
     action: {
+      activatedOpacity: 0.12,
       active: "#1c1c1c",
-      hover: "#1c1c1c",
-      hoverOpacity: 0.04,
-      selected: "#1c1c1c",
-      selectedOpacity: 0.08,
       disabled: "rgba(255, 255, 255, 0.26)",
       disabledBackground: "rgba(255, 255, 255, 0.12)",
       disabledOpacity: 0.38,
       focus: "#1c1c1c",
       focusOpacity: 0.12,
-      activatedOpacity: 0.12
-    },
-    primary: {
-      main: "#1a73e8",
-      contrastText: "#ffffff",
-      dark: "#174ea6"
-    },
-    secondary: {
-      main: "#8b8b8b",
-      contrastText: "#ffffff",
-      dark: "#212121"
+      hover: "#1c1c1c",
+      hoverOpacity: 0.04,
+      selected: "#1c1c1c",
+      selectedOpacity: 0.08
     },
     background: {
-      surface: "#121212",
-      disabled: "#1f1f1f",
-      dark: "#212121",
       body: {
-        main: "#ffffff",
-        dark: "#212121"
-      }
+        dark: "#212121",
+        main: "#ffffff"
+      },
+      dark: "#212121",
+      disabled: "#1f1f1f",
+      surface: "#121212"
     },
+    border: "#404040",
     error: {
-      main: "#d32f2f",
       contrastText: "#d52828",
-      dark: "#b71c1c"
+      dark: "#b71c1c",
+      main: "#d32f2f"
     },
     info: {
-      main: "#bbebff",
       contrastText: "#43aeda",
-      dark: "#01579b"
+      dark: "#01579b",
+      main: "#bbebff"
+    },
+    primary: {
+      contrastText: "#ffffff",
+      dark: "#174ea6",
+      main: "#1a73e8"
+    },
+    secondary: {
+      contrastText: "#ffffff",
+      dark: "#212121",
+      main: "#8b8b8b"
     },
     success: {
-      main: "#4caf50",
       contrastText: "#00a807",
-      dark: "#388e3c"
-    },
-    warning: {
-      main: "#ff9800",
-      contrastText: "#be7100",
-      dark: "#f57c00"
+      dark: "#388e3c",
+      main: "#4caf50"
     },
     text: {
+      dark: "#212121",
       primary: "#ffffff",
-      secondary: "#b3b3b3",
-      dark: "#212121"
+      secondary: "#b3b3b3"
     },
-    border: "#404040"
-  },
-  spacing: {
-    unit: 8
+    warning: {
+      contrastText: "#be7100",
+      dark: "#f57c00",
+      main: "#ff9800"
+    }
   },
-  borderRadius: {
-    small: "4px",
-    medium: "8px",
-    large: "16px"
+  images: {
+    favicon: {},
+    logo: {}
   },
   shadows: {
-    small: "0 2px 8px rgba(0, 0, 0, 0.3)",
+    large: "0 8px 32px rgba(0, 0, 0, 0.5)",
     medium: "0 4px 16px rgba(0, 0, 0, 0.4)",
-    large: "0 8px 32px rgba(0, 0, 0, 0.5)"
+    small: "0 2px 8px rgba(0, 0, 0, 0.3)"
+  },
+  spacing: {
+    unit: 8
   },
   typography: {
     fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
     fontSizes: {
-      xs: "0.75rem",
-      // 12px
-      sm: "0.875rem",
-      // 14px
-      md: "1rem",
-      // 16px
+      "2xl": "1.5rem",
+      // 24px
+      "3xl": "2.125rem",
+      // 34px
       lg: "1.125rem",
       // 18px
+      md: "1rem",
+      // 16px
+      sm: "0.875rem",
+      // 14px
       xl: "1.25rem",
       // 20px
-      "2xl": "1.5rem",
-      // 24px
-      "3xl": "2.125rem"
-      // 34px
+      xs: "0.75rem"
+      // 12px
     },
     fontWeights: {
-      normal: 400,
+      bold: 700,
       medium: 500,
-      semibold: 600,
-      bold: 700
+      normal: 400,
+      semibold: 600
     },
     lineHeights: {
-      tight: 1.2,
       normal: 1.4,
-      relaxed: 1.6
+      relaxed: 1.6,
+      tight: 1.2
     }
-  },
-  images: {
-    favicon: {},
-    logo: {}
   }
 };
 var toCssVariables = (theme) => {
@@ -3809,91 +3812,91 @@ var toThemeVars = (theme) => {
     };
   }
   const themeVars = {
+    borderRadius: {
+      large: `var(--${prefix}-border-radius-large)`,
+      medium: `var(--${prefix}-border-radius-medium)`,
+      small: `var(--${prefix}-border-radius-small)`
+    },
     colors: {
       action: {
+        activatedOpacity: `var(--${prefix}-color-action-activatedOpacity)`,
         active: `var(--${prefix}-color-action-active)`,
-        hover: `var(--${prefix}-color-action-hover)`,
-        hoverOpacity: `var(--${prefix}-color-action-hoverOpacity)`,
-        selected: `var(--${prefix}-color-action-selected)`,
-        selectedOpacity: `var(--${prefix}-color-action-selectedOpacity)`,
         disabled: `var(--${prefix}-color-action-disabled)`,
         disabledBackground: `var(--${prefix}-color-action-disabledBackground)`,
         disabledOpacity: `var(--${prefix}-color-action-disabledOpacity)`,
         focus: `var(--${prefix}-color-action-focus)`,
         focusOpacity: `var(--${prefix}-color-action-focusOpacity)`,
-        activatedOpacity: `var(--${prefix}-color-action-activatedOpacity)`
-      },
-      primary: {
-        main: `var(--${prefix}-color-primary-main)`,
-        contrastText: `var(--${prefix}-color-primary-contrastText)`
-      },
-      secondary: {
-        main: `var(--${prefix}-color-secondary-main)`,
-        contrastText: `var(--${prefix}-color-secondary-contrastText)`
+        hover: `var(--${prefix}-color-action-hover)`,
+        hoverOpacity: `var(--${prefix}-color-action-hoverOpacity)`,
+        selected: `var(--${prefix}-color-action-selected)`,
+        selectedOpacity: `var(--${prefix}-color-action-selectedOpacity)`
       },
       background: {
-        surface: `var(--${prefix}-color-background-surface)`,
-        disabled: `var(--${prefix}-color-background-disabled)`,
         body: {
           main: `var(--${prefix}-color-background-body-main)`
-        }
+        },
+        disabled: `var(--${prefix}-color-background-disabled)`,
+        surface: `var(--${prefix}-color-background-surface)`
       },
+      border: `var(--${prefix}-color-border)`,
       error: {
-        main: `var(--${prefix}-color-error-main)`,
-        contrastText: `var(--${prefix}-color-error-contrastText)`
+        contrastText: `var(--${prefix}-color-error-contrastText)`,
+        main: `var(--${prefix}-color-error-main)`
       },
       info: {
         contrastText: `var(--${prefix}-color-info-contrastText)`,
         main: `var(--${prefix}-color-info-main)`
       },
-      success: {
-        main: `var(--${prefix}-color-success-main)`,
-        contrastText: `var(--${prefix}-color-success-contrastText)`
+      primary: {
+        contrastText: `var(--${prefix}-color-primary-contrastText)`,
+        main: `var(--${prefix}-color-primary-main)`
       },
-      warning: {
-        main: `var(--${prefix}-color-warning-main)`,
-        contrastText: `var(--${prefix}-color-warning-contrastText)`
+      secondary: {
+        contrastText: `var(--${prefix}-color-secondary-contrastText)`,
+        main: `var(--${prefix}-color-secondary-main)`
+      },
+      success: {
+        contrastText: `var(--${prefix}-color-success-contrastText)`,
+        main: `var(--${prefix}-color-success-main)`
       },
       text: {
         primary: `var(--${prefix}-color-text-primary)`,
         secondary: `var(--${prefix}-color-text-secondary)`
       },
-      border: `var(--${prefix}-color-border)`
-    },
-    spacing: {
-      unit: `var(--${prefix}-spacing-unit)`
-    },
-    borderRadius: {
-      small: `var(--${prefix}-border-radius-small)`,
-      medium: `var(--${prefix}-border-radius-medium)`,
-      large: `var(--${prefix}-border-radius-large)`
+      warning: {
+        contrastText: `var(--${prefix}-color-warning-contrastText)`,
+        main: `var(--${prefix}-color-warning-main)`
+      }
     },
     shadows: {
-      small: `var(--${prefix}-shadow-small)`,
+      large: `var(--${prefix}-shadow-large)`,
       medium: `var(--${prefix}-shadow-medium)`,
-      large: `var(--${prefix}-shadow-large)`
+      small: `var(--${prefix}-shadow-small)`
+    },
+    spacing: {
+      unit: `var(--${prefix}-spacing-unit)`
     },
     typography: {
       fontFamily: `var(--${prefix}-typography-fontFamily)`,
       fontSizes: {
-        xs: `var(--${prefix}-typography-fontSize-xs)`,
-        sm: `var(--${prefix}-typography-fontSize-sm)`,
-        md: `var(--${prefix}-typography-fontSize-md)`,
+        "2xl": `var(--${prefix}-typography-fontSize-2xl)`,
+        "3xl": `var(--${prefix}-typography-fontSize-3xl)`,
         lg: `var(--${prefix}-typography-fontSize-lg)`,
+        md: `var(--${prefix}-typography-fontSize-md)`,
+        sm: `var(--${prefix}-typography-fontSize-sm)`,
         xl: `var(--${prefix}-typography-fontSize-xl)`,
-        "2xl": `var(--${prefix}-typography-fontSize-2xl)`,
-        "3xl": `var(--${prefix}-typography-fontSize-3xl)`
+        xs: `var(--${prefix}-typography-fontSize-xs)`
       },
       fontWeights: {
-        normal: `var(--${prefix}-typography-fontWeight-normal)`,
+        bold: `var(--${prefix}-typography-fontWeight-bold)`,
         medium: `var(--${prefix}-typography-fontWeight-medium)`,
-        semibold: `var(--${prefix}-typography-fontWeight-semibold)`,
-        bold: `var(--${prefix}-typography-fontWeight-bold)`
+        normal: `var(--${prefix}-typography-fontWeight-normal)`,
+        semibold: `var(--${prefix}-typography-fontWeight-semibold)`
       },
       lineHeights: {
-        tight: `var(--${prefix}-typography-lineHeight-tight)`,
         normal: `var(--${prefix}-typography-lineHeight-normal)`,
-        relaxed: `var(--${prefix}-typography-lineHeight-relaxed)`
+        relaxed: `var(--${prefix}-typography-lineHeight-relaxed)`,
+        tight: `var(--${prefix}-typography-lineHeight-tight)`
       }
     }
   };
@@ -3902,9 +3905,9 @@ var toThemeVars = (theme) => {
     Object.keys(theme.images).forEach((imageKey) => {
       const imageConfig = theme.images[imageKey];
       themeVars.images[imageKey] = {
-        url: imageConfig?.url ? `var(--${prefix}-image-${imageKey}-url)` : void 0,
+        alt: imageConfig?.alt ? `var(--${prefix}-image-${imageKey}-alt)` : void 0,
         title: imageConfig?.title ? `var(--${prefix}-image-${imageKey}-title)` : void 0,
-        alt: imageConfig?.alt ? `var(--${prefix}-image-${imageKey}-alt)` : void 0
+        url: imageConfig?.url ? `var(--${prefix}-image-${imageKey}-url)` : void 0
       };
     });
   }
@@ -3918,6 +3921,10 @@ var createTheme = (config = {}, isDark = false) => {
   const mergedConfig = {
     ...baseTheme,
     ...config,
+    borderRadius: {
+      ...baseTheme.borderRadius,
+      ...config.borderRadius
+    },
     colors: {
       ...baseTheme.colors,
       ...config.colors,
@@ -3930,18 +3937,18 @@ var createTheme = (config = {}, isDark = false) => {
         ...config.colors?.secondary || {}
       }
     },
-    spacing: {
-      ...baseTheme.spacing,
-      ...config.spacing
-    },
-    borderRadius: {
-      ...baseTheme.borderRadius,
-      ...config.borderRadius
+    images: {
+      ...baseTheme.images,
+      ...config.images
     },
     shadows: {
       ...baseTheme.shadows,
       ...config.shadows
     },
+    spacing: {
+      ...baseTheme.spacing,
+      ...config.spacing
+    },
     typography: {
       ...baseTheme.typography,
       ...config.typography,
@@ -3957,10 +3964,6 @@ var createTheme = (config = {}, isDark = false) => {
         ...baseTheme.typography.lineHeights,
         ...config.typography?.lineHeights || {}
       }
-    },
-    images: {
-      ...baseTheme.images,
-      ...config.images
     }
   };
   return {
@@ -3976,7 +3979,7 @@ var createTheme_default = createTheme;
 var arrayBufferToBase64url = (buffer) => {
   const bytes = new Uint8Array(buffer);
   let binary = "";
-  for (let i = 0; i < bytes.byteLength; i++) {
+  for (let i = 0; i < bytes.byteLength; i += 1) {
     binary += String.fromCharCode(bytes[i]);
   }
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
@@ -3989,7 +3992,7 @@ var base64urlToArrayBuffer = (base64url) => {
   const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/") + padding;
   const binaryString = atob(base64);
   const bytes = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
+  for (let i = 0; i < binaryString.length; i += 1) {
     bytes[i] = binaryString.charCodeAt(i);
   }
   return bytes.buffer;
@@ -4014,9 +4017,9 @@ var formatDate = (dateString) => {
   if (!dateString) return "-";
   try {
     return new Date(dateString).toLocaleDateString("en-US", {
-      year: "numeric",
+      day: "numeric",
       month: "long",
-      day: "numeric"
+      year: "numeric"
     });
   } catch {
     return dateString;
@@ -4025,9 +4028,7 @@ var formatDate = (dateString) => {
 var formatDate_default = formatDate;
 
 // 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 isPlainObject = (value) => 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");
@@ -4051,95 +4052,48 @@ var deepMerge = (target, ...sources) => {
 };
 var deepMerge_default = deepMerge;
 
-// src/utils/deriveOrganizationHandleFromBaseUrl.ts
-var deriveOrganizationHandleFromBaseUrl = (baseUrl) => {
-  if (!baseUrl) {
-    throw new AsgardeoRuntimeError(
-      "Base URL is required to derive organization handle.",
-      "javascript-deriveOrganizationHandleFromBaseUrl-ValidationError-001",
-      "javascript",
-      "A valid base URL must be provided to extract the organization handle."
-    );
-  }
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(baseUrl);
-  } catch (error2) {
-    throw new AsgardeoRuntimeError(
-      `Invalid base URL format: ${baseUrl}`,
-      "javascript-deriveOrganizationHandleFromBaseUrl-ValidationError-002",
-      "javascript",
-      "The provided base URL does not conform to valid URL syntax."
-    );
-  }
-  const pathSegments = parsedUrl.pathname?.split("/")?.filter((segment) => segment?.length > 0);
-  if (pathSegments.length < 2 || pathSegments[0] !== "t") {
-    console.warn(
-      new AsgardeoRuntimeError(
-        "Organization handle is required since a custom domain is configured.",
-        "javascript-deriveOrganizationHandleFromBaseUrl-CustomDomainError-002",
-        "javascript",
-        "The provided base URL does not follow the expected URL pattern (/t/{orgHandle}). Please provide the organizationHandle explicitly in the configuration."
-      ).toString()
-    );
-    return "";
-  }
-  const organizationHandle = pathSegments[1];
-  if (!organizationHandle || organizationHandle.trim().length === 0) {
-    console.warn(
-      new AsgardeoRuntimeError(
-        "Organization handle is required since a custom domain is configured.",
-        "javascript-deriveOrganizationHandleFromBaseUrl-CustomDomainError-003",
-        "javascript",
-        "The organization handle could not be extracted from the base URL. Please provide the organizationHandle explicitly in the configuration."
-      ).toString()
-    );
-    return "";
-  }
-  return organizationHandle;
-};
-var deriveOrganizationHandleFromBaseUrl_default = deriveOrganizationHandleFromBaseUrl;
-
 // src/utils/logger.ts
 var PREFIX = "\u{1F6E1}\uFE0F Asgardeo";
 var DEFAULT_CONFIG = {
   level: "info",
   prefix: `${PREFIX}`,
-  timestamps: true,
-  showLevel: true
-};
-var isBrowser = () => {
-  return typeof window !== "undefined" && typeof window.document !== "undefined";
-};
-var isNode = () => {
-  return typeof process !== "undefined" && process.versions && process.versions.node;
+  showLevel: true,
+  timestamps: true
 };
+var isBrowser = () => (
+  /* @ts-ignore */
+  typeof window !== "undefined" && typeof window.document !== "undefined"
+);
+var isNode = () => (
+  /* @ts-ignore */
+  typeof process !== "undefined" && process.versions && process.versions.node
+);
 var COLORS = {
-  reset: "\x1B[0m",
+  blue: "\x1B[34m",
   bright: "\x1B[1m",
+  cyan: "\x1B[36m",
   dim: "\x1B[2m",
-  red: "\x1B[31m",
+  gray: "\x1B[90m",
   green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
   magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m",
   white: "\x1B[37m",
-  gray: "\x1B[90m"
+  yellow: "\x1B[33m"
 };
 var BROWSER_STYLES = {
   debug: "color: #6b7280; font-weight: normal;",
-  info: "color: #2563eb; font-weight: bold;",
-  warn: "color: #d97706; font-weight: bold;",
   error: "color: #dc2626; font-weight: bold;",
+  info: "color: #2563eb; font-weight: bold;",
   prefix: "color: #7c3aed; font-weight: bold;",
-  timestamp: "color: #6b7280; font-size: 0.9em;"
+  timestamp: "color: #6b7280; font-size: 0.9em;",
+  warn: "color: #d97706; font-weight: bold;"
 };
 var LOG_LEVEL_ORDER = {
   debug: 0,
+  error: 3,
   info: 1,
-  warn: 2,
-  error: 3
+  warn: 2
 };
 var Logger = class _Logger {
   constructor(config = {}) {
@@ -4167,13 +4121,13 @@ var Logger = class _Logger {
   /**
    * Get timestamp string
    */
-  getTimestamp() {
+  static getTimestamp() {
     return (/* @__PURE__ */ new Date()).toISOString();
   }
   /**
    * Get log level string
    */
-  getLevelString(level) {
+  static getLevelString(level) {
     switch (level) {
       case "debug":
         return "DEBUG";
@@ -4193,13 +4147,13 @@ var Logger = class _Logger {
   formatForNode(level, message) {
     const parts = [];
     if (this.config.timestamps) {
-      parts.push(`${COLORS.gray}[${this.getTimestamp()}]${COLORS.reset}`);
+      parts.push(`${COLORS.gray}[${_Logger.getTimestamp()}]${COLORS.reset}`);
     }
     if (this.config.prefix) {
       parts.push(`${COLORS.magenta}${this.config.prefix}${COLORS.reset}`);
     }
     if (this.config.showLevel) {
-      const levelStr = this.getLevelString(level);
+      const levelStr = _Logger.getLevelString(level);
       let coloredLevel;
       switch (level) {
         case "debug":
@@ -4248,7 +4202,7 @@ var Logger = class _Logger {
     const parts = [];
     const styles = [];
     if (this.config.timestamps) {
-      parts.push(`%c[${this.getTimestamp()}]`);
+      parts.push(`%c[${_Logger.getTimestamp()}]`);
       styles.push(BROWSER_STYLES.timestamp);
     }
     if (this.config.prefix) {
@@ -4256,7 +4210,7 @@ var Logger = class _Logger {
       styles.push(BROWSER_STYLES.prefix);
     }
     if (this.config.showLevel) {
-      const levelStr = this.getLevelString(level);
+      const levelStr = _Logger.getLevelString(level);
       parts.push(`%c[${levelStr}]`);
       switch (level) {
         case "debug":
@@ -4365,31 +4319,74 @@ var Logger = class _Logger {
   }
 };
 var logger = new Logger();
-var createLogger = (config) => {
-  return new Logger(config);
-};
+var createLogger = (config) => new Logger(config);
 var logger_default = logger;
 var debug = (message, ...args) => logger.debug(message, ...args);
 var info = (message, ...args) => logger.info(message, ...args);
 var warn = (message, ...args) => logger.warn(message, ...args);
 var error = (message, ...args) => logger.error(message, ...args);
 var configure = (config) => logger.configure(config);
-var createComponentLogger = (component) => {
-  return logger.child(component);
-};
-var createPackageLogger = (packageName) => {
-  return createLogger({
-    prefix: `${PREFIX} - ${packageName}`,
-    level: "info",
-    timestamps: true,
-    showLevel: true
-  });
-};
+var createComponentLogger = (component) => logger.child(component);
+var createPackageLogger = (packageName) => createLogger({
+  level: "info",
+  prefix: `${PREFIX} - ${packageName}`,
+  showLevel: true,
+  timestamps: true
+});
 var createPackageComponentLogger = (packageName, component) => {
   const packageLogger = createPackageLogger(packageName);
   return packageLogger.child(component);
 };
 
+// src/utils/deriveOrganizationHandleFromBaseUrl.ts
+var deriveOrganizationHandleFromBaseUrl = (baseUrl) => {
+  if (!baseUrl) {
+    throw new AsgardeoRuntimeError(
+      "Base URL is required to derive organization handle.",
+      "javascript-deriveOrganizationHandleFromBaseUrl-ValidationError-001",
+      "javascript",
+      "A valid base URL must be provided to extract the organization handle."
+    );
+  }
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(baseUrl);
+  } catch (error2) {
+    throw new AsgardeoRuntimeError(
+      `Invalid base URL format: ${baseUrl}`,
+      "javascript-deriveOrganizationHandleFromBaseUrl-ValidationError-002",
+      "javascript",
+      "The provided base URL does not conform to valid URL syntax."
+    );
+  }
+  const pathSegments = parsedUrl.pathname?.split("/")?.filter((segment) => segment?.length > 0);
+  if (pathSegments.length < 2 || pathSegments[0] !== "t") {
+    logger_default.warn(
+      new AsgardeoRuntimeError(
+        "Organization handle is required since a custom domain is configured.",
+        "javascript-deriveOrganizationHandleFromBaseUrl-CustomDomainError-002",
+        "javascript",
+        "The provided base URL does not follow the expected URL pattern (/t/{orgHandle}). Please provide the organizationHandle explicitly in the configuration."
+      ).toString()
+    );
+    return "";
+  }
+  const organizationHandle = pathSegments[1];
+  if (!organizationHandle || organizationHandle.trim().length === 0) {
+    logger_default.warn(
+      new AsgardeoRuntimeError(
+        "Organization handle is required since a custom domain is configured.",
+        "javascript-deriveOrganizationHandleFromBaseUrl-CustomDomainError-003",
+        "javascript",
+        "The organization handle could not be extracted from the base URL. Please provide the organizationHandle explicitly in the configuration."
+      ).toString()
+    );
+    return "";
+  }
+  return organizationHandle;
+};
+var deriveOrganizationHandleFromBaseUrl_default = deriveOrganizationHandleFromBaseUrl;
+
 // src/utils/isRecognizedBaseUrlPattern.ts
 var isRecognizedBaseUrlPattern = (baseUrl) => {
   if (!baseUrl) {
@@ -4413,7 +4410,9 @@ var isRecognizedBaseUrlPattern = (baseUrl) => {
   }
   const pathSegments = parsedUrl.pathname?.split("/")?.filter((segment) => segment?.length > 0);
   if (pathSegments.length < 2 || pathSegments[0] !== "t") {
-    logger_default.warn("[isRecognizedBaseUrlPattern] The provided base URL does not follow the expected URL pattern (/t/{orgHandle}).");
+    logger_default.warn(
+      "[isRecognizedBaseUrlPattern] The provided base URL does not follow the expected URL pattern (/t/{orgHandle})."
+    );
     return false;
   }
   return true;
@@ -4451,9 +4450,7 @@ var flattenUserSchema_default = flattenUserSchema;
 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);
+  const result = pathArray.reduce((current, key) => current?.[key], object);
   return result !== void 0 ? result : defaultValue;
 };
 var get_default = get;
@@ -4466,11 +4463,9 @@ var set = (object, path, value) => {
   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) ? [] : {};
-      }
+    } 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);
@@ -4489,14 +4484,12 @@ var generateUserProfile = (meResponse, processedSchemas) => {
       if (multiValued && !Array.isArray(value)) {
         value = [value];
       }
+    } else if (multiValued) {
+      value = void 0;
+    } else if (type === "STRING") {
+      value = "";
     } else {
-      if (multiValued) {
-        value = void 0;
-      } else if (type === "STRING") {
-        value = "";
-      } else {
-        value = void 0;
-      }
+      value = void 0;
     }
     set_default(profile, name, value);
   });
@@ -4640,7 +4633,7 @@ var getRedirectBasedSignUpUrl = (config) => {
       );
     }
   }
-  const url = new URL(signUpBaseUrl + "/accountrecoveryendpoint/register.do");
+  const url = new URL(`${signUpBaseUrl}/accountrecoveryendpoint/register.do`);
   if (config.clientId) {
     url.searchParams.set("client_id", config.clientId);
   }
@@ -4661,13 +4654,14 @@ var resolveFieldType = (field) => {
   if (field.type === "STRING" /* String */) {
     if (field.param === "OTPCode" /* Otp */) {
       return "OTP" /* Otp */;
-    } else if (field?.confidential) {
+    }
+    if (field?.confidential) {
       return "PASSWORD" /* Password */;
     }
     return "TEXT" /* Text */;
   }
   throw new AsgardeoRuntimeError(
-    "Field type is not supported: " + field.type,
+    `Field type is not supported: ${field.type}`,
     "resolveFieldType-Invalid-001",
     "javascript",
     "The provided field type is not supported. Please check the field configuration."
@@ -4700,85 +4694,83 @@ var extractColorValue = (colorVariant, preferDark = false) => {
   }
   return colorVariant?.main;
 };
-var extractContrastText = (colorVariant) => {
-  return colorVariant?.contrastText;
-};
+var extractContrastText = (colorVariant) => colorVariant?.contrastText;
 var transformThemeVariant = (themeVariant, isDark = false) => {
-  const colors = themeVariant.colors;
-  const buttons = themeVariant.buttons;
-  const inputs = themeVariant.inputs;
-  const images = themeVariant.images;
+  const { buttons } = themeVariant;
+  const { colors } = themeVariant;
+  const { images } = themeVariant;
+  const { inputs } = themeVariant;
   const config = {
     colors: {
       action: {
+        activatedOpacity: 0.12,
         active: isDark ? "rgba(255, 255, 255, 0.70)" : "rgba(0, 0, 0, 0.54)",
-        hover: isDark ? "rgba(255, 255, 255, 0.04)" : "rgba(0, 0, 0, 0.04)",
-        hoverOpacity: 0.04,
-        selected: isDark ? "rgba(255, 255, 255, 0.08)" : "rgba(0, 0, 0, 0.08)",
-        selectedOpacity: 0.08,
         disabled: isDark ? "rgba(255, 255, 255, 0.26)" : "rgba(0, 0, 0, 0.26)",
         disabledBackground: isDark ? "rgba(255, 255, 255, 0.12)" : "rgba(0, 0, 0, 0.12)",
         disabledOpacity: 0.38,
         focus: isDark ? "rgba(255, 255, 255, 0.12)" : "rgba(0, 0, 0, 0.12)",
         focusOpacity: 0.12,
-        activatedOpacity: 0.12
-      },
-      primary: {
-        main: extractColorValue(colors?.primary, isDark),
-        contrastText: extractContrastText(colors?.primary),
-        dark: colors?.primary?.dark || colors?.primary?.main
-      },
-      secondary: {
-        main: extractColorValue(colors?.secondary, isDark),
-        contrastText: extractContrastText(colors?.secondary),
-        dark: colors?.secondary?.dark || colors?.secondary?.main
+        hover: isDark ? "rgba(255, 255, 255, 0.04)" : "rgba(0, 0, 0, 0.04)",
+        hoverOpacity: 0.04,
+        selected: isDark ? "rgba(255, 255, 255, 0.08)" : "rgba(0, 0, 0, 0.08)",
+        selectedOpacity: 0.08
       },
       background: {
-        surface: extractColorValue(colors?.background?.surface, isDark),
-        disabled: extractColorValue(colors?.background?.surface, isDark),
-        dark: colors?.background?.surface?.dark || colors?.background?.surface?.main,
         body: {
-          main: extractColorValue(colors?.background?.body, isDark),
-          dark: colors?.background?.body?.dark || colors?.background?.body?.main
-        }
-      },
-      text: {
-        primary: colors?.text?.primary,
-        secondary: colors?.text?.secondary,
-        dark: colors?.text?.dark || colors?.text?.primary
+          dark: colors?.background?.body?.dark || colors?.background?.body?.main,
+          main: extractColorValue(colors?.background?.body, isDark)
+        },
+        dark: colors?.background?.surface?.dark || colors?.background?.surface?.main,
+        disabled: extractColorValue(colors?.background?.surface, isDark),
+        surface: extractColorValue(colors?.background?.surface, isDark)
       },
       border: colors?.outlined?.default,
       error: {
-        main: extractColorValue(colors?.alerts?.error, isDark),
         contrastText: extractContrastText(colors?.alerts?.error),
-        dark: colors?.alerts?.error?.dark || colors?.alerts?.error?.main
+        dark: colors?.alerts?.error?.dark || colors?.alerts?.error?.main,
+        main: extractColorValue(colors?.alerts?.error, isDark)
       },
       info: {
-        main: extractColorValue(colors?.alerts?.info, isDark),
         contrastText: extractContrastText(colors?.alerts?.info),
-        dark: colors?.alerts?.info?.dark || colors?.alerts?.info?.main
+        dark: colors?.alerts?.info?.dark || colors?.alerts?.info?.main,
+        main: extractColorValue(colors?.alerts?.info, isDark)
+      },
+      primary: {
+        contrastText: extractContrastText(colors?.primary),
+        dark: colors?.primary?.dark || colors?.primary?.main,
+        main: extractColorValue(colors?.primary, isDark)
+      },
+      secondary: {
+        contrastText: extractContrastText(colors?.secondary),
+        dark: colors?.secondary?.dark || colors?.secondary?.main,
+        main: extractColorValue(colors?.secondary, isDark)
       },
       success: {
-        main: extractColorValue(colors?.alerts?.neutral, isDark),
         contrastText: extractContrastText(colors?.alerts?.neutral),
-        dark: colors?.alerts?.neutral?.dark || colors?.alerts?.neutral?.main
+        dark: colors?.alerts?.neutral?.dark || colors?.alerts?.neutral?.main,
+        main: extractColorValue(colors?.alerts?.neutral, isDark)
+      },
+      text: {
+        dark: colors?.text?.dark || colors?.text?.primary,
+        primary: colors?.text?.primary,
+        secondary: colors?.text?.secondary
       },
       warning: {
-        main: extractColorValue(colors?.alerts?.warning, isDark),
         contrastText: extractContrastText(colors?.alerts?.warning),
-        dark: colors?.alerts?.warning?.dark || colors?.alerts?.warning?.main
+        dark: colors?.alerts?.warning?.dark || colors?.alerts?.warning?.main,
+        main: extractColorValue(colors?.alerts?.warning, isDark)
       }
     },
     images: {
       favicon: images?.favicon ? {
-        url: images.favicon.imgURL,
+        alt: images.favicon.altText,
         title: images.favicon.title,
-        alt: images.favicon.altText
+        url: images.favicon.imgURL
       } : void 0,
       logo: images?.logo ? {
-        url: images.logo.imgURL,
+        alt: images.logo.altText,
         title: images.logo.title,
-        alt: images.logo.altText
+        url: images.logo.imgURL
       } : void 0
     }
   };