@gridsuite/commons-ui 0.46.0 → 0.48.0

package/dist/utils/AuthService.js

@@ -0,0 +1,336 @@
+import { Log, UserManager } from "oidc-client";
+import { UserManagerMock } from "./UserManagerMock.js";
+import { setShowAuthenticationRouterLogin, setLoggedUser, setLogoutError, setUnauthorizedUserInfo, setUserValidationError, resetAuthenticationRouterError, setSignInCallbackError } from "./actions.js";
+import jwtDecode from "jwt-decode";
+window.OIDCLog = Log;
+const hackAuthorityKey = "oidc.hack.authority";
+const oidcHackReloadedKey = "gridsuite-oidc-hack-reloaded";
+const pathKey = "powsybl-gridsuite-current-path";
+function isIssuerErrorForCodeFlow(error) {
+  return error.message.includes("Invalid issuer in token");
+}
+function extractIssuerToSessionStorage(error) {
+  const issuer = error.message.split(" ").pop();
+  sessionStorage.setItem(hackAuthorityKey, issuer);
+}
+function reload() {
+  if (!sessionStorage.getItem(oidcHackReloadedKey)) {
+    sessionStorage.setItem(oidcHackReloadedKey, true);
+    console.log("Hack oidc, reload page to make login work");
+    window.location.reload();
+  }
+}
+function reloadTimerOnExpiresIn(user, userManager, expiresIn) {
+  user.expires_in = expiresIn;
+  userManager.storeUser(user).then(() => {
+    userManager.getUser();
+  });
+}
+function handleSigninSilent(dispatch, userManager) {
+  userManager.getUser().then((user) => {
+    if (user == null || getIdTokenExpiresIn(user) < 0) {
+      return userManager.signinSilent().catch((error) => {
+        dispatch(setShowAuthenticationRouterLogin(true));
+        const errorIssuerCodeFlow = isIssuerErrorForCodeFlow(error);
+        const errorIssuerImplicitFlow = error.message === "authority mismatch on settings vs. signin state";
+        if (errorIssuerCodeFlow) {
+          extractIssuerToSessionStorage(error);
+        }
+        if (errorIssuerCodeFlow || errorIssuerImplicitFlow) {
+          reload();
+        }
+      });
+    }
+  });
+}
+function initializeAuthenticationDev(dispatch, isSilentRenew, validateUser, isSigninCallback) {
+  let userManager = new UserManagerMock({});
+  if (!isSilentRenew) {
+    handleUser(dispatch, userManager, validateUser);
+    if (!isSigninCallback) {
+      handleSigninSilent(dispatch, userManager);
+    }
+  }
+  return Promise.resolve(userManager);
+}
+const accessTokenExpiringNotificationTime = 60;
+function initializeAuthenticationProd(dispatch, isSilentRenew, idpSettings, validateUser, authorizationCodeFlowEnabled, isSigninCallback) {
+  return idpSettings.then((r) => r.json()).then((idpSettings2) => {
+    const regextoken = /id_token=[^&]*/;
+    const regexstate = /state=[^&]*/;
+    const regexexpires = /expires_in=[^&]*/;
+    let authority;
+    if (window.location.hash) {
+      const matched_id_token = window.location.hash.match(regextoken);
+      const matched_state = window.location.hash.match(regexstate);
+      if (matched_id_token != null && matched_state != null) {
+        const id_token = matched_id_token[0].split("=")[1];
+        const state = matched_state[0].split("=")[1];
+        const strState = localStorage.getItem("oidc." + state);
+        if (strState != null) {
+          const decoded = jwtDecode(id_token);
+          authority = decoded.iss;
+          const storedState = JSON.parse(strState);
+          console.debug(
+            "Replacing authority in storedState. Before: ",
+            storedState.authority,
+            "after: ",
+            authority
+          );
+          storedState.authority = authority;
+          localStorage.setItem(
+            "oidc." + state,
+            JSON.stringify(storedState)
+          );
+          sessionStorage.setItem(hackAuthorityKey, authority);
+          const matched_expires = window.location.hash.match(regexexpires);
+          if (matched_expires != null) {
+            const expires_in = parseInt(
+              matched_expires[0].split("=")[1]
+            );
+            window.location.hash = window.location.hash.replace(
+              matched_expires[0],
+              "expires_in=" + computeMinExpiresIn(
+                expires_in,
+                id_token,
+                idpSettings2.maxExpiresIn
+              )
+            );
+          }
+        }
+      }
+    }
+    authority = authority || sessionStorage.getItem(hackAuthorityKey) || idpSettings2.authority;
+    const responseSettings = authorizationCodeFlowEnabled ? { response_type: "code" } : {
+      response_type: "id_token token",
+      response_mode: "fragment"
+    };
+    const settings = {
+      authority,
+      client_id: idpSettings2.client_id,
+      redirect_uri: idpSettings2.redirect_uri,
+      post_logout_redirect_uri: idpSettings2.post_logout_redirect_uri,
+      silent_redirect_uri: idpSettings2.silent_redirect_uri,
+      scope: idpSettings2.scope,
+      automaticSilentRenew: !isSilentRenew,
+      accessTokenExpiringNotificationTime,
+      ...responseSettings
+    };
+    let userManager = new UserManager(settings);
+    userManager.idpSettings = idpSettings2;
+    userManager.authorizationCodeFlowEnabled = authorizationCodeFlowEnabled;
+    if (!isSilentRenew) {
+      handleUser(dispatch, userManager, validateUser);
+      if (!isSigninCallback) {
+        handleSigninSilent(dispatch, userManager);
+      }
+    }
+    return userManager;
+  }).catch((error) => {
+    console.debug("error when importing the idp settings", error);
+    dispatch(setShowAuthenticationRouterLogin(true));
+    throw error;
+  });
+}
+function computeMinExpiresIn(expiresIn, idToken, maxExpiresIn) {
+  const now = parseInt(Date.now() / 1e3);
+  const exp = jwtDecode(idToken).exp;
+  const idTokenExpiresIn = exp - now;
+  let newExpiresIn = expiresIn;
+  let newExpiresInReplaceReason;
+  if (expiresIn === void 0 || idTokenExpiresIn < newExpiresIn) {
+    newExpiresIn = idTokenExpiresIn;
+    newExpiresInReplaceReason = "idtoken.exp is earlier";
+  }
+  if (maxExpiresIn && maxExpiresIn < newExpiresIn) {
+    newExpiresIn = maxExpiresIn;
+    newExpiresInReplaceReason = "idpSettings.maxExpiresIn is smaller";
+  }
+  if (newExpiresInReplaceReason) {
+    console.debug(
+      "Replacing expiresIn in user to " + newExpiresIn + " because " + newExpiresInReplaceReason + ". ",
+      "debug:",
+      "original expires_in: " + expiresIn + ", ",
+      "idTokenExpiresIn: " + idTokenExpiresIn + ", idpSettings maxExpiresIn: " + maxExpiresIn
+    );
+  }
+  return newExpiresIn;
+}
+function login(location, userManagerInstance) {
+  sessionStorage.setItem(pathKey, location.pathname + location.search);
+  return userManagerInstance.signinRedirect().then(() => console.debug("login"));
+}
+function logout(dispatch, userManagerInstance) {
+  sessionStorage.removeItem(hackAuthorityKey);
+  return userManagerInstance.getUser().then((user) => {
+    if (user) {
+      return userManagerInstance.signoutRedirect({
+        extraQueryParams: {
+          TargetResource: userManagerInstance.settings.post_logout_redirect_uri
+        }
+      }).then(() => {
+        console.debug("logged out, window is closing...");
+      }).catch((e) => {
+        var _a;
+        console.log("Error during logout :", e);
+        dispatch(setLoggedUser(null));
+        dispatch(setLogoutError((_a = user == null ? void 0 : user.profile) == null ? void 0 : _a.name, { error: e }));
+      });
+    } else {
+      console.log("Error nobody to logout ");
+    }
+  });
+}
+function getIdTokenExpiresIn(user) {
+  const now = parseInt(Date.now() / 1e3);
+  const exp = jwtDecode(user.id_token).exp;
+  return exp - now;
+}
+function dispatchUser(dispatch, userManagerInstance, validateUser) {
+  return userManagerInstance.getUser().then((user) => {
+    if (user) {
+      if (getIdTokenExpiresIn(user) < 0) {
+        console.debug(
+          "User token is expired and will not be dispatched"
+        );
+        return;
+      }
+      let validateUserPromise = validateUser && validateUser(user) || Promise.resolve(true);
+      return validateUserPromise.then((valid) => {
+        var _a;
+        if (!valid) {
+          console.debug(
+            "User isn't authorized to log in and will not be dispatched"
+          );
+          return dispatch(
+            setUnauthorizedUserInfo((_a = user == null ? void 0 : user.profile) == null ? void 0 : _a.name, {})
+          );
+        }
+        console.debug(
+          "User has been successfully loaded from store."
+        );
+        if (userManagerInstance.authorizationCodeFlowEnabled) {
+          reloadTimerOnExpiresIn(
+            user,
+            userManagerInstance,
+            computeMinExpiresIn(
+              user.expires_in,
+              user.id_token,
+              userManagerInstance.idpSettings.maxExpiresIn
+            )
+          );
+        }
+        return dispatch(setLoggedUser(user));
+      }).catch((e) => {
+        var _a;
+        console.log("Error in dispatchUser", e);
+        return dispatch(
+          setUserValidationError((_a = user == null ? void 0 : user.profile) == null ? void 0 : _a.name, {
+            error: e
+          })
+        );
+      });
+    } else {
+      console.debug("You are not logged in.");
+    }
+  });
+}
+function getPreLoginPath() {
+  return sessionStorage.getItem(pathKey);
+}
+function navigateToPreLoginPath(navigate) {
+  const previousPath = getPreLoginPath();
+  navigate(previousPath);
+}
+function handleSigninCallback(dispatch, navigate, userManagerInstance) {
+  let reloadAfterNavigate = false;
+  userManagerInstance.signinRedirectCallback().catch(function(e) {
+    if (isIssuerErrorForCodeFlow(e)) {
+      extractIssuerToSessionStorage(e);
+      reloadAfterNavigate = true;
+    } else {
+      throw e;
+    }
+  }).then(function() {
+    dispatch(setSignInCallbackError(null));
+    navigateToPreLoginPath(navigate);
+    if (reloadAfterNavigate) {
+      reload();
+    }
+  }).catch(function(e) {
+    dispatch(setSignInCallbackError(e));
+    console.error(e);
+  });
+}
+function handleSilentRenewCallback(userManagerInstance) {
+  userManagerInstance.signinSilentCallback();
+}
+function handleUser(dispatch, userManager, validateUser) {
+  userManager.events.addUserLoaded((user) => {
+    console.debug("user loaded", user);
+    dispatchUser(dispatch, userManager, validateUser);
+  });
+  userManager.events.addSilentRenewError((error) => {
+    console.debug(error);
+    window.setTimeout(() => {
+      userManager.getUser().then((user) => {
+        if (!user) {
+          console.error(
+            "user is null at silent renew error, it shouldn't happen."
+          );
+        }
+        const idTokenExpiresIn = getIdTokenExpiresIn(user);
+        if (idTokenExpiresIn < 0) {
+          console.log(
+            "Error in silent renew, idtoken expired: " + idTokenExpiresIn + " => Logging out.",
+            error
+          );
+          dispatch(setShowAuthenticationRouterLogin(true));
+          dispatch(resetAuthenticationRouterError());
+          return dispatch(setLoggedUser(null));
+        } else if (userManager.idpSettings.maxExpiresIn) {
+          if (idTokenExpiresIn < userManager.idpSettings.maxExpiresIn) {
+            console.log(
+              "Error in silent renew, but idtoken ALMOST expiring (expiring in" + idTokenExpiresIn + ") => last chance, next error will logout",
+              "maxExpiresIn = " + userManager.idpSettings.maxExpiresIn,
+              "last renew attempt in " + idTokenExpiresIn - accessTokenExpiringNotificationTime + "seconds",
+              error
+            );
+            reloadTimerOnExpiresIn(
+              user,
+              userManager,
+              idTokenExpiresIn
+            );
+          } else {
+            console.log(
+              "Error in silent renew, but idtoken NOT expiring (expiring in" + idTokenExpiresIn + ") => postponing expiration to" + userManager.idpSettings.maxExpiresIn,
+              error
+            );
+            reloadTimerOnExpiresIn(
+              user,
+              userManager,
+              userManager.idpSettings.maxExpiresIn
+            );
+          }
+        } else {
+          console.log(
+            "Error in silent renew, unsupported configuration: token still valid for " + idTokenExpiresIn + " but maxExpiresIn is not configured:" + userManager.idpSettings.maxExpiresIn,
+            error
+          );
+        }
+      });
+    }, accessTokenExpiringNotificationTime * 1e3);
+  });
+  console.debug("dispatch user");
+  dispatchUser(dispatch, userManager, validateUser);
+}
+export {
+  dispatchUser,
+  getPreLoginPath,
+  handleSigninCallback,
+  handleSilentRenewCallback,
+  initializeAuthenticationDev,
+  initializeAuthenticationProd,
+  login,
+  logout
+};

package/dist/utils/ElementType.d.ts

@@ -0,0 +1,13 @@
+export function getFileIcon(type: any, style: any): import("react/jsx-runtime").JSX.Element | undefined;
+export namespace elementType {
+    const DIRECTORY: string;
+    const STUDY: string;
+    const CASE: string;
+    const FILTER: string;
+    const MODIFICATION: string;
+    const CONTINGENCY_LIST: string;
+    const VOLTAGE_INIT_PARAMETERS: string;
+    const SECURITY_ANALYSIS_PARAMETERS: string;
+    const LOADFLOW_PARAMETERS: string;
+    const SENSITIVITY_PARAMETERS: string;
+}

package/dist/utils/ElementType.js

@@ -0,0 +1,42 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { Settings, Article, NoteAlt, OfflineBolt, Photo, PhotoLibrary } from "@mui/icons-material";
+const elementType = {
+  DIRECTORY: "DIRECTORY",
+  STUDY: "STUDY",
+  CASE: "CASE",
+  FILTER: "FILTER",
+  MODIFICATION: "MODIFICATION",
+  CONTINGENCY_LIST: "CONTINGENCY_LIST",
+  VOLTAGE_INIT_PARAMETERS: "VOLTAGE_INIT_PARAMETERS",
+  SECURITY_ANALYSIS_PARAMETERS: "SECURITY_ANALYSIS_PARAMETERS",
+  LOADFLOW_PARAMETERS: "LOADFLOW_PARAMETERS",
+  SENSITIVITY_PARAMETERS: "SENSITIVITY_PARAMETERS"
+};
+function getFileIcon(type, style) {
+  switch (type) {
+    case elementType.STUDY:
+      return /* @__PURE__ */ jsx(PhotoLibrary, { sx: style });
+    case elementType.CASE:
+      return /* @__PURE__ */ jsx(Photo, { sx: style });
+    case elementType.CONTINGENCY_LIST:
+      return /* @__PURE__ */ jsx(OfflineBolt, { sx: style });
+    case elementType.MODIFICATION:
+      return /* @__PURE__ */ jsx(NoteAlt, { sx: style });
+    case elementType.FILTER:
+      return /* @__PURE__ */ jsx(Article, { sx: style });
+    case elementType.VOLTAGE_INIT_PARAMETERS:
+    case elementType.SECURITY_ANALYSIS_PARAMETERS:
+    case elementType.LOADFLOW_PARAMETERS:
+    case elementType.SENSITIVITY_PARAMETERS:
+      return /* @__PURE__ */ jsx(Settings, { sx: style });
+    case elementType.DIRECTORY:
+      return;
+    default:
+      console.warn("unknown type [" + type + "]");
+  }
+}
+export {
+  elementType,
+  getFileIcon
+};

package/dist/utils/EquipmentType.d.ts

@@ -0,0 +1,136 @@
+export const TYPE_TAG_MAX_SIZE: "90px";
+export const VL_TAG_MAX_SIZE: "100px";
+export namespace equipmentStyles {
+    namespace equipmentOption {
+        const display: string;
+        const gap: string;
+        const width: string;
+        const margin: string;
+        const padding: string;
+        const alignItems: string;
+        const justifyContent: string;
+    }
+    function equipmentTag(theme: any): {
+        borderRadius: string;
+        padding: string;
+        fontSize: string;
+        textAlign: string;
+        color: string;
+    };
+    namespace equipmentTypeTag {
+        export { TYPE_TAG_MAX_SIZE as minWidth };
+        export { TYPE_TAG_MAX_SIZE as maxWidth };
+        export const background: string;
+    }
+    namespace equipmentVlTag {
+        export { VL_TAG_MAX_SIZE as width };
+        export { VL_TAG_MAX_SIZE as minWidth };
+        export { VL_TAG_MAX_SIZE as maxWidth };
+        const background_1: string;
+        export { background_1 as background };
+        export const fontStyle: string;
+    }
+    namespace result {
+        const width_1: string;
+        export { width_1 as width };
+        const padding_1: string;
+        export { padding_1 as padding };
+    }
+}
+export namespace EQUIPMENT_TYPE {
+    namespace SUBSTATION {
+        const name: string;
+        const tagLabel: string;
+    }
+    namespace VOLTAGE_LEVEL {
+        const name_1: string;
+        export { name_1 as name };
+        const tagLabel_1: string;
+        export { tagLabel_1 as tagLabel };
+    }
+    namespace LINE {
+        const name_2: string;
+        export { name_2 as name };
+        const tagLabel_2: string;
+        export { tagLabel_2 as tagLabel };
+    }
+    namespace TWO_WINDINGS_TRANSFORMER {
+        const name_3: string;
+        export { name_3 as name };
+        const tagLabel_3: string;
+        export { tagLabel_3 as tagLabel };
+    }
+    namespace THREE_WINDINGS_TRANSFORMER {
+        const name_4: string;
+        export { name_4 as name };
+        const tagLabel_4: string;
+        export { tagLabel_4 as tagLabel };
+    }
+    namespace HVDC_LINE {
+        const name_5: string;
+        export { name_5 as name };
+        const tagLabel_5: string;
+        export { tagLabel_5 as tagLabel };
+    }
+    namespace GENERATOR {
+        const name_6: string;
+        export { name_6 as name };
+        const tagLabel_6: string;
+        export { tagLabel_6 as tagLabel };
+    }
+    namespace BATTERY {
+        const name_7: string;
+        export { name_7 as name };
+        const tagLabel_7: string;
+        export { tagLabel_7 as tagLabel };
+    }
+    namespace LOAD {
+        const name_8: string;
+        export { name_8 as name };
+        const tagLabel_8: string;
+        export { tagLabel_8 as tagLabel };
+    }
+    namespace SHUNT_COMPENSATOR {
+        const name_9: string;
+        export { name_9 as name };
+        const tagLabel_9: string;
+        export { tagLabel_9 as tagLabel };
+    }
+    namespace DANGLING_LINE {
+        const name_10: string;
+        export { name_10 as name };
+        const tagLabel_10: string;
+        export { tagLabel_10 as tagLabel };
+    }
+    namespace STATIC_VAR_COMPENSATOR {
+        const name_11: string;
+        export { name_11 as name };
+        const tagLabel_11: string;
+        export { tagLabel_11 as tagLabel };
+    }
+    namespace HVDC_CONVERTER_STATION {
+        const name_12: string;
+        export { name_12 as name };
+        const tagLabel_12: string;
+        export { tagLabel_12 as tagLabel };
+    }
+    namespace BUSBAR_SECTION {
+        const name_13: string;
+        export { name_13 as name };
+        const tagLabel_13: string;
+        export { tagLabel_13 as tagLabel };
+    }
+    namespace BUS {
+        const name_14: string;
+        export { name_14 as name };
+        const tagLabel_14: string;
+        export { tagLabel_14 as tagLabel };
+    }
+    namespace SWITCH {
+        const name_15: string;
+        export { name_15 as name };
+        const tagLabel_15: string;
+        export { tagLabel_15 as tagLabel };
+    }
+}
+export function getEquipmentsInfosForSearchBar(equipmentsInfos: any, getNameOrId: any): any;

package/dist/utils/EquipmentType.js

@@ -0,0 +1,132 @@
+import { LIGHT_THEME } from "../components/TopBar/TopBar.js";
+const TYPE_TAG_MAX_SIZE = "90px";
+const VL_TAG_MAX_SIZE = "100px";
+const equipmentStyles = {
+  equipmentOption: {
+    display: "flex",
+    gap: "20px",
+    width: "100%",
+    margin: "0px",
+    padding: "0px",
+    alignItems: "center",
+    justifyContent: "space-between"
+  },
+  equipmentTag: (theme) => ({
+    borderRadius: "10px",
+    padding: "4px",
+    fontSize: "x-small",
+    textAlign: "center",
+    color: theme === LIGHT_THEME ? "inherit" : "black"
+  }),
+  equipmentTypeTag: {
+    minWidth: TYPE_TAG_MAX_SIZE,
+    maxWidth: TYPE_TAG_MAX_SIZE,
+    background: "lightblue"
+  },
+  equipmentVlTag: {
+    width: VL_TAG_MAX_SIZE,
+    minWidth: VL_TAG_MAX_SIZE,
+    maxWidth: VL_TAG_MAX_SIZE,
+    background: "lightgray",
+    fontStyle: "italic"
+  },
+  result: {
+    width: "100%",
+    padding: "2px"
+  }
+};
+const EQUIPMENT_TYPE = {
+  SUBSTATION: {
+    name: "SUBSTATION",
+    tagLabel: "equipment_search/substationTag"
+  },
+  VOLTAGE_LEVEL: {
+    name: "VOLTAGE_LEVEL",
+    tagLabel: "equipment_search/voltageLevelTag"
+  },
+  LINE: {
+    name: "LINE",
+    tagLabel: "equipment_search/lineTag"
+  },
+  TWO_WINDINGS_TRANSFORMER: {
+    name: "TWO_WINDINGS_TRANSFORMER",
+    tagLabel: "equipment_search/2wtTag"
+  },
+  THREE_WINDINGS_TRANSFORMER: {
+    name: "THREE_WINDINGS_TRANSFORMER",
+    tagLabel: "equipment_search/3wtTag"
+  },
+  HVDC_LINE: {
+    name: "HVDC_LINE",
+    tagLabel: "equipment_search/hvdcLineTag"
+  },
+  GENERATOR: {
+    name: "GENERATOR",
+    tagLabel: "equipment_search/generatorTag"
+  },
+  BATTERY: {
+    name: "BATTERY",
+    tagLabel: "equipment_search/batteryTag"
+  },
+  LOAD: {
+    name: "LOAD",
+    tagLabel: "equipment_search/loadTag"
+  },
+  SHUNT_COMPENSATOR: {
+    name: "SHUNT_COMPENSATOR",
+    tagLabel: "equipment_search/shuntTag"
+  },
+  DANGLING_LINE: {
+    name: "DANGLING_LINE",
+    tagLabel: "equipment_search/lineTag"
+  },
+  STATIC_VAR_COMPENSATOR: {
+    name: "STATIC_VAR_COMPENSATOR",
+    tagLabel: "equipment_search/svcTag"
+  },
+  HVDC_CONVERTER_STATION: {
+    name: "HVDC_CONVERTER_STATION",
+    tagLabel: "equipment_search/hvdcStationTag"
+  },
+  BUSBAR_SECTION: {
+    name: "BUSBAR_SECTION",
+    tagLabel: "equipment_search/busbarSectionTag"
+  },
+  BUS: {
+    name: "BUS",
+    tagLabel: "equipment_search/busTag"
+  },
+  SWITCH: {
+    name: "SWITCH",
+    tagLabel: "equipment_search/switchTag"
+  }
+};
+const getEquipmentsInfosForSearchBar = (equipmentsInfos, getNameOrId) => {
+  return equipmentsInfos.flatMap((e) => {
+    let label = getNameOrId(e);
+    return e.type === "SUBSTATION" ? [
+      {
+        label,
+        id: e.id,
+        key: e.id,
+        type: e.type
+      }
+    ] : e.voltageLevels.map((vli) => {
+      return {
+        label,
+        id: e.id,
+        key: e.id + "_" + vli.id,
+        type: e.type,
+        voltageLevelLabel: getNameOrId(vli),
+        voltageLevelId: vli.id
+      };
+    });
+  });
+};
+export {
+  EQUIPMENT_TYPE,
+  TYPE_TAG_MAX_SIZE,
+  VL_TAG_MAX_SIZE,
+  equipmentStyles,
+  getEquipmentsInfosForSearchBar
+};

package/dist/utils/UserManagerMock.d.ts

@@ -0,0 +1,34 @@
+export class UserManagerMock {
+    constructor(settings: any);
+    settings: any;
+    events: Events;
+    user: {
+        profile: {
+            name: string;
+            email: string;
+        };
+        id_token: string;
+        session_state: string;
+        access_token: string;
+        token_type: string;
+        scope: string;
+    };
+    getUser(): Promise<any>;
+    signinSilent(): Promise<any>;
+    signinSilentCallback(): Promise<never>;
+    signinRedirect(): Promise<null>;
+    signoutRedirect(): Promise<null>;
+    signinRedirectCallback(): Promise<string>;
+}
+/**
+ * Copyright (c) 2020, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+declare class Events {
+    userLoadedCallbacks: any[];
+    addUserLoaded(callback: any): void;
+    addSilentRenewError(callback: any): void;
+}
+export {};