Web element CDK and views

web_apps_src/identifo.js/dist/IdentifoAuth.d.ts

@@ -0,0 +1,24 @@
+import { API } from './api/api';
+import TokenService from './tokenService';
+import { ClientToken, IdentifoConfig, UrlBuilderInit } from './types/types';
+declare class IdentifoAuth {
+    api: API;
+    tokenService: TokenService;
+    config: IdentifoConfig;
+    urlBuilder: UrlBuilderInit;
+    private token;
+    isAuth: boolean;
+    constructor(config?: IdentifoConfig);
+    configure(config: IdentifoConfig): void;
+    private handleToken;
+    private resetAuthValues;
+    signup(): void;
+    signin(): void;
+    logout(): void;
+    handleAuthentication(): Promise<boolean>;
+    private getTokenFromUrl;
+    getToken(): Promise<ClientToken | null>;
+    renewSession(): Promise<string>;
+    private renewSessionWithToken;
+}
+export default IdentifoAuth;

web_apps_src/identifo.js/dist/UrlBuilder.d.ts

@@ -0,0 +1,10 @@
+import { IdentifoConfig, UrlFlows } from './types/types';
+export declare class UrlBuilder {
+    private config;
+    constructor(config: IdentifoConfig);
+    getUrl(flow: UrlFlows): string;
+    createSignupUrl(): string;
+    createSigninUrl(): string;
+    createLogoutUrl(): string;
+    createRenewSessionUrl(): string;
+}

web_apps_src/identifo.js/dist/api/api.d.ts

@@ -0,0 +1,39 @@
+import TokenService from '../tokenService';
+import { IdentifoConfig } from '../types/types';
+import { AppSettingsResponse, EnableTFAResponse, LoginResponse, SuccessResponse, UpdateUser, User, FederatedLoginProvider, TokenResponse, TFARequiredRespopnse } from './model';
+export declare class API {
+    private config;
+    private tokenService;
+    baseUrl: string;
+    appId: string;
+    defaultHeaders: {
+        "X-Identifo-Clientid": string;
+        Accept: string;
+        'Content-Type': string;
+    };
+    catchNetworkErrorHandler: (e: TypeError) => never;
+    checkStatusCodeAndGetJSON: (r: Response) => Promise<any>;
+    constructor(config: IdentifoConfig, tokenService: TokenService);
+    get<T>(path: string, options?: RequestInit): Promise<T>;
+    put<T>(path: string, data: unknown, options?: RequestInit): Promise<T>;
+    post<T>(path: string, data: unknown, options?: RequestInit): Promise<T>;
+    send<T>(path: string, options?: RequestInit): Promise<T>;
+    getUser(): Promise<User>;
+    renewToken(): Promise<LoginResponse>;
+    updateUser(user: UpdateUser): Promise<User>;
+    login(email: string, password: string, deviceToken: string, scopes: string[]): Promise<LoginResponse>;
+    federatedLogin(provider: FederatedLoginProvider, scopes: string[], redirectUrl: string, callbackUrl?: string, opts?: {
+        width?: number;
+        height?: number;
+        popUp?: boolean;
+    }): Promise<void>;
+    federatedLoginComplete(params: URLSearchParams): Promise<LoginResponse>;
+    register(email: string, password: string, scopes: string[]): Promise<LoginResponse>;
+    requestResetPassword(email: string, tfaCode?: string): Promise<SuccessResponse | TFARequiredRespopnse>;
+    resetPassword(password: string): Promise<SuccessResponse>;
+    getAppSettings(callbackUrl: string): Promise<AppSettingsResponse>;
+    enableTFA(): Promise<EnableTFAResponse>;
+    verifyTFA(code: string, scopes: string[]): Promise<LoginResponse>;
+    logout(): Promise<SuccessResponse>;
+    storeToken<T extends TokenResponse>(response: T): T;
+}

web_apps_src/identifo.js/dist/api/model.d.ts

@@ -0,0 +1,96 @@
+export declare enum APIErrorCodes {
+    PleaseEnableTFA = "error.api.request.2fa.please_enable",
+    InvalidCallbackURL = "error.api.request.callbackurl.invalid",
+    NetworkError = "error.network"
+}
+export declare enum TFAType {
+    TFATypeApp = "app",
+    TFATypeSMS = "sms",
+    TFATypeEmail = "email"
+}
+export declare enum TFAStatus {
+    DISABLED = "disabled",
+    OPTIONAL = "optional",
+    MANDATORY = "mandatory"
+}
+export interface ApiRequestError {
+    error: {
+        detailed_message?: string;
+        id?: APIErrorCodes;
+        message?: string;
+        status?: number;
+    };
+}
+export declare class ApiError extends Error {
+    detailedMessage?: string;
+    id?: APIErrorCodes;
+    status?: number;
+    constructor(error?: ApiRequestError['error']);
+}
+export interface LoginResponse {
+    access_token?: string;
+    refresh_token?: string;
+    require_2fa: boolean;
+    enabled_2fa: boolean;
+    user: {
+        active: boolean;
+        email?: string;
+        id: string;
+        latest_login_time: number;
+        num_of_logins: number;
+        username?: string;
+        tfa_info: {
+            hotp_expired_at: string;
+        };
+        phone?: string;
+    };
+    scopes?: string[];
+    callbackUrl?: string;
+}
+export interface EnableTFAResponse {
+    provisioning_uri?: string;
+    provisioning_qr?: string;
+    access_token?: string;
+}
+export interface TokenResponse {
+    access_token?: string;
+    refresh_token?: string;
+}
+export interface AppSettingsResponse {
+    anonymousResitrationAllowed: boolean;
+    active: boolean;
+    description: string;
+    id: string;
+    newUserDefaultRole: string;
+    offline: boolean;
+    registrationForbidden: boolean;
+    tfaType: TFAType;
+    tfaStatus: TFAStatus;
+    federatedProviders: FederatedLoginProvider[];
+}
+export interface User {
+    id: string;
+    username: string;
+    email: string;
+    phone: string;
+    active: boolean;
+    tfa_info: {
+        is_enabled: boolean;
+    };
+    num_of_logins: number;
+    latest_login_time: number;
+    access_role: string;
+    anonymous: boolean;
+    federated_ids: string[];
+}
+export interface UpdateUser {
+    new_email?: string;
+    new_phone?: string;
+}
+export interface SuccessResponse {
+    result: 'ok';
+}
+export interface TFARequiredRespopnse {
+    result: 'tfa-required';
+}
+export declare type FederatedLoginProvider = 'apple' | 'google' | 'facebook';

web_apps_src/identifo.js/dist/cdk/cdk.d.ts

@@ -0,0 +1,12 @@
+import { BehaviorSubject } from 'rxjs';
+import IdentifoAuth from '../IdentifoAuth';
+import { IdentifoConfig } from '../types/types';
+import { StateLogin, States } from './model';
+export declare class CDK {
+    auth: IdentifoAuth;
+    states: {
+        login: StateLogin;
+    };
+    state: BehaviorSubject<States>;
+    constructor(authConfig?: IdentifoConfig);
+}

web_apps_src/identifo.js/dist/cdk/model.d.ts

@@ -0,0 +1,52 @@
+import { ApiError, FederatedLoginProvider } from '../api/model';
+export declare enum Routes {
+    'LOGIN' = "login",
+    'REGISTER' = "register",
+    'TFA_VERIFY_SMS' = "tfa/verify/sms",
+    'TFA_VERIFY_EMAIL' = "tfa/verify/email",
+    'TFA_VERIFY_APP' = "tfa/verify/app",
+    'TFA_VERIFY_SELECT' = "tfa/verify/select",
+    'TFA_SETUP_SMS' = "tfa/setup/sms",
+    'TFA_SETUP_EMAIL' = "tfa/setup/email",
+    'TFA_SETUP_APP' = "tfa/setup/app",
+    'TFA_SETUP_SELECT' = "tfa/setup/select",
+    'PASSWORD_RESET' = "password/reset",
+    'PASSWORD_FORGOT' = "password/forgot",
+    'PASSWORD_FORGOT_TFA_SMS' = "password/forgot/tfa/sms",
+    'PASSWORD_FORGOT_TFA_EMAIL' = "password/forgot/tfa/email",
+    'PASSWORD_FORGOT_TFA_APP' = "password/forgot/tfa/app",
+    'PASSWORD_FORGOT_TFA_SELECT' = "password/forgot/tfa/select",
+    'CALLBACK' = "callback",
+    'OTP_LOGIN' = "otp/login",
+    'ERROR' = "error",
+    'PASSWORD_FORGOT_SUCCESS' = "password/forgot/success",
+    'LOGOUT' = "logout",
+    'LOADING' = "loading"
+}
+export declare type TFASetupRoutes = Routes.TFA_SETUP_SELECT | 'TFA_SETUP_SMS' | 'TFA_SETUP_EMAIL' | 'TFA_SETUP_APP';
+export declare type TFALoginVerifyRoutes = 'TFA_VERIFY_SELECT' | 'TFA_VERIFY_SMS' | 'TFA_VERIFY_EMAIL' | 'TFA_VERIFY_APP';
+export declare type TFAResetVerifyRoutes = 'PASSWORD_FORGOT_TFA_SELECT' | 'PASSWORD_FORGOT_TFA_SMS' | 'PASSWORD_FORGOT_TFA_EMAIL' | 'PASSWORD_FORGOT_TFA_APP';
+export interface State {
+    route: Routes;
+}
+export interface StateLogin extends State {
+    route: Routes.LOGIN;
+    registrationForbidden: boolean;
+    lastError: ApiError;
+    federatedProviders: FederatedLoginProvider[];
+    signup: () => void;
+    signin: () => void;
+    socialLogin: (provider: FederatedLoginProvider) => void;
+    passwordForgot: () => void;
+}
+export interface StateRegister extends State {
+    route: Routes.REGISTER;
+    registrationForbidden: boolean;
+    lastError: ApiError;
+    federatedProviders: FederatedLoginProvider[];
+    signup: () => void;
+    signin: () => void;
+    socialLogin: (provider: FederatedLoginProvider) => void;
+    passwordForgot: () => void;
+}
+export declare type States = StateLogin | StateRegister;

web_apps_src/identifo.js/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const jwtRegex: RegExp;
+export declare const INVALID_TOKEN_ERROR = "Empty or invalid token";
+export declare const TOKEN_QUERY_KEY = "token";
+export declare const REFRESH_TOKEN_QUERY_KEY = "refresh_token";