@vc-shell/framework 1.1.91-alpha.5 → 1.1.92

package/core/composables/useNotifications/index.ts

@@ -1,8 +1,6 @@
 import { PushNotification, PushNotificationClient } from "./../../api/platform";
-import { computed, ComputedRef, ref, onUnmounted, inject } from "vue";
+import { computed, ComputedRef, ref, onUnmounted } from "vue";
 import * as _ from "lodash-es";
-import { AuthProviderKey } from "../../../injection-keys";
-import { shouldEnablePlatformFeatures } from "../../providers/auth-provider-utils";
 
 const notificationsClient = new PushNotificationClient();
 
@@ -31,10 +29,6 @@ const subscribers = new Map<
 let subscriberCounter = 0;
 
 export function useNotifications(notifyType?: string | string[]): INotifications {
-  // Check if we're using a custom auth provider
-  const authProvider = inject(AuthProviderKey);
-  const isPlatformProvider = shouldEnablePlatformFeatures(authProvider);
-
   if (notifyType) {
     const types = Array.isArray(notifyType) ? notifyType : [notifyType];
 
@@ -55,12 +49,6 @@ export function useNotifications(notifyType?: string | string[]): INotifications
   }
 
   async function loadFromHistory(take = 10) {
-    // Skip platform API calls for custom authentication providers
-    if (!isPlatformProvider) {
-      console.log("[useNotifications] Skipping loadFromHistory - custom authentication provider detected");
-      return;
-    }
-
     // TODO temporary workaround to get push notifications without base type
     try {
       const result = await fetch("/api/platform/pushnotifications", {
@@ -118,25 +106,6 @@ export function useNotifications(notifyType?: string | string[]): INotifications
   }
 
   async function markAllAsRead() {
-    // Skip platform API calls for custom authentication providers
-    if (!isPlatformProvider) {
-      console.log("[useNotifications] Skipping markAllAsRead - custom authentication provider detected");
-      // Still update local state
-      notifications.value = notifications.value.map((x) => {
-        if (x.isNew) {
-          x.isNew = false;
-        }
-        return x;
-      });
-      pushNotifications.value = pushNotifications.value.map((x) => {
-        if (x.isNew) {
-          x.isNew = false;
-        }
-        return x;
-      });
-      return;
-    }
-
     try {
       notifications.value = notifications.value.map((x) => {
         if (x.isNew) {

package/core/composables/useSettings/index.ts

@@ -1,10 +1,8 @@
 import { useAsync } from "./../useAsync";
 import { useApiClient } from "./../useApiClient";
-import { computed, Ref, ref, ComputedRef, onMounted, inject } from "vue";
+import { computed, Ref, ref, ComputedRef, onMounted } from "vue";
 import { SettingClient } from "./../../api/platform";
 import { useLoading } from "../useLoading";
-import { shouldEnablePlatformFeatures } from "../../providers/auth-provider-utils";
-import { AuthProviderKey } from "../../../injection-keys";
 
 interface IUISetting {
   contrast_logo?: string;
@@ -21,16 +19,13 @@ interface IUseSettings {
 }
 
 export function useSettings(): IUseSettings {
-  // Check if we're using a custom auth provider
-  const authProvider = inject(AuthProviderKey);
-  const isPlatformProvider = shouldEnablePlatformFeatures(authProvider);
   const uiSettings = ref<IUISetting | undefined>();
   const customSettingsApplied = ref(false);
 
   const { getApiClient } = useApiClient(SettingClient);
 
   const { loading, action: getUiCustomizationSettings } = useAsync(async () => {
-    if (customSettingsApplied.value || !isPlatformProvider) return;
+    if (customSettingsApplied.value) return;
 
     const result = await (await getApiClient()).getUICustomizationSetting();
     const settings = await JSON.parse(result.defaultValue ?? null);
@@ -56,7 +51,7 @@ export function useSettings(): IUseSettings {
   }
 
   onMounted(async () => {
-    if (!uiSettings.value && !customSettingsApplied.value && isPlatformProvider) {
+    if (!uiSettings.value && !customSettingsApplied.value) {
       await getUiCustomizationSettings();
     }
   });

package/core/composables/useUser/index.ts

@@ -1,114 +1,211 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { computed, inject, ComputedRef, getCurrentInstance } from "vue";
+import { computed, Ref, ref, ComputedRef } from "vue";
 import {
   UserDetail,
+  SecurityClient,
+  ResetPasswordConfirmRequest,
   SecurityResult,
+  ValidatePasswordResetTokenRequest,
   IdentityResult,
+  ChangePasswordRequest,
   LoginType,
+  LoginRequest,
   SignInResult,
-  IUserDetail,
-  ISecurityResult,
-  ILoginType,
-  IIdentityResult,
 } from "./../../api/platform";
-import { RequestPasswordResult, IAuthProvider } from "./../../types";
+import { RequestPasswordResult } from "./../../types";
 import { createSharedComposable } from "@vueuse/core";
-import { AuthProviderKey } from "../../../injection-keys";
-import { authProviderManager } from "../../providers/auth-provider-manager";
+import { useExternalProvider } from "../../../shared/components/sign-in/useExternalProvider";
 
-/**
- * Interface for the full internal API
- * @deprecated This interface is kept for backward compatibility but will be removed in future versions
- */
+// Interface for the full internal API provided by _createInternalUserLogic
 export interface IUserInternalAPI {
-  user: ComputedRef<IUserDetail | undefined>;
+  user: ComputedRef<UserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
-  loadUser: () => Promise<IUserDetail>;
+  loadUser: () => Promise<UserDetail>;
   signIn: (username: string, password: string) => Promise<SignInResult | { succeeded: boolean; error?: any }>;
   signOut: () => Promise<void>;
   validateToken: (userId: string, token: string) => Promise<boolean>;
-  validatePassword: (password: string) => Promise<IIdentityResult>;
-  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<ISecurityResult>;
+  validatePassword: (password: string) => Promise<IdentityResult>;
+  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<SecurityResult>;
   requestPasswordReset: (loginOrEmail: string) => Promise<RequestPasswordResult>;
-  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<ISecurityResult | undefined>;
-  getLoginType: () => Promise<ILoginType[]>;
+  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult | undefined>;
+  getLoginType: () => Promise<LoginType[]>;
   isAuthenticated: ComputedRef<boolean>;
 }
 
 export interface IAppUserAPI {
-  user: ComputedRef<IUserDetail | undefined>;
+  user: ComputedRef<UserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAuthenticated: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
-  loadUser: () => Promise<IUserDetail>;
+  loadUser: () => Promise<UserDetail>;
   signOut: () => Promise<void>;
 }
 
-/**
- * Get auth provider with fallback to global instance
- * This allows composables to work before Vue app context is available
- * Priority: Vue DI > Global Manager (always has default PlatformAuthProvider)
- */
-function getAuthProvider(): IAuthProvider {
-  // Try to get from Vue DI first (preferred method for components)
-  const instance = getCurrentInstance();
-  if (instance) {
-    const injectedProvider = inject(AuthProviderKey, null);
-    if (injectedProvider) {
-      return injectedProvider;
+const user: Ref<UserDetail | undefined> = ref();
+
+export function _createInternalUserLogic(): IUserInternalAPI {
+  const loading: Ref<boolean> = ref(false);
+
+  const { storage: externalSignInStorage, signOut: externalSignOut } = useExternalProvider();
+
+  const securityClient = new SecurityClient();
+
+  const isAuthenticated = computed(() => user.value?.userName != null);
+
+  async function validateToken(userId: string, token: string): Promise<boolean> {
+    let result = false;
+    try {
+      loading.value = true;
+      result = await securityClient.validatePasswordResetToken(userId, {
+        token,
+      } as ValidatePasswordResetTokenRequest);
+    } catch (e) {
+      //TODO: log error
+    } finally {
+      loading.value = false;
     }
+    return result;
   }
 
-  // Fallback to global provider (always available with default PlatformAuthProvider)
-  return authProviderManager.getProvider();
-}
+  async function validatePassword(password: string): Promise<IdentityResult> {
+    return securityClient.validatePassword(password);
+  }
 
-/**
- * Internal user logic - delegates to auth provider
- * @deprecated This function is kept for backward compatibility but will be removed in future versions
- * Use auth provider directly or useUser/useUserManagement composables
- */
-export function _createInternalUserLogic(): IUserInternalAPI {
-  const authProvider = getAuthProvider();
+  async function resetPasswordByToken(userId: string, password: string, token: string): Promise<SecurityResult> {
+    return securityClient.resetPasswordByToken(userId, {
+      newPassword: password,
+      token,
+    } as ResetPasswordConfirmRequest);
+  }
+
+  async function signIn(
+    username: string,
+    password: string,
+  ): Promise<SignInResult | { succeeded: boolean; error?: any; status?: number }> {
+    console.debug(`[@vc-shell/framework#_createInternalUserLogic:signIn] - Entry point`);
+    try {
+      loading.value = true;
+      const result = await securityClient.login(new LoginRequest({ userName: username, password }));
+      return await securityClient
+        .getCurrentUser()
+        .then((res) => {
+          if (res) {
+            user.value = res;
+            return result;
+          }
+          throw { succeeded: false };
+        })
+        .catch((e) => {
+          throw e;
+        });
+    } catch (e: any) {
+      //TODO: log error
+      console.log(e);
+      return { succeeded: false, error: e.message, status: e.status };
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function signOut(): Promise<void> {
+    console.debug(`[@vc-shell/framework#_createInternalUserLogic:signOut] - Entry point`);
+
+    user.value = undefined;
+
+    if (externalSignInStorage.value?.providerType) {
+      await externalSignOut(externalSignInStorage.value.providerType);
+    } else {
+      securityClient.logout();
+    }
+  }
+
+  async function loadUser(): Promise<UserDetail> {
+    console.debug(`[@vc-shell/framework#_createInternalUserLogic:loadUser] - Entry point`);
+
+    try {
+      loading.value = true;
+      user.value = await securityClient.getCurrentUser();
+      console.log("[_createInternalUserLogic]: an user details has been loaded", user.value);
+    } catch (e: any) {
+      console.error(e);
+    } finally {
+      loading.value = false;
+    }
+
+    return { ...user.value } as UserDetail;
+  }
+
+  async function requestPasswordReset(loginOrEmail: string): Promise<RequestPasswordResult> {
+    try {
+      loading.value = true;
+      await securityClient.requestPasswordReset(loginOrEmail);
+      return { succeeded: true };
+    } catch (e) {
+      //TODO: log error
+      return { succeeded: false, error: e as string };
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function changeUserPassword(oldPassword: string, newPassword: string): Promise<SecurityResult | undefined> {
+    let result;
+
+    try {
+      loading.value = true;
+      const command = new ChangePasswordRequest({
+        oldPassword,
+        newPassword,
+      });
+
+      result = await securityClient.changeCurrentUserPassword(command);
+    } catch (e: any) {
+      return { succeeded: false, errors: [e.message] } as SecurityResult;
+    } finally {
+      loading.value = false;
+    }
+
+    return result;
+  }
+
+  async function getLoginType() {
+    let result: LoginType[] | null = null;
+    try {
+      result = await securityClient.getLoginTypes();
+    } catch (e) {
+      console.error(e);
+      throw e;
+    }
+
+    return result;
+  }
 
   return {
-    user: authProvider.user,
-    loading: authProvider.loading,
-    isAdministrator: authProvider.isAdministrator,
-    isAuthenticated: authProvider.isAuthenticated,
-    loadUser: authProvider.loadUser.bind(authProvider),
-    signIn: authProvider.signIn.bind(authProvider),
-    signOut: authProvider.signOut.bind(authProvider),
-    validateToken: authProvider.validateToken.bind(authProvider),
-    validatePassword: authProvider.validatePassword.bind(authProvider),
-    resetPasswordByToken: authProvider.resetPasswordByToken.bind(authProvider),
-    requestPasswordReset: authProvider.requestPasswordReset.bind(authProvider),
-    changeUserPassword: authProvider.changeUserPassword.bind(authProvider),
-    getLoginType: authProvider.getLoginType.bind(authProvider),
+    user: computed(() => user.value),
+    loading: computed(() => loading.value),
+    isAdministrator: computed(() => user.value?.isAdministrator),
+    isAuthenticated,
+    loadUser,
+    signIn,
+    signOut,
+    validateToken,
+    validatePassword,
+    resetPasswordByToken,
+    requestPasswordReset,
+    changeUserPassword,
+    getLoginType,
   };
 }
 
 export const useUser = createSharedComposable((): IAppUserAPI => {
-  // Get provider dynamically on each access to ensure correct provider is used
-  // This is important because custom auth providers may be set after composable creation
-
+  const internals = _createInternalUserLogic();
   return {
-    // Computed properties should get provider dynamically
-    get user() {
-      return getAuthProvider().user;
-    },
-    get loading() {
-      return getAuthProvider().loading;
-    },
-    get isAuthenticated() {
-      return getAuthProvider().isAuthenticated;
-    },
-    get isAdministrator() {
-      return getAuthProvider().isAdministrator;
-    },
-    // Methods get provider dynamically on each call
-    loadUser: () => getAuthProvider().loadUser(),
-    signOut: () => getAuthProvider().signOut(),
+    user: internals.user,
+    loading: internals.loading,
+    isAuthenticated: internals.isAuthenticated,
+    isAdministrator: internals.isAdministrator,
+    loadUser: internals.loadUser,
+    signOut: internals.signOut,
   };
 });

package/core/composables/useUserManagement/index.ts

@@ -1,87 +1,45 @@
-import { inject, ComputedRef, getCurrentInstance } from "vue";
+import { computed, ComputedRef } from "vue";
 import { createSharedComposable } from "@vueuse/core";
-import {
-  SecurityResult,
-  IdentityResult,
-  LoginType,
-  UserDetail,
-  SignInResult,
-  IUserDetail,
-  IIdentityResult,
-  ISecurityResult,
-  ILoginType,
-} from "./../../api/platform";
-import { RequestPasswordResult, IAuthProvider } from "./../../types";
-import { AuthProviderKey } from "../../../injection-keys";
-import { authProviderManager } from "../../providers/auth-provider-manager";
+import { _createInternalUserLogic, IUserInternalAPI } from "../useUser"; // Import the internal logic
+import { SecurityResult, IdentityResult, LoginType, UserDetail, SignInResult } from "./../../api/platform";
+import { RequestPasswordResult } from "./../../types";
 
 // Interface for the API exposed by useUserManagement (for framework/admin use)
 export interface IUserManagementAPI {
-  user: ComputedRef<IUserDetail | undefined>;
+  user: ComputedRef<UserDetail | undefined>;
   loading: ComputedRef<boolean>;
   isAdministrator: ComputedRef<boolean | undefined>;
   isAuthenticated: ComputedRef<boolean>;
   // Methods specific to user management
   validateToken: (userId: string, token: string) => Promise<boolean>;
-  validatePassword: (password: string) => Promise<IIdentityResult>;
-  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<ISecurityResult>;
-  getLoginType: () => Promise<ILoginType[]>;
-  loadUser: () => Promise<IUserDetail>;
+  validatePassword: (password: string) => Promise<IdentityResult>;
+  resetPasswordByToken: (userId: string, password: string, token: string) => Promise<SecurityResult>;
+  getLoginType: () => Promise<LoginType[]>;
+  loadUser: () => Promise<UserDetail>;
   requestPasswordReset: (loginOrEmail: string) => Promise<RequestPasswordResult>;
-  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<ISecurityResult | undefined>;
+  changeUserPassword: (oldPassword: string, newPassword: string) => Promise<SecurityResult | undefined>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   signIn: (username: string, password: string) => Promise<SignInResult | { succeeded: boolean; error?: any }>;
   signOut: () => Promise<void>;
 }
 
-/**
- * Get auth provider with fallback to global instance
- * This allows composables to work before Vue app context is available
- * Priority: Vue DI > Global Manager (always has default PlatformAuthProvider)
- */
-function getAuthProvider(): IAuthProvider {
-  // Try to get from Vue DI first (preferred method for components)
-  const instance = getCurrentInstance();
-  if (instance) {
-    const injectedProvider = inject(AuthProviderKey, null);
-    if (injectedProvider) {
-      return injectedProvider;
-    }
-  }
-
-  // Fallback to global provider (always available with default PlatformAuthProvider)
-  return authProviderManager.getProvider();
-}
-
 export const useUserManagement = createSharedComposable((): IUserManagementAPI => {
-  // Get provider dynamically on each access to ensure correct provider is used
-  // This is important because custom auth providers may be set after composable creation
+  // Utilize the same internal logic instance
+  const internals: IUserInternalAPI = _createInternalUserLogic();
 
   return {
-    // Computed properties should get provider dynamically
-    get user() {
-      return getAuthProvider().user;
-    },
-    get loading() {
-      return getAuthProvider().loading;
-    },
-    get isAdministrator() {
-      return getAuthProvider().isAdministrator;
-    },
-    get isAuthenticated() {
-      return getAuthProvider().isAuthenticated;
-    },
-    // Methods get provider dynamically on each call
-    validateToken: (userId: string, token: string) => getAuthProvider().validateToken(userId, token),
-    validatePassword: (password: string) => getAuthProvider().validatePassword(password),
-    resetPasswordByToken: (userId: string, password: string, token: string) =>
-      getAuthProvider().resetPasswordByToken(userId, password, token),
-    getLoginType: () => getAuthProvider().getLoginType(),
-    loadUser: () => getAuthProvider().loadUser(),
-    requestPasswordReset: (loginOrEmail: string) => getAuthProvider().requestPasswordReset(loginOrEmail),
-    changeUserPassword: (oldPassword: string, newPassword: string) =>
-      getAuthProvider().changeUserPassword(oldPassword, newPassword),
-    signIn: (username: string, password: string) => getAuthProvider().signIn(username, password),
-    signOut: () => getAuthProvider().signOut(),
+    user: internals.user,
+    loading: internals.loading,
+    isAdministrator: internals.isAdministrator,
+    isAuthenticated: internals.isAuthenticated,
+    validateToken: internals.validateToken,
+    validatePassword: internals.validatePassword,
+    resetPasswordByToken: internals.resetPasswordByToken,
+    getLoginType: internals.getLoginType,
+    loadUser: internals.loadUser,
+    requestPasswordReset: internals.requestPasswordReset,
+    changeUserPassword: internals.changeUserPassword,
+    signIn: internals.signIn,
+    signOut: internals.signOut,
   };
 });

package/core/interceptors/index.ts

@@ -1,33 +1,70 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Router } from "vue-router";
+import { useUserManagement } from "../composables/useUserManagement";
 import { notification } from "../../shared";
-import { IAuthProvider } from "../types/auth-provider";
 
-export function registerInterceptors(router: Router, authProvider: IAuthProvider) {
+export function registerInterceptors(router: Router) {
   const { fetch: originalFetch } = window;
+  const { signOut, isAuthenticated } = useUserManagement();
 
   window.fetch = async (...args) => {
     /**
-     * Intercepts fetch requests to handle authentication errors.
-     * Note: Demo mode should be handled by the auth provider itself, not by global interceptors.
+     * Overrides the global `fetch` function to handle API calls in demo mode.
+     * If `window.__DEMO_MODE__` is true, the fetch is cancelled and a warning is logged.
+     * Otherwise, the original `fetch` function is called.
+     * @param args - The arguments passed to the `fetch` function.
+     * @returns A promise that resolves to the response from the API call.
      */
-    const response = await originalFetch(...args);
-
-    /**
-     * If the response is unauthorized, logout the user
-     */
-    if (response.status === 401) {
-      //logout user
-      if (authProvider.isAuthenticated.value) {
-        authProvider.signOut().then(() => {
-          redirect(router);
-          notification.error(
-            "Access Denied: Your session has expired or you do not have the necessary permissions.\nPlease log in again or contact the administrator for assistance.",
+    if (window.__DEMO_MODE__) {
+      console.warn("CANCELLED FETCH WHILE IN __DEMO_MODE__: ", ...args);
+      console.warn("Please logout and add APP_PLATFORM_URL into .env file of your application to enable API calls");
+      return new Promise((resolve: any) => {
+        /**
+         * This conditions are mocking login, currentuser API calls for demo purposes.
+         */
+        if (args[0] === "/api/platform/security/login") {
+          resolve({
+            status: 200,
+            text: async () => JSON.stringify({ succeeded: true }),
+          });
+        } else if (args[0] === "/api/platform/security/currentuser") {
+          notification.warning(
+            "You are currently in DEMO mode until the first page refresh. \n All API calls are disabled. Please add APP_PLATFORM_URL to your application's .env file to enable API calls.",
+            {
+              timeout: 10000,
+            },
           );
-        });
+          resolve({
+            status: 200,
+            text: async () => JSON.stringify({ id: "demo_user_id", userName: "DEMO_USER" }),
+          });
+        } else {
+          resolve({
+            status: 200,
+            text: async () => JSON.stringify({}),
+          });
+        }
+      });
+    } else {
+      const response = await originalFetch(...args);
+
+      /**
+       * If the response is unauthorized, logout the user
+       */
+      if (response.status === 401) {
+        //logout user
+        if (isAuthenticated.value) {
+          signOut().then(() => {
+            redirect(router);
+            notification.error(
+              "Access Denied: Your session has expired or you do not have the necessary permissions.\nPlease log in again or contact the administrator for assistance.",
+            );
+          });
+        }
       }
-    }
 
-    return response;
+      return response;
+    }
   };
 
   return window.fetch;

package/core/plugins/signalR/index.ts

@@ -1,12 +1,9 @@
-import { App, watch, ref, InjectionKey, inject } from "vue";
+import { App, watch, ref, InjectionKey } from "vue";
 import { HubConnection, HubConnectionBuilder, LogLevel } from "@microsoft/signalr";
 import { PushNotification } from "../../api/platform";
 import { useNotifications } from "./../../composables/useNotifications";
 import { useUserManagement } from "../../composables/useUserManagement";
 import { useCypressSignalRMock } from "cypress-signalr-mock";
-import { AuthProviderKey } from "../../../injection-keys";
-import { IAuthProvider } from "../../types/auth-provider";
-import { shouldEnablePlatformFeatures } from "../../providers/auth-provider-utils";
 
 const { addNotification } = useNotifications();
 const currentCreator = ref<string | undefined>();
@@ -34,31 +31,8 @@ export const signalR = {
     app: App,
     options?: {
       creator?: string;
-      authProvider?: IAuthProvider;
     },
   ) {
-    // Check if we should enable SignalR (only for platform providers)
-    const authProvider = options?.authProvider;
-
-    console.log("[SignalR] Auth provider: ", authProvider);
-
-    // Check if platform features should be enabled
-    if (!shouldEnablePlatformFeatures(authProvider)) {
-      console.log("[SignalR] Skipping initialization - custom authentication provider detected");
-      console.log("[SignalR] SignalR is only available with platform authentication");
-
-      // Provide empty implementations to prevent errors
-      app.config.globalProperties.$updateSignalRCreator = () => {
-        console.warn("[SignalR] Not available with custom authentication provider");
-      };
-      app.provide(updateSignalRCreatorSymbol, () => {
-        console.warn("[SignalR] Not available with custom authentication provider");
-      });
-
-      return;
-    }
-
-    console.log("[SignalR] Initializing with platform authentication");
     currentCreator.value = options?.creator;
     const { isAuthenticated } = useUserManagement();
     let reconnect = false;

package/core/types/index.ts

@@ -233,5 +233,3 @@ export interface MenuItemConfig {
   inGroupPriority?: number;
   permissions?: string | string[];
 }
-
-export * from "./auth-provider";

package/dist/core/api/platform.d.ts

@@ -1197,7 +1197,7 @@ export interface IIdentityError {
 }
 export declare class IdentityResult implements IIdentityResult {
     readonly succeeded?: boolean;
-    readonly errors?: IIdentityError[] | undefined;
+    readonly errors?: IdentityError[] | undefined;
     constructor(data?: IIdentityResult);
     init(_data?: any): void;
     static fromJS(data: any): IdentityResult;