@ksremp/ngx-ksremp-app-lib 1.0.0

package/esm2022/lib/guards/auth.guard.mjs

@@ -0,0 +1,138 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/storage-angular";
+import * as i2 from "@angular/router";
+import * as i3 from "../services/login/login.service";
+import * as i4 from "@ionic/angular";
+import * as i5 from "../services/util/util.service";
+import * as i6 from "../services/logger/logger.service";
+export class AuthGuard {
+    constructor(storage, router, ls, ar, nav, util, logger) {
+        this.storage = storage;
+        this.router = router;
+        this.ls = ls;
+        this.ar = ar;
+        this.nav = nav;
+        this.util = util;
+        this.logger = logger;
+    }
+    async canActivate(route, state) {
+        this.util.showLoader();
+        let routeData = route.data;
+        if (this.ls.getUser()) {
+            let isAccessGranted = this.checkPageAccess(routeData, state);
+            if (isAccessGranted) {
+                return isAccessGranted;
+            }
+            else {
+                this.logger.error('[AuthGuard] Aunauthorized Access', routeData);
+                this.nav.navigateRoot(['/unauthorized']);
+                return isAccessGranted;
+            }
+        }
+        else {
+            if (state.url.startsWith('/login/sso')) {
+                let refreshToken = this.getCookie('rt');
+                let isNavAllowed = await this.ls
+                    .refreshToken(refreshToken)
+                    .then(async (res) => {
+                    await this.ls.setUser(res).then(res => res);
+                    this.nav.navigateRoot(['/welcome']);
+                    return true;
+                })
+                    .catch(err => {
+                    this.logger.error('[AuthGuard] error while refreshing token', err);
+                    this.nav.navigateRoot(['/login']);
+                    return true;
+                });
+                return isNavAllowed;
+            }
+            let authToken = await this.storage.get('access_token');
+            let refreshToken = await this.storage.get('refresh_token');
+            if (authToken) {
+                let isAllowed = await this.ls.loadUserInfo()
+                    .then(async (res) => {
+                    if (!res) {
+                        this.nav.navigateRoot(['/login']);
+                        return false;
+                    }
+                    else {
+                        let user = res;
+                        user['access_token'] = authToken;
+                        user['refresh_token'] = refreshToken;
+                        await this.ls.setUser(user).then(res => res);
+                        if (state.url.includes('login')) {
+                            this.nav.navigateRoot(['/welcome']);
+                        }
+                        let isAccessGranted = this.checkPageAccess(routeData, state);
+                        if (isAccessGranted) {
+                            return isAccessGranted;
+                        }
+                        else {
+                            this.nav.navigateRoot(['/unauthorized']);
+                            return isAccessGranted;
+                        }
+                    }
+                }).catch(async (err) => {
+                    this.ls.reset();
+                    if (state.url.includes('/not-found')) {
+                        return true;
+                    }
+                    this.nav.navigateRoot(['/login']);
+                    return false;
+                });
+                return isAllowed;
+            }
+            else {
+                if (state.url.includes('login')) {
+                    this.ls.reset();
+                    return true;
+                }
+                else if (state.url.includes('/not-found')) {
+                    return true;
+                }
+                else {
+                    this.nav.navigateRoot(['/login']);
+                    this.ls.reset();
+                    return false;
+                }
+            }
+        }
+    }
+    checkPageAccess(routeData, state) {
+        let functions = routeData.functions;
+        if (functions && functions.length > 0) {
+            if (functions.includes("*")) {
+                return true;
+            }
+            else {
+                return this.ls.checkFunctions(functions);
+            }
+        }
+        throw "Please specify function in app-routing.module.ts file for page :: " + state.url;
+    }
+    getCookie(cname) {
+        var name = cname + "=";
+        var decodedCookie = document.cookie;
+        var ca = decodedCookie.split(';');
+        for (var i = 0; i < ca.length; i++) {
+            var c = ca[i];
+            while (c.charAt(0) == ' ') {
+                c = c.substring(1);
+            }
+            if (c.indexOf(name) == 0) {
+                return c.substring(name.length, c.length);
+            }
+        }
+        return "";
+    }
+    static { this.ɵfac = function AuthGuard_Factory(t) { return new (t || AuthGuard)(i0.ɵɵinject(i1.Storage), i0.ɵɵinject(i2.Router), i0.ɵɵinject(i3.LoginService), i0.ɵɵinject(i2.ActivatedRoute), i0.ɵɵinject(i4.NavController), i0.ɵɵinject(i5.UtilService), i0.ɵɵinject(i6.LoggerService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthGuard, factory: AuthGuard.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthGuard, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.Storage }, { type: i2.Router }, { type: i3.LoginService }, { type: i2.ActivatedRoute }, { type: i4.NavController }, { type: i5.UtilService }, { type: i6.LoggerService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.guard.js","sourceRoot":"","sources":["../../../../../projects/ngx-reusa-app-lib/src/lib/guards/auth.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Router, ActivatedRoute, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';\r\nimport { Storage } from '@ionic/storage-angular';\r\nimport { NavController } from '@ionic/angular';\r\nimport { LoginService } from '../services/login/login.service';\r\nimport { UtilService } from '../services/util/util.service';\r\nimport { LoggerService } from '../services/logger/logger.service';\r\n\r\ninterface RouteData {\r\n    functions: string[];\r\n    title: string;\r\n    pageId: string;\r\n}\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class AuthGuard  {\r\n    constructor(private storage: Storage, private router: Router, private ls: LoginService,\r\n        private ar: ActivatedRoute, private nav: NavController, private util : UtilService, private logger: LoggerService) { }\r\n\r\n    async canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot) {\r\n        this.util.showLoader();\r\n        let routeData: RouteData | any = route.data;\r\n        if (this.ls.getUser()) {\r\n            let isAccessGranted: boolean = this.checkPageAccess(routeData, state);\r\n            if (isAccessGranted) {\r\n                return isAccessGranted;\r\n            } else {\r\n                this.logger.error('[AuthGuard] Aunauthorized Access', routeData);\r\n                this.nav.navigateRoot(['/unauthorized']);\r\n                return isAccessGranted;\r\n            }\r\n        } else {\r\n            if (state.url.startsWith('/login/sso')) {\r\n                let refreshToken = this.getCookie('rt');\r\n                let isNavAllowed = await this.ls\r\n                    .refreshToken(refreshToken)\r\n                    .then(async res => {\r\n                        await this.ls.setUser(res).then(res => res);\r\n                        this.nav.navigateRoot(['/welcome']);\r\n                        return true\r\n                    })\r\n                    .catch(err => {\r\n                        this.logger.error('[AuthGuard] error while refreshing token', err);\r\n                        this.nav.navigateRoot(['/login']);\r\n                        return true;\r\n                    });\r\n                return isNavAllowed;\r\n            }\r\n            let authToken = await this.storage.get('access_token');\r\n            let refreshToken = await this.storage.get('refresh_token');\r\n            if (authToken) {\r\n                let isAllowed = await this.ls.loadUserInfo()\r\n                    .then(async res => {\r\n                        if (!res) {\r\n                            this.nav.navigateRoot(['/login']);\r\n                            return false;\r\n                        } else {\r\n                            let user: any = res;\r\n                            user['access_token'] = authToken;\r\n                            user['refresh_token'] = refreshToken;\r\n                            await this.ls.setUser(user).then(res => res);\r\n                            if (state.url.includes('login')) {\r\n                                this.nav.navigateRoot(['/welcome']);\r\n                            }\r\n                            let isAccessGranted: boolean = this.checkPageAccess(routeData, state);\r\n                            if (isAccessGranted) {\r\n                                return isAccessGranted;\r\n                            } else {\r\n                                this.nav.navigateRoot(['/unauthorized']);\r\n                                return isAccessGranted;\r\n                            }\r\n                        }\r\n                    }).catch(async err => {\r\n                        this.ls.reset();\r\n                        if (state.url.includes('/not-found')) {\r\n                            return true;\r\n                        }\r\n                        this.nav.navigateRoot(['/login']);\r\n                        return false;\r\n                    });\r\n                return isAllowed;\r\n            } else {\r\n                if (state.url.includes('login')) {\r\n                    this.ls.reset();\r\n                    return true;\r\n                } else if (state.url.includes('/not-found')) {\r\n                    return true;\r\n                } else {\r\n                    this.nav.navigateRoot(['/login']);\r\n                    this.ls.reset();\r\n                    return false;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    checkPageAccess(routeData: RouteData, state: RouterStateSnapshot): boolean {\r\n        let functions: string[] = routeData.functions;\r\n        if (functions && functions.length > 0) {\r\n            if (functions.includes(\"*\")) {\r\n                return true;\r\n            } else {\r\n                return this.ls.checkFunctions(functions);\r\n            }\r\n        }\r\n        throw \"Please specify function in app-routing.module.ts file for page :: \" + state.url;\r\n    }\r\n\r\n    getCookie(cname) {\r\n        var name = cname + \"=\";\r\n        var decodedCookie = document.cookie;\r\n        var ca = decodedCookie.split(';');\r\n        for (var i = 0; i < ca.length; i++) {\r\n            var c = ca[i];\r\n            while (c.charAt(0) == ' ') {\r\n                c = c.substring(1);\r\n            }\r\n            if (c.indexOf(name) == 0) {\r\n                return c.substring(name.length, c.length);\r\n            }\r\n        }\r\n        return \"\";\r\n    }\r\n}\r\n"]}

package/esm2022/lib/guards/no-login/no-login.guard.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/util/util.service";
+export class NoLoginGuard {
+    constructor(util) {
+        this.util = util;
+    }
+    canActivate(next, state) {
+        this.util.showLoader();
+        return true;
+    }
+    static { this.ɵfac = function NoLoginGuard_Factory(t) { return new (t || NoLoginGuard)(i0.ɵɵinject(i1.UtilService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: NoLoginGuard, factory: NoLoginGuard.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NoLoginGuard, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.UtilService }], null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm8tbG9naW4uZ3VhcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmV1c2EtYXBwLWxpYi9zcmMvbGliL2d1YXJkcy9uby1sb2dpbi9uby1sb2dpbi5ndWFyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFRM0MsTUFBTSxPQUFPLFlBQVk7SUFFdkIsWUFBbUIsSUFBaUI7UUFBakIsU0FBSSxHQUFKLElBQUksQ0FBYTtJQUFFLENBQUM7SUFFdkMsV0FBVyxDQUNULElBQTRCLEVBQzVCLEtBQTBCO1FBQ3hCLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDekIsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDOzZFQVRVLFlBQVk7dUVBQVosWUFBWSxXQUFaLFlBQVksbUJBRlgsTUFBTTs7aUZBRVAsWUFBWTtjQUh4QixVQUFVO2VBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIFJvdXRlclN0YXRlU25hcHNob3QsIFVybFRyZWUgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IFV0aWxTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvdXRpbC91dGlsLnNlcnZpY2UnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgTm9Mb2dpbkd1YXJkICB7XHJcblxyXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB1dGlsOiBVdGlsU2VydmljZSl7fVxyXG5cclxuICBjYW5BY3RpdmF0ZShcclxuICAgIG5leHQ6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsXHJcbiAgICBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCk6IE9ic2VydmFibGU8Ym9vbGVhbiB8IFVybFRyZWU+IHwgUHJvbWlzZTxib29sZWFuIHwgVXJsVHJlZT4gfCBib29sZWFuIHwgVXJsVHJlZSB7XHJcbiAgICAgIHRoaXMudXRpbC5zaG93TG9hZGVyKCk7XHJcbiAgICByZXR1cm4gdHJ1ZTtcclxuICB9XHJcbiAgXHJcbn1cclxuIl19

package/esm2022/lib/interceptors/error-interceptor/http-error-interceptor.mjs

@@ -0,0 +1,107 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse, HttpErrorResponse } from '@angular/common/http';
+import { throwError } from "rxjs";
+import { catchError, tap } from 'rxjs/operators';
+import { ErrorModel } from '../../models/ErrorModel';
+import { LibConstants } from '../../models/LibConstants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../services/util/util.service";
+import * as i3 from "@ionic/angular";
+import * as i4 from "../../services/login/login.service";
+import * as i5 from "../../services/logger/logger.service";
+import * as i6 from "../../services/maintenance/maintenance.service";
+export class HttpErrorInterceptor {
+    constructor(router, util, nav, ls, logger, ms) {
+        this.router = router;
+        this.util = util;
+        this.nav = nav;
+        this.ls = ls;
+        this.logger = logger;
+        this.ms = ms;
+    }
+    intercept(req, next) {
+        return next.handle(req).pipe(tap(evt => {
+            if (evt instanceof HttpResponse) {
+                this.logger.log('[HttpErrorInterceptor] response ->', evt);
+                if (evt.status >= 200 && evt.status < 300) {
+                    //this.util.hideLoader();
+                }
+            }
+        }), catchError((error) => {
+            let errorModel = new ErrorModel();
+            errorModel.msg = 'An error occured while processing your request. Please check your network connection or try again.';
+            errorModel.timestamp = new Date().toDateString();
+            this.logger.error('[HttpErrorInterceptor] Error occured', error);
+            if (error instanceof HttpErrorResponse) {
+                if ((error.error instanceof ErrorEvent) || (error.error instanceof ProgressEvent)) {
+                    this.logger.error("[HttpErrorInterceptor] Error Event", error);
+                    if ((!req.url.includes('localhost') || this.util.isPlayformCapacitor()) && LibConstants.maintenanceModeFeatureEnabled == 'true') {
+                        this.ms.checkforMaintenance()
+                            .subscribe(res => {
+                            if (res.isAppUnderMaintenance) {
+                                this.nav.navigateRoot('maintenance').then(() => { window.location.reload(); });
+                            }
+                        });
+                    }
+                }
+                else {
+                    this.logger.error(`[HttpErrorInterceptor] error status : ${error.status} ${error.statusText}`);
+                    switch (error.status) {
+                        case 401: //login
+                            errorModel = error.error;
+                            if ((error.error.error == 'invalid_request' && error.error.roles == 'PRE_AUTH') || this.shouldStayOnPage()) {
+                                this.logger.error("[HttpErrorInterceptor] invalid request, staying on same page", errorModel);
+                                break;
+                            }
+                            else {
+                                this.nav.navigateRoot("login").then(() => {
+                                    if (errorModel.msg == 'unauthorized'
+                                        || errorModel.msg == 'invalid_token'
+                                        || errorModel.msg == 'token_expired'
+                                        || errorModel['error'] == 'invalid_token'
+                                        || errorModel['error'] == 'token_expired') {
+                                        errorModel.msg = 'Session Expired. Please login again.';
+                                    }
+                                    this.ls.logout();
+                                    this.util.errorHandler(errorModel);
+                                });
+                            }
+                            break;
+                        case 403: //forbidden
+                            this.util.errorHandler(errorModel);
+                            this.nav.navigateRoot("unauthorized");
+                            break;
+                        case 404: //Not Found
+                        case 422: //Unprocessable Entity
+                            errorModel = error.error;
+                            break;
+                        default:
+                            errorModel = error.error ? error.error : errorModel;
+                            break;
+                    }
+                }
+            }
+            else {
+                this.logger.error("[HttpErrorInterceptor] some thing else happened", error);
+            }
+            //this.util.hideLoader();
+            return throwError(errorModel);
+        }));
+    }
+    shouldStayOnPage() {
+        return this.router.url.includes('account-success') ||
+            this.router.url.includes('landing') ||
+            this.router.url.includes('login') ||
+            this.router.url.includes('welcome-splash');
+    }
+    static { this.ɵfac = function HttpErrorInterceptor_Factory(t) { return new (t || HttpErrorInterceptor)(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.UtilService), i0.ɵɵinject(i3.NavController), i0.ɵɵinject(i4.LoginService), i0.ɵɵinject(i5.LoggerService), i0.ɵɵinject(i6.MaintenanceService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: HttpErrorInterceptor, factory: HttpErrorInterceptor.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpErrorInterceptor, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.Router }, { type: i2.UtilService }, { type: i3.NavController }, { type: i4.LoginService }, { type: i5.LoggerService }, { type: i6.MaintenanceService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-error-interceptor.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/interceptors/error-interceptor/http-error-interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {HttpEvent, HttpHandler, HttpInterceptor,HttpRequest,HttpResponse,HttpErrorResponse} from '@angular/common/http';\nimport {Observable, throwError} from \"rxjs\";\nimport {catchError, tap} from 'rxjs/operators';\nimport { Router } from '@angular/router';\nimport { NavController } from '@ionic/angular';\nimport { ErrorModel } from '../../models/ErrorModel';\nimport { UtilService } from '../../services/util/util.service';\nimport { LoginService } from '../../services/login/login.service';\nimport { LoggerService } from '../../services/logger/logger.service';\nimport { MaintenanceService } from '../../services/maintenance/maintenance.service';\nimport { LibConstants } from '../../models/LibConstants';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class HttpErrorInterceptor implements HttpInterceptor{\n\n  constructor(public router : Router, private util : UtilService, private nav : NavController, private ls : LoginService, private logger: LoggerService, public ms : MaintenanceService) { }\n\n  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n          return next.handle(req).pipe(\n            tap(evt => {\n                if (evt instanceof HttpResponse) {\n                    this.logger.log('[HttpErrorInterceptor] response ->', evt);\n                    if(evt.status >= 200 && evt.status < 300){\n                        //this.util.hideLoader();\n                    }\n                }\n            }),\n            catchError( (error) => {\n               let errorModel : ErrorModel = new ErrorModel();\n               errorModel.msg = 'An error occured while processing your request. Please check your network connection or try again.';\n               errorModel.timestamp = new Date().toDateString();\n               this.logger.error('[HttpErrorInterceptor] Error occured', error);\n              if (error instanceof HttpErrorResponse) {\n                if ((error.error instanceof ErrorEvent) || (error.error instanceof ProgressEvent)) {\n                    this.logger.error(\"[HttpErrorInterceptor] Error Event\", error);\n                    if((!req.url.includes('localhost') || this.util.isPlayformCapacitor()) && LibConstants.maintenanceModeFeatureEnabled == 'true'){\n                        this.ms.checkforMaintenance()\n                                .subscribe(res => {\n                                if(res.isAppUnderMaintenance) {\n                                    this.nav.navigateRoot('maintenance').then(() => {window.location.reload()});\n                                }});\n                    }\n                } else {\n                    this.logger.error(`[HttpErrorInterceptor] error status : ${error.status} ${error.statusText}`);\n                    switch (error.status) {\n                        case 401:      //login\n                            errorModel = error.error;\n                            if((error.error.error == 'invalid_request' && error.error.roles == 'PRE_AUTH') || this.shouldStayOnPage()){\n                                this.logger.error(\"[HttpErrorInterceptor] invalid request, staying on same page\", errorModel);\n                                break;\n                            }else{\n                                this.nav.navigateRoot(\"login\").then(\n                                    () => {\n                                        if(errorModel.msg == 'unauthorized' \n                                            || errorModel.msg == 'invalid_token' \n                                            || errorModel.msg == 'token_expired'\n                                            || errorModel['error'] == 'invalid_token'\n                                            || errorModel['error'] == 'token_expired'){\n                                            errorModel.msg = 'Session Expired. Please login again.';\n                                        }\n                                        this.ls.logout();\n                                        this.util.errorHandler(errorModel);\n                                    }\n                                );\n                            }\n                            break;\n                        case 403:     //forbidden\n                            this.util.errorHandler(errorModel);\n                            this.nav.navigateRoot(\"unauthorized\");\n                            break;\n                        case 404:     //Not Found\n                        case 422:     //Unprocessable Entity\n                            errorModel = error.error;\n                            break;\n                        default:\n                            errorModel = error.error ? error.error : errorModel;\n                            break;\n                    }\n                } \n            } else {\n                this.logger.error(\"[HttpErrorInterceptor] some thing else happened\", error);\n            }\n            //this.util.hideLoader();\n            return throwError(errorModel);\n          })\n        );\n    }\n\n    shouldStayOnPage(): boolean {\n        return this.router.url.includes('account-success') ||\n                this.router.url.includes('landing') ||\n                this.router.url.includes('login') ||\n                this.router.url.includes('welcome-splash');\n    }\n}\n"]}

package/esm2022/lib/interceptors/header-interceptor/http-header.interceptor.mjs

@@ -0,0 +1,99 @@
+import { Injectable } from '@angular/core';
+import { LibConstants } from '../../models/LibConstants';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/login/login.service";
+import * as i2 from "../../services/util/util.service";
+import * as i3 from "../../services/logger/logger.service";
+import * as i4 from "../../services/captcha/captcha.service";
+import * as i5 from "../../services/fpjs/fingerprint.service";
+import * as i6 from "../../services/claimant-context/claimant-context.service";
+export class HttpHeaderInterceptor {
+    constructor(loginService, util, logger, captchaService, fingerprintService, claimantContextService) {
+        this.loginService = loginService;
+        this.util = util;
+        this.logger = logger;
+        this.captchaService = captchaService;
+        this.fingerprintService = fingerprintService;
+        this.claimantContextService = claimantContextService;
+    }
+    intercept(request, next) {
+        // add authorization header with jwt token if available
+        this.logger.log('[HttpHeaderInterceptor] Inside Interceptor before --> ', request);
+        //this.util.showLoader();
+        let currentUser = this.loginService.getUser();
+        if (currentUser && !(request.url.includes("/oauth/token") ||
+            request.url.includes('/check_token') ||
+            (request.url.includes('/trends') && request.method.toLocaleLowerCase() == 'get'))) {
+            request = request.clone({
+                headers: request.headers
+                    .append('Authorization', `Bearer ${currentUser.access_token}`)
+            });
+        }
+        if (!(currentUser && currentUser.username) && (request.url.includes("/oauth/token") || request.url.includes('/check_token'))) {
+            if (!request.headers.get('Authorization')) {
+                request = request.clone({
+                    withCredentials: false,
+                    headers: request.headers
+                        .append('Authorization', `Basic ` + btoa(`${LibConstants.oauthClientUser}:${LibConstants.oauthClientSecret}`))
+                });
+            }
+        }
+        let value = localStorage.getItem('language');
+        let language = value != null ? value : 'en';
+        request = request.clone({
+            headers: request.headers.append('Accept-Language', language)
+        });
+        if (this.fingerprintService.getBrowserFingerprint()) {
+            request = request.clone({
+                headers: request.headers
+                    .append('X-Custom-Fingerprint', this.fingerprintService.getBrowserFingerprint())
+            });
+        }
+        if (this.fingerprintService.getRequestId()) {
+            request = request.clone({
+                headers: request.headers
+                    .append('X-Custom-IPQS-RequestId', this.fingerprintService.getRequestId())
+            });
+        }
+        if (this.captchaService.getCaptcha()) {
+            request = request.clone({
+                headers: request.headers
+                    .append('X-Custom-Captcha', this.captchaService.getCaptcha())
+            });
+        }
+        if (this.captchaService.getInvisibelCaptcha()) {
+            request = request.clone({
+                headers: request.headers
+                    .append('X-Custom-Captcha-v3', this.captchaService.getInvisibelCaptcha())
+            });
+        }
+        if (this.loginService.getAuthcode()) {
+            request = request.clone({
+                headers: request.headers
+                    .append('X-Custom-Authcode', this.loginService.getAuthcode() + '')
+            });
+        }
+        if (this.loginService.isCsr() && this.claimantContextService.getSsn()) {
+            request = request.clone({
+                headers: request.headers
+                    .append('X-Custom-Param-Soc', this.claimantContextService.getSsn())
+            });
+        }
+        if (this.loginService.isCsr() && this.claimantContextService.getClaimantId()) {
+            request = request.clone({
+                headers: request.headers
+                    .append('X-Custom-Param-Cid', this.claimantContextService.getClaimantId())
+            });
+        }
+        return next.handle(request);
+    }
+    static { this.ɵfac = function HttpHeaderInterceptor_Factory(t) { return new (t || HttpHeaderInterceptor)(i0.ɵɵinject(i1.LoginService), i0.ɵɵinject(i2.UtilService), i0.ɵɵinject(i3.LoggerService), i0.ɵɵinject(i4.CaptchaService), i0.ɵɵinject(i5.FingerprintService), i0.ɵɵinject(i6.ClaimantContextService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: HttpHeaderInterceptor, factory: HttpHeaderInterceptor.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HttpHeaderInterceptor, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], () => [{ type: i1.LoginService }, { type: i2.UtilService }, { type: i3.LoggerService }, { type: i4.CaptchaService }, { type: i5.FingerprintService }, { type: i6.ClaimantContextService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-header.interceptor.js","sourceRoot":"","sources":["../../../../../../projects/ngx-reusa-app-lib/src/lib/interceptors/header-interceptor/http-header.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { UserModel } from '../../models/UserModel';\r\nimport { UtilService } from '../../services/util/util.service';\r\nimport { LoginService } from '../../services/login/login.service';\r\nimport { LoggerService } from '../../services/logger/logger.service';\r\nimport { LibConstants } from '../../models/LibConstants';\r\nimport { CaptchaService } from '../../services/captcha/captcha.service';\r\nimport { FingerprintService } from '../../services/fpjs/fingerprint.service';\r\nimport { ClaimantContextService } from '../../services/claimant-context/claimant-context.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class HttpHeaderInterceptor implements HttpInterceptor{\r\n\r\n  constructor(public loginService : LoginService, public util: UtilService, private logger: LoggerService, \r\n              private captchaService: CaptchaService, private fingerprintService: FingerprintService, private claimantContextService: ClaimantContextService) { \r\n\r\n  }\r\n\r\n  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n    // add authorization header with jwt token if available\r\n    this.logger.log('[HttpHeaderInterceptor] Inside Interceptor before --> ', request);\r\n    //this.util.showLoader();\r\n    let currentUser : UserModel = this.loginService.getUser();\r\n    if (currentUser && !(request.url.includes(\"/oauth/token\") || \r\n                         request.url.includes('/check_token') || \r\n                         (request.url.includes('/trends') && request.method.toLocaleLowerCase() == 'get'))) {\r\n      request = request.clone({\r\n        headers: request.headers\r\n                        .append('Authorization', `Bearer ${currentUser.access_token}`)\r\n      });\r\n    }\r\n    if(!(currentUser && currentUser.username) && (request.url.includes(\"/oauth/token\") || request.url.includes('/check_token')) ){\r\n      if(!request.headers.get('Authorization')){\r\n        request = request.clone({\r\n          withCredentials: false,\r\n          headers: request.headers\r\n                          .append('Authorization', `Basic ` + btoa(`${LibConstants.oauthClientUser}:${LibConstants.oauthClientSecret}`))\r\n        });\r\n      }\r\n    }\r\n\r\n      let value = localStorage.getItem('language');\r\n      let language = value != null ? value : 'en';\r\n      request = request.clone({\r\n        headers: request.headers.append('Accept-Language', language)\r\n      });\r\n  \r\n      if(this.fingerprintService.getBrowserFingerprint()){\r\n        request = request.clone({\r\n          headers: request.headers\r\n                .append('X-Custom-Fingerprint', this.fingerprintService.getBrowserFingerprint())\r\n          });\r\n      }\r\n  \r\n      if(this.fingerprintService.getRequestId()){\r\n        request = request.clone({\r\n          headers: request.headers\r\n                .append('X-Custom-IPQS-RequestId', this.fingerprintService.getRequestId())\r\n          });\r\n      }\r\n      \r\n      if(this.captchaService.getCaptcha()){\r\n        request = request.clone({\r\n          headers: request.headers\r\n                .append('X-Custom-Captcha', this.captchaService.getCaptcha())\r\n          });\r\n      }\r\n  \r\n      if(this.captchaService.getInvisibelCaptcha()){\r\n        request = request.clone({\r\n          headers: request.headers\r\n                .append('X-Custom-Captcha-v3', this.captchaService.getInvisibelCaptcha())\r\n          });\r\n      }\r\n  \r\n      if(this.loginService.getAuthcode()){\r\n        request = request.clone({\r\n          headers: request.headers\r\n                .append('X-Custom-Authcode', this.loginService.getAuthcode() + '')\r\n          });\r\n      }\r\n  \r\n      if(this.loginService.isCsr() && this.claimantContextService.getSsn()){\r\n        request = request.clone({\r\n          headers: request.headers\r\n                .append('X-Custom-Param-Soc', this.claimantContextService.getSsn())\r\n          });\r\n      }\r\n  \r\n      if(this.loginService.isCsr() && this.claimantContextService.getClaimantId()){\r\n        request = request.clone({\r\n          headers: request.headers\r\n                .append('X-Custom-Param-Cid', this.claimantContextService.getClaimantId())\r\n          });\r\n      }\r\n    return next.handle(request);\r\n  }\r\n}\r\n"]}

package/esm2022/lib/models/AddressComponentModel.mjs

@@ -0,0 +1,3 @@
+export class AddressComponentModel {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWRkcmVzc0NvbXBvbmVudE1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJldXNhLWFwcC1saWIvc3JjL2xpYi9tb2RlbHMvQWRkcmVzc0NvbXBvbmVudE1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxxQkFBcUI7Q0FTakMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgQWRkcmVzc0NvbXBvbmVudE1vZGVsIHtcclxuICAgIHppcD86IHN0cmluZztcclxuICAgIHppcENvZGU/OiBzdHJpbmc7XHJcbiAgICBjaXR5Pzogc3RyaW5nO1xyXG4gICAgY291bnR5PzogQ2hvaWNlc01vZGVsO1xyXG4gICAgdG93bj86IENob2ljZXNNb2RlbDtcclxuICAgIHN0YXRlPzpDaG9pY2VzTW9kZWw7IFxyXG4gICAgY291bnRyeT86IENob2ljZXNNb2RlbDtcclxuXHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ2hvaWNlc01vZGVsIHtcclxuICAgIHZhbHVlOiBzdHJpbmc7XHJcbiAgICB0ZXh0OiBzdHJpbmc7XHJcbn0iXX0=

package/esm2022/lib/models/BankDetailsComponentModel.mjs

@@ -0,0 +1,3 @@
+export class BankDetailsComponentModel {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFua0RldGFpbHNDb21wb25lbnRNb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZXVzYS1hcHAtbGliL3NyYy9saWIvbW9kZWxzL0JhbmtEZXRhaWxzQ29tcG9uZW50TW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLHlCQUF5QjtDQU1yQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBCYW5rRGV0YWlsc0NvbXBvbmVudE1vZGVse1xyXG4gICAgbmFtZU9uQWNjb3VudCA/OiBzdHJpbmc7XHJcbiAgICBhY2NvdW50VHlwZSA/OiBDaG9pY2VzTW9kZWw7XHJcbiAgICByb3V0aW5nTnVtYmVyID86IHN0cmluZztcclxuICAgIGFjY291bnROdW1iZXIgPzogc3RyaW5nO1xyXG4gICAgcmVFbnRlckFjY291bnROdW1iZXIgPzogc3RyaW5nO1xyXG59XHJcblxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBDaG9pY2VzTW9kZWwge1xyXG4gICAgdmFsdWU6IHN0cmluZztcclxuICAgIHRleHQ6IHN0cmluZztcclxufSJdfQ==

package/esm2022/lib/models/BankDetailsModel.mjs

@@ -0,0 +1,3 @@
+export class BankDetailsModel {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFua0RldGFpbHNNb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZXVzYS1hcHAtbGliL3NyYy9saWIvbW9kZWxzL0JhbmtEZXRhaWxzTW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLGdCQUFnQjtDQUc1QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBCYW5rRGV0YWlsc01vZGVsIHtcclxuICAgIHJvdXRpbmdOdW1iZXI/OiBzdHJpbmc7XHJcbiAgICBiYW5rTmFtZT86IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2022/lib/models/CinRequalificationCriteriaModel.mjs

@@ -0,0 +1,3 @@
+export class CinRequalificationCriteriaModel {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2luUmVxdWFsaWZpY2F0aW9uQ3JpdGVyaWFNb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZXVzYS1hcHAtbGliL3NyYy9saWIvbW9kZWxzL0NpblJlcXVhbGlmaWNhdGlvbkNyaXRlcmlhTW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLCtCQUErQjtDQVMzQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBDaW5SZXF1YWxpZmljYXRpb25Dcml0ZXJpYU1vZGVseyAgICBcclxuXHRlbXBsb3llcklkPzpzdHJpbmc7XHJcblx0Y2xhaW1BcHBFbXBsb3llcklkPzpzdHJpbmc7XHJcblx0ZW1wbG95ZXJOYW1lPzpzdHJpbmc7XHJcblx0aXNzdWVJZD86c3RyaW5nO1xyXG5cdHJlYXNvbj86c3RyaW5nO1xyXG5cdHN0YXJ0RGF0ZT86c3RyaW5nO1xyXG5cdHJlcXVhbGlmaWNhdGlvbldhZ2U/OnN0cmluZztcclxuXHRhY3Rpb25UYWtlbj86c3RyaW5nO1xyXG59Il19

package/esm2022/lib/models/EmployerDetailSearchResult.mjs

@@ -0,0 +1,6 @@
+export class EmployerSearchResult {
+}
+export class EmployerInfoModel {
+    constructor() { }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/ErrorModel.mjs

@@ -0,0 +1,6 @@
+export class ErrorModel {
+    constructor() {
+        this.errorId = 'NA';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXJyb3JNb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1yZXVzYS1hcHAtbGliL3NyYy9saWIvbW9kZWxzL0Vycm9yTW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFVBQVU7SUFBdkI7UUFDSSxZQUFPLEdBQVksSUFBSSxDQUFDO0lBSTVCLENBQUM7Q0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBFcnJvck1vZGVse1xuICAgIGVycm9ySWQgOiBzdHJpbmcgPSAnTkEnO1xuICAgIHRpbWVzdGFtcCA6IHN0cmluZztcbiAgICBtc2cgOiBzdHJpbmc7XG4gICAgZGV0YWlscyA6IHN0cmluZztcbn0iXX0=

package/esm2022/lib/models/FileModel.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmlsZU1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJldXNhLWFwcC1saWIvc3JjL2xpYi9tb2RlbHMvRmlsZU1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIEZpbGVNb2RlbHtcbiAgICBmaWxlSWQgOiBzdHJpbmc7XG4gICAgZmlsZU5hbWUgOiBzdHJpbmc7XG59Il19

package/esm2022/lib/models/LexisNexisAccountCreationModel.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGV4aXNOZXhpc0FjY291bnRDcmVhdGlvbk1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJldXNhLWFwcC1saWIvc3JjL2xpYi9tb2RlbHMvTGV4aXNOZXhpc0FjY291bnRDcmVhdGlvbk1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIExleGlzTmV4aXNBY2NvdW50Q3JlYXRpb25Nb2RlbCB7XHJcbiAgICBzZXNzaW9uX2lkOiBzdHJpbmc7XHJcbiAgICBpbnB1dF9pcF9hZGRyZXNzOiBzdHJpbmc7XHJcbiAgICBhY2NvdW50X2ZpcnN0X25hbWU6IHN0cmluZztcclxuICAgIGFjY291bnRfbGFzdF9uYW1lOiBzdHJpbmc7XHJcbiAgICBhY2NvdW50X2FkZHJlc3Nfc3RyZWV0MTogc3RyaW5nO1xyXG4gICAgYWNjb3VudF9hZGRyZXNzX2NpdHk6IHN0cmluZztcclxuICAgIGFjY291bnRfYWRkcmVzc19zdGF0ZTogc3RyaW5nO1xyXG4gICAgYWNjb3VudF9hZGRyZXNzX3ppcDogc3RyaW5nO1xyXG4gICAgYWNjb3VudF9kYXRlX29mX2JpcnRoOiBzdHJpbmc7XHJcbiAgICBhY2NvdW50X2VtYWlsOiBzdHJpbmc7XHJcbiAgICBhY2NvdW50X3RlbGVwaG9uZTogc3RyaW5nO1xyXG4gICAgbmF0aW9uYWxfaWRfbnVtYmVyOiBzdHJpbmc7XHJcbn0iXX0=

package/esm2022/lib/models/LexisNexisAuthSelectionRequestModel.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGV4aXNOZXhpc0F1dGhTZWxlY3Rpb25SZXF1ZXN0TW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmV1c2EtYXBwLWxpYi9zcmMvbGliL21vZGVscy9MZXhpc05leGlzQXV0aFNlbGVjdGlvblJlcXVlc3RNb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBMZXhpc05leGlzQXV0aFNlbGVjdGlvblJlcXVlc3RNb2RlbCB7XHJcbiAgYXV0aF9zZWxlY3Rpb25faWQ6IHN0cmluZztcclxuICAnaWlkcWEuYW5zd2Vycyc6IEFuc3dlcnM7IC8vIExOIEFQSSBpZGVudGlmaWVzIGl0IGFzIGlpZHFhLmFuc3dlcnNcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBDaG9pY2Uge1xyXG4gIENob2ljZTogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFF1ZXN0aW9uIHtcclxuICBRdWVzdGlvbklkOiBudW1iZXI7XHJcbiAgQ2hvaWNlczogQ2hvaWNlW107XHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQW5zd2VycyB7XHJcbiAgUXVlc3Rpb25TZXRJZDogbnVtYmVyO1xyXG4gIFF1ZXN0aW9uczogUXVlc3Rpb25bXTtcclxufVxyXG4iXX0=

package/esm2022/lib/models/LexisNexisAuthSelectionResponseModel.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGV4aXNOZXhpc0F1dGhTZWxlY3Rpb25SZXNwb25zZU1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJldXNhLWFwcC1saWIvc3JjL2xpYi9tb2RlbHMvTGV4aXNOZXhpc0F1dGhTZWxlY3Rpb25SZXNwb25zZU1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIExleGlzTmV4aXNBdXRoU2VsZWN0aW9uUmVzcG9uc2VNb2RlbCB7XHJcbiAgYXV0aF9zZWxlY3Rpb25faWQ6IHN0cmluZztcclxuICBlcnJvcl9kZXRhaWw6IHN0cmluZyB8IG51bGw7XHJcbiAgZXZlbnRfZGF0ZXRpbWU6IHN0cmluZztcclxuICBldmVudF90eXBlOiBzdHJpbmc7XHJcbiAgJ2lpZHFhLmRpc2NvdmVyeV9zdGF0dXMnOiBzdHJpbmc7XHJcbiAgJ2lpZHFhLnF1ZXN0aW9uX3NldCc6IFF1ZXN0aW9uU2V0O1xyXG4gICdpaWRxYS52ZWxvY2l0eV9zdGF0dXMnOiBzdHJpbmc7XHJcbiAgcG9saWN5OiBzdHJpbmc7XHJcbiAgcG9saWN5X2VuZ2luZV92ZXJzaW9uOiBzdHJpbmc7XHJcbiAgcG9saWN5X3NpdGVfaWQ6IHN0cmluZztcclxuICByZXF1ZXN0X2R1cmF0aW9uOiBzdHJpbmc7XHJcbiAgcmVxdWVzdF9pZDogc3RyaW5nO1xyXG4gIHJlcXVlc3RfcmVzdWx0OiBzdHJpbmc7XHJcbiAgcmV2aWV3X3N0YXR1czogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFF1ZXN0aW9uU2V0IHtcclxuICBRdWVzdGlvblNldElkOiBudW1iZXI7XHJcbiAgUXVlc3Rpb25zOiBRdWVzdGlvbltdO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFF1ZXN0aW9uIHtcclxuICBRdWVzdGlvbklkOiBudW1iZXI7XHJcbiAgQ2hvaWNlczogQ2hvaWNlW107XHJcbiAgSGVscFRleHQ6IEhlbHBUZXh0O1xyXG4gIEtleTogc3RyaW5nO1xyXG4gIFRleHQ6IFRleHQ7XHJcbiAgVHlwZTogc3RyaW5nO1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIENob2ljZSB7XHJcbiAgQ2hvaWNlSWQ6IHN0cmluZztcclxuICBUZXh0OiBUZXh0O1xyXG59XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEhlbHBUZXh0IHtcclxuICBTdGF0ZW1lbnQ6IHN0cmluZztcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBUZXh0IHtcclxuICBTdGF0ZW1lbnQ6IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2022/lib/models/LexisNexisEnabledResponseModel.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGV4aXNOZXhpc0VuYWJsZWRSZXNwb25zZU1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJldXNhLWFwcC1saWIvc3JjL2xpYi9tb2RlbHMvTGV4aXNOZXhpc0VuYWJsZWRSZXNwb25zZU1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIExleGlzTmV4aXNFbmFibGVkUmVzcG9uc2VNb2RlbCB7XHJcbiAgICBsbmVuYWJsZWQgOiBib29sZWFuLFxyXG4gICAgbWVzc2FnZSA6IHN0cmluZ1xyXG59Il19

package/esm2022/lib/models/LexisNexisResponseModel.mjs

@@ -0,0 +1,3 @@
+export class LexisNexisResponseModel {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGV4aXNOZXhpc1Jlc3BvbnNlTW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtcmV1c2EtYXBwLWxpYi9zcmMvbGliL21vZGVscy9MZXhpc05leGlzUmVzcG9uc2VNb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sdUJBQXVCO0NBS25DIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIExleGlzTmV4aXNSZXNwb25zZU1vZGVsIHtcclxuICBzZXNzaW9uSWQ/OiBzdHJpbmc7XHJcbiAgc3RhdHVzPzogc3RyaW5nO1xyXG4gIGF1dGhTZWxlY3Rpb25JZD86IHN0cmluZztcclxuICByZXZpZXdTdGF0dXM/OiBzdHJpbmc7XHJcbn1cclxuIl19