@asgardeo/javascript 0.8.0 → 0.8.1

package/dist/AsgardeoJavaScriptClient.d.ts

@@ -15,45 +15,48 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { AuthClientConfig } from './__legacy__/models/client-config';
+import { AgentConfig } from './models/agent';
+import { AuthCodeResponse } from './models/auth-code-response';
 import { AsgardeoClient } from './models/client';
 import { Config, SignInOptions, SignOutOptions, SignUpOptions } from './models/config';
+import { Crypto } from './models/crypto';
 import { EmbeddedFlowExecuteRequestPayload, EmbeddedFlowExecuteResponse } from './models/embedded-flow';
-import { EmbeddedSignInFlowHandleRequestPayload } from './models/embedded-signin-flow';
 import { AllOrganizationsApiResponse, Organization } from './models/organization';
 import { Storage } from './models/store';
 import { TokenExchangeRequestConfig, TokenResponse } from './models/token';
 import { User, UserProfile } from './models/user';
-/**
- * Base class for implementing Asgardeo clients.
- * This class provides the core functionality for managing user authentication and sessions.
- *
- * @typeParam T - Configuration type that extends Config.
- */
-declare abstract class AsgardeoJavaScriptClient<T = Config> implements AsgardeoClient<T> {
-    abstract switchOrganization(organization: Organization, sessionId?: string): Promise<TokenResponse | Response>;
-    abstract initialize(config: T, storage?: Storage): Promise<boolean>;
-    abstract reInitialize(config: Partial<T>): Promise<boolean>;
-    abstract getUser(options?: any): Promise<User>;
-    abstract getAllOrganizations(options?: any, sessionId?: string): Promise<AllOrganizationsApiResponse>;
-    abstract getMyOrganizations(options?: any, sessionId?: string): Promise<Organization[]>;
-    abstract getCurrentOrganization(sessionId?: string): Promise<Organization | null>;
-    abstract getUserProfile(options?: any): Promise<UserProfile>;
-    abstract isLoading(): boolean;
-    abstract isSignedIn(): Promise<boolean>;
-    abstract updateUserProfile(payload: any, userId?: string): Promise<User>;
-    abstract getConfiguration(): T;
-    abstract exchangeToken(config: TokenExchangeRequestConfig, sessionId?: string): Promise<TokenResponse | Response>;
-    abstract signIn(options?: SignInOptions, sessionId?: string, onSignInSuccess?: (afterSignInUrl: string) => void): Promise<User>;
-    abstract signIn(payload: EmbeddedSignInFlowHandleRequestPayload, request: Request, sessionId?: string, onSignInSuccess?: (afterSignInUrl: string) => void): Promise<User>;
-    abstract signInSilently(options?: SignInOptions): Promise<User | boolean>;
-    abstract signOut(options?: SignOutOptions, afterSignOut?: (afterSignOutUrl: string) => void): Promise<string>;
-    abstract signOut(options?: SignOutOptions, sessionId?: string, afterSignOut?: (afterSignOutUrl: string) => void): Promise<string>;
-    abstract signUp(options?: SignUpOptions): Promise<void>;
-    abstract signUp(payload: EmbeddedFlowExecuteRequestPayload): Promise<EmbeddedFlowExecuteResponse>;
-    abstract signUp(payload?: unknown): Promise<void> | Promise<EmbeddedFlowExecuteResponse>;
-    abstract getAccessToken(sessionId?: string): Promise<string>;
-    abstract clearSession(sessionId?: string): void;
-    abstract setSession(sessionData: Record<string, unknown>, sessionId?: string): Promise<void>;
-    abstract decodeJwtToken<R = Record<string, unknown>>(token: string): Promise<R>;
+declare class AsgardeoJavaScriptClient<T = Config> implements AsgardeoClient<T> {
+    private cacheStore;
+    private cryptoUtils;
+    private auth;
+    private storageManager;
+    private baseURL;
+    constructor(config?: AuthClientConfig<T>, cacheStore?: Storage, cryptoUtils?: Crypto);
+    switchOrganization(_organization: Organization, _sessionId?: string): Promise<TokenResponse | Response>;
+    initialize(_config: T, _storage?: Storage): Promise<boolean>;
+    reInitialize(_config: Partial<T>): Promise<boolean>;
+    getUser(_options?: any): Promise<User>;
+    getAllOrganizations(_options?: any, _sessionId?: string): Promise<AllOrganizationsApiResponse>;
+    getMyOrganizations(_options?: any, _sessionId?: string): Promise<Organization[]>;
+    getCurrentOrganization(_sessionId?: string): Promise<Organization | null>;
+    getUserProfile(_options?: any): Promise<UserProfile>;
+    isLoading(): boolean;
+    isSignedIn(): Promise<boolean>;
+    updateUserProfile(_payload: any, _userId?: string): Promise<User>;
+    getConfiguration(): T;
+    exchangeToken(_config: TokenExchangeRequestConfig, _sessionId?: string): Promise<TokenResponse | Response>;
+    signInSilently(_options?: SignInOptions): Promise<User | boolean>;
+    getAccessToken(_sessionId?: string): Promise<string>;
+    clearSession(_sessionId?: string): void;
+    setSession(_sessionData: Record<string, unknown>, _sessionId?: string): Promise<void>;
+    decodeJwtToken<R = Record<string, unknown>>(_token: string): Promise<R>;
+    signIn(_options?: SignInOptions): Promise<User>;
+    signOut(_options?: SignOutOptions, _sessionIdOrAfterSignOut?: string | ((afterSignOutUrl: string) => void), _afterSignOut?: (afterSignOutUrl: string) => void): Promise<string>;
+    signUp(options?: SignUpOptions): Promise<void>;
+    signUp(payload: EmbeddedFlowExecuteRequestPayload): Promise<EmbeddedFlowExecuteResponse>;
+    getAgentToken(agentConfig: AgentConfig): Promise<TokenResponse>;
+    getOBOSignInURL(agentConfig: AgentConfig): Promise<string>;
+    getOBOToken(agentConfig: AgentConfig, authCodeResponse: AuthCodeResponse): Promise<TokenResponse>;
 }
 export default AsgardeoJavaScriptClient;

package/dist/DefaultCacheStore.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export declare class DefaultCacheStore implements Storage {
+    private cache;
+    constructor();
+    get length(): number;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+    key(index: number): string | null;
+    setData(key: string, value: string): Promise<void>;
+    getData(key: string): Promise<string>;
+    removeData(key: string): Promise<void>;
+}

package/dist/DefaultCrypto.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com).
+ *
+ * WSO2 LLC. licenses this file to you under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Crypto, JWKInterface } from './models/crypto';
+/**
+ * Default implementation of the Crypto interface using the 'jose' library
+ * and the native Web Crypto API.
+ */
+export declare class DefaultCrypto implements Crypto<Uint8Array> {
+    base64URLDecode(value: string): string;
+    base64URLEncode(value: Uint8Array): string;
+    generateRandomBytes(length: number): Uint8Array;
+    hashSha256(data: string): Promise<Uint8Array>;
+    verifyJwt(idToken: string, jwk: JWKInterface, algorithms: string[], clientId: string, issuer: string, subject: string, clockTolerance?: number, validateJwtIssuer?: boolean): Promise<boolean>;
+}

package/dist/IsomorphicCrypto.d.ts

@@ -32,7 +32,7 @@ export declare class IsomorphicCrypto<T = any> {
      *
      * @returns - code challenge.
      */
-    getCodeChallenge(verifier: string): string;
+    getCodeChallenge(verifier: string): Promise<string>;
     /**
      * Get JWK used for the id_token
      *

package/dist/cjs/index.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
@@ -15,12 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AgentConfig: () => AgentConfig,
   ApplicationNativeAuthenticationConstants: () => ApplicationNativeAuthenticationConstants_default,
   AsgardeoAPIError: () => AsgardeoAPIError,
   AsgardeoAuthClient: () => AsgardeoAuthClient,
@@ -105,6 +116,8 @@ __export(index_exports, {
   removeTrailingSlash: () => removeTrailingSlash_default,
   resolveFieldName: () => resolveFieldName_default,
   resolveFieldType: () => resolveFieldType_default,
+  resolveMeta: () => resolveMeta,
+  resolveVars: () => resolveVars,
   set: () => set_default,
   transformBrandingPreferenceToTheme: () => transformBrandingPreferenceToTheme_default,
   updateMeProfile: () => updateMeProfile_default,
@@ -785,8 +798,9 @@ var IsomorphicCrypto = class {
    *
    * @returns - code challenge.
    */
-  getCodeChallenge(verifier) {
-    return this.cryptoUtils.base64URLEncode(this.cryptoUtils.hashSha256(verifier));
+  async getCodeChallenge(verifier) {
+    const hashed = await this.cryptoUtils.hashSha256(verifier);
+    return this.cryptoUtils.base64URLEncode(hashed);
   }
   /**
    * Get JWK used for the id_token
@@ -1006,6 +1020,31 @@ var StorageManager = class _StorageManager {
 };
 var StorageManager_default = StorageManager;
 
+// src/utils/deepMerge.ts
+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");
+  }
+  const result = { ...target };
+  sources.forEach((source) => {
+    if (!source || typeof source !== "object") {
+      return;
+    }
+    Object.keys(source).forEach((key) => {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+        result[key] = deepMerge(targetValue, sourceValue);
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    });
+  });
+  return result;
+};
+var deepMerge_default = deepMerge;
+
 // src/utils/extractPkceStorageKeyFromState.ts
 var extractPkceStorageKeyFromState = (state) => {
   const index = parseInt(state.split("request_")[1], 10);
@@ -1246,7 +1285,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
       let codeChallenge;
       if (configData.enablePKCE) {
         codeVerifier = this.cryptoHelper?.getCodeVerifier();
-        codeChallenge = this.cryptoHelper?.getCodeChallenge(codeVerifier);
+        codeChallenge = await this.cryptoHelper?.getCodeChallenge(codeVerifier);
         await this.storageManager.setTemporaryDataParameter(pkceKey, codeVerifier, userId);
       }
       if (authRequestConfig["client_secret"]) {
@@ -2013,7 +2052,9 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async reInitialize(config) {
-    await this.storageManager.setConfigData(config);
+    const currentConfig = this.storageManager.getConfigData();
+    const newConfig = deepMerge_default(currentConfig, config);
+    await this.storageManager.setConfigData(newConfig);
     await this.loadOpenIDProviderConfiguration(true);
   }
   static async clearSession(userId) {
@@ -3379,10 +3420,14 @@ var EmbeddedFlowComponentType2 = /* @__PURE__ */ ((EmbeddedFlowComponentType3) =
   EmbeddedFlowComponentType3["Block"] = "BLOCK";
   EmbeddedFlowComponentType3["Divider"] = "DIVIDER";
   EmbeddedFlowComponentType3["EmailInput"] = "EMAIL_INPUT";
+  EmbeddedFlowComponentType3["Icon"] = "ICON";
+  EmbeddedFlowComponentType3["Image"] = "IMAGE";
   EmbeddedFlowComponentType3["OtpInput"] = "OTP_INPUT";
   EmbeddedFlowComponentType3["PasswordInput"] = "PASSWORD_INPUT";
   EmbeddedFlowComponentType3["PhoneInput"] = "PHONE_INPUT";
+  EmbeddedFlowComponentType3["RichText"] = "RICH_TEXT";
   EmbeddedFlowComponentType3["Select"] = "SELECT";
+  EmbeddedFlowComponentType3["Stack"] = "STACK";
   EmbeddedFlowComponentType3["Text"] = "TEXT";
   EmbeddedFlowComponentType3["TextInput"] = "TEXT_INPUT";
   return EmbeddedFlowComponentType3;
@@ -3439,6 +3484,12 @@ var FlowMode = /* @__PURE__ */ ((FlowMode2) => {
   return FlowMode2;
 })(FlowMode || {});
 
+// src/models/agent.ts
+var AgentConfig;
+((AgentConfig2) => {
+  AgentConfig2.DEFAULT_AUTHENTICATOR_NAME = "Username & Password";
+})(AgentConfig || (AgentConfig = {}));
+
 // src/models/scim2-schema.ts
 var WellKnownSchemaIds = /* @__PURE__ */ ((WellKnownSchemaIds2) => {
   WellKnownSchemaIds2["Core"] = "urn:ietf:params:scim:schemas:core:2.0";
@@ -3465,8 +3516,225 @@ var FieldType = /* @__PURE__ */ ((FieldType2) => {
   return FieldType2;
 })(FieldType || {});
 
+// src/DefaultCacheStore.ts
+var DefaultCacheStore = class {
+  constructor() {
+    __publicField(this, "cache");
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get length() {
+    return this.cache.size;
+  }
+  getItem(key) {
+    return this.cache.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.cache.set(key, value);
+  }
+  removeItem(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  key(index) {
+    const keys = Array.from(this.cache.keys());
+    return keys[index] ?? null;
+  }
+  async setData(key, value) {
+    this.cache.set(key, value);
+  }
+  async getData(key) {
+    return this.cache.get(key) ?? "{}";
+  }
+  async removeData(key) {
+    this.cache.delete(key);
+  }
+};
+
+// src/DefaultCrypto.ts
+var jose = __toESM(require("jose"), 1);
+var DefaultCrypto = class {
+  // eslint-disable-next-line class-methods-use-this
+  base64URLDecode(value) {
+    const decodedArray = jose.base64url.decode(value);
+    return new TextDecoder().decode(decodedArray);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  base64URLEncode(value) {
+    return jose.base64url.encode(value);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  generateRandomBytes(length) {
+    return crypto.getRandomValues(new Uint8Array(length));
+  }
+  // eslint-disable-next-line class-methods-use-this
+  async hashSha256(data) {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
+    return new Uint8Array(hashBuffer);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  async verifyJwt(idToken, jwk, algorithms, clientId, issuer, subject, clockTolerance, validateJwtIssuer = true) {
+    const key = await jose.importJWK(jwk);
+    await jose.jwtVerify(idToken, key, {
+      algorithms,
+      audience: clientId,
+      clockTolerance,
+      issuer: validateJwtIssuer ? issuer : void 0,
+      subject
+    });
+    return true;
+  }
+};
+
 // src/AsgardeoJavaScriptClient.ts
 var AsgardeoJavaScriptClient = class {
+  constructor(config, cacheStore, cryptoUtils) {
+    __publicField(this, "cacheStore");
+    __publicField(this, "cryptoUtils");
+    __publicField(this, "auth");
+    __publicField(this, "storageManager");
+    __publicField(this, "baseURL");
+    this.cacheStore = cacheStore ?? new DefaultCacheStore();
+    this.cryptoUtils = cryptoUtils ?? new DefaultCrypto();
+    this.auth = new AsgardeoAuthClient();
+    if (config) {
+      this.auth.initialize(config, this.cacheStore, this.cryptoUtils);
+      this.storageManager = this.auth.getStorageManager();
+    }
+    this.baseURL = config?.baseUrl ?? "";
+  }
+  /* eslint-disable class-methods-use-this, @typescript-eslint/no-unused-vars */
+  switchOrganization(_organization, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  initialize(_config, _storage) {
+    throw new Error("Method not implemented.");
+  }
+  reInitialize(_config) {
+    throw new Error("Method not implemented.");
+  }
+  getUser(_options) {
+    throw new Error("Method not implemented.");
+  }
+  getAllOrganizations(_options, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getMyOrganizations(_options, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getCurrentOrganization(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getUserProfile(_options) {
+    throw new Error("Method not implemented.");
+  }
+  isLoading() {
+    throw new Error("Method not implemented.");
+  }
+  isSignedIn() {
+    throw new Error("Method not implemented.");
+  }
+  updateUserProfile(_payload, _userId) {
+    throw new Error("Method not implemented.");
+  }
+  getConfiguration() {
+    throw new Error("Method not implemented.");
+  }
+  exchangeToken(_config, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  signInSilently(_options) {
+    throw new Error("Method not implemented.");
+  }
+  getAccessToken(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  clearSession(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  setSession(_sessionData, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  decodeJwtToken(_token) {
+    throw new Error("Method not implemented.");
+  }
+  signIn(_options) {
+    throw new Error("Method not implemented.");
+  }
+  signOut(_options, _sessionIdOrAfterSignOut, _afterSignOut) {
+    throw new Error("Method not implemented.");
+  }
+  signUp(_optionsOrPayload) {
+    throw new Error("Method not implemented.");
+  }
+  /* eslint-enable class-methods-use-this, @typescript-eslint/no-unused-vars */
+  async getAgentToken(agentConfig) {
+    const customParam = {
+      response_mode: "direct"
+    };
+    const authorizeURL = new URL(await this.auth.getSignInUrl(customParam));
+    const authorizeResponse = await initializeEmbeddedSignInFlow_default({
+      payload: Object.fromEntries(authorizeURL.searchParams.entries()),
+      url: `${authorizeURL.origin}${authorizeURL.pathname}`
+    });
+    const authenticatorName = agentConfig.authenticatorName ?? AgentConfig.DEFAULT_AUTHENTICATOR_NAME;
+    const targetAuthenticator = authorizeResponse.nextStep.authenticators.find(
+      (auth) => auth.authenticator === authenticatorName
+    );
+    if (!targetAuthenticator) {
+      throw new Error(`Authenticator '${authenticatorName}' not found among authentication steps.`);
+    }
+    const authnRequest = {
+      baseUrl: this.baseURL,
+      payload: {
+        flowId: authorizeResponse.flowId,
+        selectedAuthenticator: {
+          authenticatorId: targetAuthenticator.authenticatorId,
+          params: {
+            password: agentConfig.agentSecret,
+            username: agentConfig.agentID
+          }
+        }
+      }
+    };
+    const authnResponse = await executeEmbeddedSignInFlow_default(authnRequest);
+    if (authnResponse.flowStatus !== "SUCCESS_COMPLETED" /* SuccessCompleted */) {
+      throw new Error("Agent authentication failed.");
+    }
+    return this.auth.requestAccessToken(
+      authnResponse.authData["code"],
+      authnResponse.authData["session_state"],
+      authnResponse.authData["state"]
+    );
+  }
+  async getOBOSignInURL(agentConfig) {
+    const customParam = {
+      requested_actor: agentConfig.agentID
+    };
+    const authURL = await this.auth.getSignInUrl(customParam);
+    if (authURL) {
+      return authURL.toString();
+    }
+    throw new Error("Could not build Authorize URL");
+  }
+  async getOBOToken(agentConfig, authCodeResponse) {
+    const agentToken = await this.getAgentToken(agentConfig);
+    const tokenRequestConfig = {
+      params: {
+        actor_token: agentToken.accessToken
+      }
+    };
+    return this.auth.requestAccessToken(
+      authCodeResponse.code,
+      authCodeResponse.session_state,
+      authCodeResponse.state,
+      void 0,
+      tokenRequestConfig
+    );
+  }
 };
 var AsgardeoJavaScriptClient_default = AsgardeoJavaScriptClient;
 
@@ -4060,9 +4328,9 @@ var arrayBufferToBase64url = (buffer) => {
 var arrayBufferToBase64url_default = arrayBufferToBase64url;
 
 // src/utils/base64urlToArrayBuffer.ts
-var base64urlToArrayBuffer = (base64url) => {
-  const padding = "=".repeat((4 - base64url.length % 4) % 4);
-  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/") + padding;
+var base64urlToArrayBuffer = (base64url2) => {
+  const padding = "=".repeat((4 - base64url2.length % 4) % 4);
+  const base64 = base64url2.replace(/-/g, "+").replace(/_/g, "/") + padding;
   const binaryString = atob(base64);
   const bytes = new Uint8Array(binaryString.length);
   for (let i = 0; i < binaryString.length; i += 1) {
@@ -4100,31 +4368,6 @@ var formatDate = (dateString) => {
 };
 var formatDate_default = formatDate;
 
-// src/utils/deepMerge.ts
-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");
-  }
-  const result = { ...target };
-  sources.forEach((source) => {
-    if (!source || typeof source !== "object") {
-      return;
-    }
-    Object.keys(source).forEach((key) => {
-      const sourceValue = source[key];
-      const targetValue = result[key];
-      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
-        result[key] = deepMerge(targetValue, sourceValue);
-      } else if (sourceValue !== void 0) {
-        result[key] = sourceValue;
-      }
-    });
-  });
-  return result;
-};
-var deepMerge_default = deepMerge;
-
 // src/utils/logger.ts
 var PREFIX = "\u{1F6E1}\uFE0F Asgardeo";
 var DEFAULT_CONFIG = {
@@ -4756,6 +4999,48 @@ var resolveFieldName = (field) => {
 };
 var resolveFieldName_default = resolveFieldName;
 
+// src/utils/v2/resolveMeta.ts
+function resolveMeta(path, meta) {
+  const value = path.split(".").reduce((current, part) => {
+    if (current == null || typeof current !== "object") {
+      return void 0;
+    }
+    const obj = current;
+    const snakePart = part.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+    return part in obj ? obj[part] : obj[snakePart];
+  }, meta);
+  return value != null ? String(value) : "";
+}
+
+// src/utils/v2/resolveVars.ts
+function resolveVars(text, { t, meta }) {
+  if (!text) {
+    return "";
+  }
+  return text.replace(/\{\{(.+?)\}\}/g, (match, content) => {
+    const trimmed = content.trim();
+    const tMatch = trimmed.match(/^t\((.+)\)$/);
+    if (tMatch) {
+      let key = tMatch[1].trim();
+      if (key.startsWith('"') && key.endsWith('"') || key.startsWith("'") && key.endsWith("'")) {
+        key = key.slice(1, -1);
+      }
+      return t(key.replace(/:/g, "."));
+    }
+    if (meta) {
+      const metaMatch = trimmed.match(/^meta\((.+)\)$/);
+      if (metaMatch) {
+        let path = metaMatch[1].trim();
+        if (path.startsWith('"') && path.endsWith('"') || path.startsWith("'") && path.endsWith("'")) {
+          path = path.slice(1, -1);
+        }
+        return resolveMeta(path, meta);
+      }
+    }
+    return match;
+  });
+}
+
 // src/utils/withVendorCSSClassPrefix.ts
 var withVendorCSSClassPrefix = (className) => `${VendorConstants_default.VENDOR_PREFIX}-${className}`;
 var withVendorCSSClassPrefix_default = withVendorCSSClassPrefix;
@@ -4899,6 +5184,7 @@ var transformBrandingPreferenceToTheme = (brandingPreference, forceTheme) => {
 var transformBrandingPreferenceToTheme_default = transformBrandingPreferenceToTheme;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AgentConfig,
   ApplicationNativeAuthenticationConstants,
   AsgardeoAPIError,
   AsgardeoAuthClient,
@@ -4983,6 +5269,8 @@ var transformBrandingPreferenceToTheme_default = transformBrandingPreferenceToTh
   removeTrailingSlash,
   resolveFieldName,
   resolveFieldType,
+  resolveMeta,
+  resolveVars,
   set,
   transformBrandingPreferenceToTheme,
   updateMeProfile,