@frontegg/rest-api 6.0.1-alpha.4 → 7.28.0-alpha.0

package/FetchClient.js

@@ -0,0 +1,260 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { ContextHolder } from './ContextHolder';
+import { FronteggApiError } from './error';
+import { GENERIC_ERROR_MESSAGE } from './constants';
+import { fronteggHeaders } from './interfaces';
+
+/**
+ * FetchClient is a class that wrap around the fetch API to make requests.
+ * It is used by the BaseApiClient to make requests to the server
+ */
+export class FetchClient {
+  constructor(appName) {
+    this.appName = void 0;
+    this.getFronteggContext = () => {
+      return ContextHolder.for(this.appName);
+    };
+    this.prepareUrl = async (url, params) => {
+      const context = this.getFronteggContext().getContext();
+      const baseUrl = this.getContextBaseUrl(url);
+      const paramsToSend = await this.buildQueryParams(context, params);
+      let finalUrl = url.startsWith('http') ? url : `${baseUrl}${url}`;
+      const hasKeys = Object.keys(paramsToSend).length > 0;
+      if (paramsToSend && hasKeys) {
+        const urlParams = new URLSearchParams(paramsToSend);
+        finalUrl += `?${urlParams}`;
+      }
+      return finalUrl;
+    };
+    this.buildQueryParams = async (context, params) => {
+      if (!params) {
+        params = {};
+      }
+      const additionalQueryParams = await this.getAdditionalQueryParams(context);
+      for (const queryParam of additionalQueryParams) {
+        params[queryParam.key] = queryParam.value;
+      }
+      const keys = Object.keys(params);
+      for (const key of keys) {
+        const value = params[key];
+        params[key] = typeof value === 'object' ? JSON.stringify(value) : value;
+      }
+      return params;
+    };
+    this.getAdditionalQueryParams = async context => {
+      let output = [];
+      if (context.additionalQueryParamsResolver) {
+        output = await context.additionalQueryParamsResolver();
+      }
+      return output;
+    };
+    this.getAdditionalHeaders = async context => {
+      let output = [];
+      if (context.additionalHeadersResolver) {
+        output = await context.additionalHeadersResolver();
+      }
+      if (context.tenantResolver) {
+        const resolvedTenantResult = await context.tenantResolver();
+        if (!!(resolvedTenantResult != null && resolvedTenantResult.tenant)) {
+          output.push({
+            key: 'frontegg-login-alias',
+            value: resolvedTenantResult.tenant
+          });
+        }
+      }
+      if (context.appId) {
+        output.push({
+          key: 'frontegg-requested-application-id',
+          value: context.appId
+        });
+      }
+      return output;
+    };
+    this.buildRequestHeaders = async contentType => {
+      var _context$tokenResolve;
+      const fronteggContext = this.getFronteggContext();
+      const context = fronteggContext.getContext();
+      const headers = FetchClient.getMetadataHeaders(context);
+      const authToken = await ((_context$tokenResolve = context == null ? void 0 : context.tokenResolver) != null ? _context$tokenResolve : fronteggContext.getAccessToken)();
+      const requestSource = fronteggContext.getRequestSource();
+      const scopedTenant = FetchClient.getScopedTenant();
+      if (contentType) {
+        headers[fronteggHeaders.contentType] = contentType;
+      }
+      if (requestSource) {
+        headers[fronteggHeaders.source] = requestSource;
+      }
+      if (authToken) {
+        headers.Authorization = `Bearer ${authToken}`;
+      }
+      if (scopedTenant) {
+        headers[fronteggHeaders.scopedTenant] = scopedTenant;
+      }
+      for (const additionalHeader of await this.getAdditionalHeaders(context)) {
+        headers[`${additionalHeader.key}`] = `${additionalHeader.value}`;
+      }
+      return headers;
+    };
+    this.sendRequest = async opts => {
+      var _opts$method, _ref, _opts$credentials;
+      const context = this.getFronteggContext().getContext();
+      const headers = await this.buildRequestHeaders(opts.contentType);
+      const url = await this.prepareUrl(opts.url, opts.params);
+      const interceptor = context.beforeRequestInterceptor;
+      const initialRequestOptions = {
+        body: opts.body ? opts.contentType === 'application/json' ? JSON.stringify(opts.body) : opts.body : null,
+        method: (_opts$method = opts.method) != null ? _opts$method : 'GET',
+        headers: _extends({}, headers, opts.headers),
+        credentials: (_ref = (_opts$credentials = opts.credentials) != null ? _opts$credentials : context.requestCredentials) != null ? _ref : 'same-origin'
+      };
+      const requestOptions = interceptor ? interceptor(initialRequestOptions, url) : initialRequestOptions;
+      const response = await fetch(url, requestOptions);
+      if (response.status === 302) {
+        window.location.href = await response.text();
+        return new Promise(() => {});
+      }
+      if (!response.ok) {
+        var _context$logLevel, _context$logLevel2;
+        if (response.status === 413) {
+          throw new FronteggApiError('Error request is too large', response.status);
+        }
+        let errorMessage;
+        let isJsonResponse = true;
+        try {
+          errorMessage = await response.text();
+          errorMessage = JSON.parse(errorMessage);
+        } catch (e) {
+          isJsonResponse = false;
+        }
+        if (errorMessage.errors) {
+          errorMessage = errorMessage.errors.join(', ');
+        } else if (typeof errorMessage !== 'string') {
+          errorMessage = `Error ${response.status} - ${response.statusText}`;
+        }
+        if (response.status >= 400 && response.status < 500 && ['warn'].includes((_context$logLevel = context.logLevel) != null ? _context$logLevel : '')) console.warn(errorMessage);else if (response.status === 500 && ['warn', 'error'].includes((_context$logLevel2 = context.logLevel) != null ? _context$logLevel2 : '')) console.error(errorMessage);
+        throw new FronteggApiError(isJsonResponse ? errorMessage : GENERIC_ERROR_MESSAGE, response.status);
+      }
+      if (opts.responseType === 'stream') {
+        return response.body;
+      }
+      if (!opts.responseType || opts.responseType === 'json') {
+        try {
+          return await response.json();
+        } catch (e) {
+          return {};
+        }
+      } else if (opts.responseType === 'blob') {
+        const {
+          outputFileName
+        } = opts.params;
+        return await response.blob().then(blob => URL.createObjectURL(blob)).then(url => {
+          const tempLink = document.createElement('a');
+          tempLink.href = url;
+          tempLink.setAttribute('download', outputFileName || 'output');
+          tempLink.click();
+        });
+      } else {
+        return await response.text();
+      }
+    };
+    this.get = async (url, params, opts) => this.sendRequest(_extends({
+      url,
+      method: 'GET',
+      contentType: 'application/json',
+      params
+    }, opts));
+    this.post = async (url, body, opts) => this.sendRequest(_extends({
+      url,
+      method: 'POST',
+      contentType: 'application/json',
+      body
+    }, opts));
+    this.patch = async (url, body, opts) => this.sendRequest(_extends({
+      url,
+      method: 'PATCH',
+      contentType: 'application/json',
+      body
+    }, opts));
+    this.put = async (url, body, opts) => this.sendRequest(_extends({
+      url,
+      method: 'PUT',
+      contentType: 'application/json',
+      body
+    }, opts));
+    this.delete = async (url, body, opts) => this.sendRequest(_extends({
+      url,
+      method: 'DELETE',
+      contentType: 'application/json',
+      body
+    }, opts));
+    this.postDownload = async (url, body, params, opts) => this.sendRequest(_extends({
+      url,
+      method: 'POST',
+      contentType: 'application/json',
+      responseType: 'blob',
+      body,
+      params
+    }, opts));
+    this.extractHeadersFromOptions = (options = {}) => _extends({}, options.jwt ? {
+      Authorization: options.jwt
+    } : {});
+    this.getBaseUrl = (context, url, withFronteggPrefix = true) => {
+      return FetchClient.getBaseUrl(context, url, withFronteggPrefix);
+    };
+    this.getContextBaseUrl = (url, withFronteggPrefix = true) => {
+      const context = this.getFronteggContext().getContext();
+      return this.getBaseUrl(context, url, withFronteggPrefix);
+    };
+    this.getMetadataHeaders = context => {
+      return FetchClient.getMetadataHeaders(context);
+    };
+    this.getContextMetadataHeaders = () => {
+      const context = this.getFronteggContext().getContext();
+      return FetchClient.getMetadataHeaders(context);
+    };
+    this.appName = appName;
+  }
+}
+
+/**
+ * import FetchClient and use it to make requests to the server for specific application
+ * @param appName - the application name to make requests for
+ * @deprecated - use FetchClient directly
+ */
+FetchClient.getBaseUrl = (context, url, withFronteggPrefix = true) => {
+  let baseUrl;
+  if (typeof context.baseUrl === 'function') {
+    baseUrl = context.baseUrl(url);
+  } else {
+    baseUrl = context.baseUrl;
+  }
+  const prefix = context.urlPrefix || 'frontegg';
+  const removePrefix = prefix === 'frontegg' && !withFronteggPrefix;
+  if (!baseUrl.endsWith('/')) {
+    baseUrl += '/';
+  }
+  if (!baseUrl.endsWith(prefix) && !removePrefix) {
+    baseUrl += prefix;
+  }
+  return baseUrl;
+};
+FetchClient.getMetadataHeaders = context => {
+  var _context$metadataHead, _context$metadataHead2;
+  const headers = {};
+  if (context != null && (_context$metadataHead = context.metadataHeaders) != null && _context$metadataHead.fronteggSdkVersion) {
+    headers[fronteggHeaders.fronteggSdkVersion] = context.metadataHeaders.fronteggSdkVersion;
+  }
+  if (context != null && (_context$metadataHead2 = context.metadataHeaders) != null && _context$metadataHead2.framework) {
+    headers[fronteggHeaders.frameWork] = context.metadataHeaders.framework;
+  }
+  return headers;
+};
+FetchClient.getScopedTenant = () => {
+  const urlParams = new URLSearchParams(window.location.search);
+  const scopedTenant = urlParams.get('tenantId');
+  if (scopedTenant) {
+    return scopedTenant;
+  }
+  return null;
+};
+export default new FetchClient('default');

package/account-settings/index.d.ts

@@ -1,7 +1,21 @@
-import { ISettingsResponse, IUpdateSettings } from './interfaces';
-/*** update account settings for tenant.
- * tenantId is caclulated in the backend from context
- * ``authorized user``
- */
-export declare function updateSettings(body: IUpdateSettings): Promise<ISettingsResponse>;
-export declare function getSettings(): Promise<ISettingsResponse>;
+import { IPublicSettingsResponse, ISettingsResponse, IUpdateSettings } from './interfaces';
+import { UserJwtOptions } from '../interfaces';
+import { BaseApiClient } from '../BaseApiClient';
+export declare class AccountSettingsApi extends BaseApiClient {
+    constructor(appName: string);
+    /**
+     * Update account settings for a tenant.
+     * TenantId is calculated in the backend from context of the `authorized user`.
+     */
+    updateSettings: (body: IUpdateSettings, options?: UserJwtOptions) => Promise<ISettingsResponse>;
+    /**
+     * Get account settings for a tenant.
+     */
+    getSettings: (options?: UserJwtOptions) => Promise<ISettingsResponse>;
+    /**
+     * Get public account settings.
+     */
+    getPublicSettings: () => Promise<IPublicSettingsResponse>;
+}
+declare const _default: AccountSettingsApi;
+export default _default;

package/account-settings/index.js

@@ -1,8 +1,27 @@
 import { urls } from '../constants';
-import { Put, Get } from '../fetch';
-export async function updateSettings(body) {
-  return Put(urls.tenants.accountSettings.v1, body);
+import { BaseApiClient } from '../BaseApiClient';
+export class AccountSettingsApi extends BaseApiClient {
+  constructor(appName) {
+    super(appName);
+    this.updateSettings = async (body, options) => {
+      return this.put(urls.tenants.accountSettings.v1, body, {
+        headers: this.extractHeadersFromOptions(options)
+      });
+    };
+    this.getSettings = async options => {
+      return this.get(urls.tenants.accountSettings.v1, undefined, {
+        headers: this.extractHeadersFromOptions(options)
+      });
+    };
+    this.getPublicSettings = async () => {
+      return this.get(`${urls.tenants.accountSettings.v1}/public`);
+    };
+  }
+
+  /**
+   * Update account settings for a tenant.
+   * TenantId is calculated in the backend from context of the `authorized user`.
+   */
 }
-export async function getSettings() {
-  return Get(urls.tenants.accountSettings.v1);
-}
+
+export default new AccountSettingsApi('default');

package/account-settings/interfaces.d.ts

@@ -1,4 +1,4 @@
-export interface ISettingsResponse {
+export interface ISettingsResponse extends Partial<IPublicSettingsResponse> {
     address?: string;
     timezone?: string;
     dateFormat?: string;
@@ -6,4 +6,11 @@ export interface ISettingsResponse {
     currency?: string;
     logo?: string;
 }
-export declare type IUpdateSettings = Partial<ISettingsResponse>;
+export interface IPublicSettingsResponse {
+    tenantId: string;
+    applicationUrl?: string;
+    loginUrl?: string;
+}
+export interface IUpdateSettings extends ISettingsResponse {
+    name?: string;
+}

package/applications/index.d.ts

@@ -0,0 +1,51 @@
+import { BaseApiClient } from '../BaseApiClient';
+import { IUserApplicationsIdPayload, IUserApplicationsDataPayload, IApplicationsResponse, IAssignUserToApplicationsBody, IUsersApplicationsIdPayload, IUsersOfApplicationsResponse, ITenantApplicationsResponse, IGetUsersOfApplicationsQuery, IUsersApplicationsIdsResponse } from './interfaces';
+/**
+ * UsersApplicationsApi class for handling applications-related operations.
+ */
+export declare class ApplicationsApi extends BaseApiClient {
+    constructor(appName: string);
+    /**
+     * Get applications id array for a single user by user id.
+     * @param {IUserApplicationsIdPayload} param0 - user id to find their applications id array.
+     * @returns {Promise<string[]>} all app ids as string[].
+     */
+    getUserApplicationsId: ({ userId }: IUserApplicationsIdPayload) => Promise<string[]>;
+    /**
+     * Get applications id array for multiple users by user id array.
+     * @param {IUsersApplicationsIdPayload} param0 - array of all user ids.
+     * @returns {Promise<IUsersApplicationsIdsResponse[]>} object that maps every user id to its applications id array.
+     */
+    getUsersApplicationsId: ({ userIds, }: IUsersApplicationsIdPayload) => Promise<IUsersApplicationsIdsResponse[]>;
+    /**
+     * Get applications data array for a specific tenant.
+     * @returns {Promise<ITenantApplicationsResponse[]>} array of objects with tenant id and its applications id array.
+     */
+    getTenantsApplications: () => Promise<ITenantApplicationsResponse[]>;
+    /**
+     * Get applications data by array of application ids.
+     * @param {IUserApplicationsDataPayload} param0 - array of application ids.
+     * @returns {Promise<IApplicationsResponse[]>} array of application data.
+     */
+    getApplicationsData: ({ appIds, includeFreeAccess, }: IUserApplicationsDataPayload) => Promise<IApplicationsResponse[]>;
+    /**
+     * Assign user to multiple applications.
+     * @param {IAssignUserToApplicationsBody} body - assignment details.
+     * @returns {Promise<void>}
+     */
+    assignUserToApplications: (body: IAssignUserToApplicationsBody) => Promise<void>;
+    /**
+     * Unassign user from multiple applications.
+     * @param {IAssignUserToApplicationsBody} body - unassignment details.
+     * @returns {Promise<void>}
+     */
+    unassignUserFromApplications: (body: IAssignUserToApplicationsBody) => Promise<void>;
+    /**
+     * Get users array for each application for an array of applications.
+     * @param {IGetUsersOfApplicationsQuery} param0 - array of applications.
+     * @returns {Promise<IUsersOfApplicationsResponse[]>} array of objects with application id and its users array.
+     */
+    getUsersOfApplications: ({ appIds, }: IGetUsersOfApplicationsQuery) => Promise<IUsersOfApplicationsResponse[]>;
+}
+declare const _default: ApplicationsApi;
+export default _default;

package/applications/index.js

@@ -0,0 +1,55 @@
+import { urls } from '../constants';
+import { BaseApiClient } from '../BaseApiClient';
+/**
+ * UsersApplicationsApi class for handling applications-related operations.
+ */
+export class ApplicationsApi extends BaseApiClient {
+  constructor(appName) {
+    super(appName);
+    this.getUserApplicationsId = async ({
+      userId
+    }) => {
+      return this.get(`${urls.identity.applications.v1}/${userId}/apps`);
+    };
+    this.getUsersApplicationsId = async ({
+      userIds
+    }) => {
+      return this.get(`${urls.identity.applications.v1}/users-apps`, {
+        userIds: userIds.join(',')
+      });
+    };
+    this.getTenantsApplications = async () => {
+      return this.get(urls.applications.tenant.v1);
+    };
+    this.getApplicationsData = async ({
+      appIds,
+      includeFreeAccess = true
+    }) => {
+      return this.get(urls.applications.v1, {
+        ids: appIds.join(','),
+        _includeFreeAccess: includeFreeAccess
+      });
+    };
+    this.assignUserToApplications = async body => {
+      return this.post(`${urls.identity.applications.v1}/apps-user`, body);
+    };
+    this.unassignUserFromApplications = async body => {
+      return this.delete(`${urls.identity.applications.v1}/user-apps`, body);
+    };
+    this.getUsersOfApplications = async ({
+      appIds
+    }) => {
+      return this.get(`${urls.identity.applications.v1}/apps-users`, {
+        appIds: appIds.join(',')
+      });
+    };
+  }
+
+  /**
+   * Get applications id array for a single user by user id.
+   * @param {IUserApplicationsIdPayload} param0 - user id to find their applications id array.
+   * @returns {Promise<string[]>} all app ids as string[].
+   */
+}
+
+export default new ApplicationsApi('default');

package/applications/interfaces.d.ts

@@ -0,0 +1,49 @@
+export type IUserApplicationsIdPayload = {
+    userId: string;
+};
+export type IUsersApplicationsIdPayload = {
+    userIds: string[];
+};
+export type IGetUsersOfApplicationsQuery = {
+    appIds: string[];
+};
+export type IUserApplicationsDataPayload = IGetUsersOfApplicationsQuery & {
+    includeFreeAccess?: boolean;
+};
+export type IUsersOfApplicationsResponse = {
+    appId: string;
+    userIds: string[];
+};
+export type IAssignUserToApplicationsBody = {
+    userId: string;
+    tenantId: string;
+    appIds: string[];
+};
+export declare enum ApplicationAccessType {
+    FREE_ACCESS = "FREE_ACCESS",
+    MANAGED_ACCESS = "MANAGED_ACCESS"
+}
+export type IApplicationsResponse = {
+    id: string;
+    accessType: ApplicationAccessType;
+    appURL: string;
+    loginURL: string;
+    isDefault: boolean;
+    isActive: boolean;
+    name: string;
+    logoURL: string;
+    createdAt: string;
+    updatedAt: string;
+    type: string;
+    frontendStack: string;
+    description: string;
+    integrationFinishedAt: string;
+};
+export type ITenantApplicationsResponse = {
+    tenantId: string;
+    appIds?: string[];
+};
+export type IUsersApplicationsIdsResponse = {
+    userId: string;
+    appIds: string[];
+};

package/applications/interfaces.js

@@ -0,0 +1,5 @@
+export let ApplicationAccessType;
+(function (ApplicationAccessType) {
+  ApplicationAccessType["FREE_ACCESS"] = "FREE_ACCESS";
+  ApplicationAccessType["MANAGED_ACCESS"] = "MANAGED_ACCESS";
+})(ApplicationAccessType || (ApplicationAccessType = {}));

package/applications/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/applications/index.js",
+  "types": "./index.d.ts"
+}

package/audits/index.d.ts

@@ -1,16 +1,28 @@
 import { IAudits, IAuditsStats, IGetAuditsParams, IGetAuditsStatsParams, IExportAudits } from './interfaces';
-/*****************************************
- * Audits Api
- *****************************************/
-/**
- * get Audits
- */
-export declare function getAudits(params: IGetAuditsParams): Promise<IAudits>;
-/**
- * get Audits Stats
- */
-export declare function getAuditsStats(params: IGetAuditsStatsParams): Promise<IAuditsStats>;
-/**
- * export Audits
- */
-export declare function exportAudits(params: IExportAudits): Promise<any>;
+import { BaseApiClient } from '../BaseApiClient';
+export declare class AuditsApi extends BaseApiClient {
+    constructor(appName: string);
+    /**
+     * Fetches audit logs based on the provided parameters.
+     *
+     * @param params - Parameters to filter and paginate audits.
+     * @returns A promise that resolves to the list of audits.
+     */
+    getAudits: (params: IGetAuditsParams) => Promise<IAudits>;
+    /**
+     * Retrieves audit statistics based on the provided parameters.
+     *
+     * @param params - Parameters to filter and define the scope of the stats.
+     * @returns A promise that resolves to the audits statistics.
+     */
+    getAuditsStats: (params: IGetAuditsStatsParams) => Promise<IAuditsStats>;
+    /**
+     * Exports audit logs based on the provided parameters.
+     *
+     * @param params - Parameters including endpoint, header properties, and other request specifics.
+     * @returns A promise that initiates a download for the exported audits.
+     */
+    exportAudits: (params: IExportAudits) => Promise<void>;
+}
+declare const _default: AuditsApi;
+export default _default;

package/audits/index.js

@@ -1,21 +1,34 @@
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
 const _excluded = ["endpoint", "headerProps"];
-import { Get, PostDownload } from '../fetch';
 import { urls } from '../constants';
-export async function getAudits(params) {
-  return Get(urls.audits.v1, params);
-}
-export async function getAuditsStats(params) {
-  return Get(`${urls.audits.v1}/stats`, params);
-}
-export async function exportAudits(params) {
-  const {
-    endpoint,
-    headerProps
-  } = params,
+import { BaseApiClient } from '../BaseApiClient';
+export class AuditsApi extends BaseApiClient {
+  constructor(appName) {
+    super(appName);
+    this.getAudits = async params => {
+      return this.get(urls.audits.v1, params);
+    };
+    this.getAuditsStats = async params => {
+      return this.get(`${urls.audits.v1}/stats`, params);
+    };
+    this.exportAudits = async params => {
+      const {
+          endpoint,
+          headerProps
+        } = params,
         restParams = _objectWithoutPropertiesLoose(params, _excluded);
+      return this.postDownload(`${urls.audits.v1}/export/${endpoint}`, {
+        properties: headerProps
+      }, restParams);
+    };
+  }
+
+  /**
+   * Fetches audit logs based on the provided parameters.
+   *
+   * @param params - Parameters to filter and paginate audits.
+   * @returns A promise that resolves to the list of audits.
+   */
+}
 
-  return PostDownload(`${urls.audits.v1}/export/${endpoint}`, {
-    properties: headerProps
-  }, restParams);
-}
+export default new AuditsApi('default');

package/audits/interfaces.d.ts

@@ -1,4 +1,4 @@
-export declare type SortDirectionType = 'asc' | 'desc';
+export type SortDirectionType = 'asc' | 'desc';
 export interface AuditRowData {
     _id: string;
     ip: string;
@@ -13,6 +13,7 @@ export interface AuditRowData {
     tenantId: string;
     createdAt: string;
     updatedAt: string;
+    actorMail?: string;
     __v: number;
 }
 export interface IGetAuditsParams {
@@ -36,7 +37,7 @@ export interface IAuditsStats {
     totalToday: number;
     severeThisWeek: number;
 }
-export declare type TExportAudits = 'csv' | 'pdf' | 'csv/v2';
+export type TExportAudits = 'csv' | 'pdf' | 'csv/v2';
 export interface IExportAudits {
     headerProps: HeaderProps[];
     sortDirection: SortDirectionType;

package/auth/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const FRONTEGG_SEPARATE_TABS_BY_TENANT = "FRONTEGG_SEPARATE_TABS_BY_TENANT";
+/**
+ * use current user tenant v1 feature flag
+ */
+export declare const USE_CURRENT_USER_TENANTS_V1_ENDPOINT_FF = "admin_portal_use_current_user_tenants_v1_endpoint";

package/auth/constants.js

@@ -0,0 +1,5 @@
+export const FRONTEGG_SEPARATE_TABS_BY_TENANT = 'FRONTEGG_SEPARATE_TABS_BY_TENANT';
+/**
+ * use current user tenant v1 feature flag
+ */
+export const USE_CURRENT_USER_TENANTS_V1_ENDPOINT_FF = 'admin_portal_use_current_user_tenants_v1_endpoint';

package/auth/enums.d.ts

@@ -2,7 +2,10 @@ export declare enum SocialLoginProviders {
     Microsoft = "microsoft",
     Facebook = "facebook",
     Google = "google",
-    Github = "github"
+    Github = "github",
+    Slack = "slack",
+    Apple = "apple",
+    Linkedin = "linkedin"
 }
 export declare enum AuthStrategyEnum {
     EmailAndPassword = "EmailAndPassword",
@@ -11,3 +14,7 @@ export declare enum AuthStrategyEnum {
     NoLocalAuthentication = "NoLocalAuthentication",
     SmsCode = "SmsCode"
 }
+export declare enum MachineToMachineAuthStrategy {
+    ClientCredentials = "ClientCredentials",
+    AccessToken = "AccessToken"
+}