@colijnit/sharedcomponents 261.1.0 → 261.1.2

package/projects/sharedcomponents/src/lib/service/shared-event.service.ts

@@ -0,0 +1,9 @@
+import {Injectable} from "@angular/core";
+import {BehaviorSubject, Subject} from 'rxjs';
+
+@Injectable({
+  providedIn: "root"
+})
+export class SharedEventService {
+  public readonly salesOrderNavigation: Subject<string> = new Subject<string>();
+}

package/projects/sharedcomponents/src/lib/service/shared-initializer.service.ts

@@ -0,0 +1,44 @@
+import {Inject, Injectable, Injector} from '@angular/core';
+import {SharedService} from './shared.service';
+import {SharedComponentsDictionaryService} from '../translation/shared-components-dictionary.service';
+import {LanguageCode} from '../enum/language-code.enum';
+
+@Injectable()
+export class SharedInitializerService {
+
+  constructor(
+    @Inject(Injector) private readonly injector: Injector,
+    private _sharedDictionary: SharedComponentsDictionaryService
+  ) {
+  }
+
+  public async initializeApp(): Promise<void> {
+    // const options = {
+    //   url: 'https://demo1.ionecloud.nl/',
+    //   //url: 'http://localhost:8080/ione',
+    //   schema: "134592",
+    //   version: "257",
+    //   useLoginEncryption: true,
+    //   username: "Testscher",
+    //   password: "Wachtwoord1!",
+    //   languageCode: "NL"
+    // };
+    const options = {
+      url: 'https://develop.colijn-it.nl/',
+      // url: 'http://localhost:8080/ione',
+      schema: "815",
+      version: "261",
+      useLoginEncryption: true,
+      username: "elske",
+      password: "elske1",
+      languageCode: "NL"
+    };
+
+    const sharedService = this.injector.get(SharedService);
+     if (sharedService) {
+        await sharedService.init(options);
+     }
+     await this._sharedDictionary.setDictionary(LanguageCode.Dutch);
+  }
+
+}

package/projects/sharedcomponents/src/lib/service/shared.service.ts

@@ -0,0 +1,244 @@
+import {SharedConnectorService} from "./shared-connector.service";
+import {Inject, Injectable, LOCALE_ID} from "@angular/core";
+import {OptionsService} from "./options.service";
+import {Printer} from '@colijnit/mainapi/build/model/printer.bo';
+import {SendMethod} from '@colijnit/mainapi/build/model/send-method.bo';
+import {TagCategory} from "@colijnit/mainapi/build/enum/tab-category.enum";
+import {TagTreeItem} from "@colijnit/mainapi/build/model/tag-tree-item.bo";
+import {RelationRequest} from "@colijnit/relationapi/build/model/relation-request";
+import {RelationListObject} from "@colijnit/relationapi/build/model/relation-list-object.bo";
+import {TaskCategory} from "@colijnit/mainapi/build/model/task-category.bo";
+import {TableName} from "@colijnit/mainapi/build/enum/table-name.enum";
+import {WorkflowProcess} from "@colijnit/mainapi/build/model/workflow-process";
+import {DomainName} from "@colijnit/mainapi/build/enum/domain-name.enum";
+import {CoDomainValue} from "@colijnit/mainapi/build/model/co-domain-value.bo";
+import {RoleEmailaddress} from "@colijnit/mainapi/build/model/role-email-address";
+import {Activity} from "@colijnit/mainapi/build/model/activity.bo";
+import {ValidationResult} from "@colijnit/ioneconnector/build/model/validation-result";
+import {Task} from "@colijnit/mainapi/build/model/task.bo";
+import {WorkflowProcessInfoPerStatus} from "@colijnit/mainapi/build/model/workflow-process-info-per-status";
+import {RelationSmallObject} from "@colijnit/mainapi/build/model/relation-small-object.bo";
+import {SelectReportTemplatesRequest} from "@colijnit/mainapi/build/model/select-report-templates-request";
+import {Report} from "@colijnit/mainapi/build/model/report.bo";
+import {ReportType} from "@colijnit/mainapi/build/enum/report-type.enum";
+import {SendMethodType} from "@colijnit/mainapi/build/enum/send-method-type.enum";
+import {EmailJob} from "@colijnit/mainapi/build/model/email-job";
+import {LanguageCode} from "../enum/language-code.enum";
+import {Work} from "@colijnit/mainapi/build/model/work.bo";
+import {Remark} from "@colijnit/mainapi/build/model/remark.bo";
+import {ActivityEmailHistory} from "@colijnit/mainapi/build/model/activity-email-history.bo";
+import {ActivityWorkflow} from "@colijnit/mainapi/build/model/activity-workflow";
+import {CoEmailAttachment} from "@colijnit/mainapi/build/model/co-email-attachment.bo";
+import {SharedComponentsDictionaryService} from '../translation/shared-components-dictionary.service';
+import {CoDocument} from "@colijnit/mainapi/build/model/co-document.bo";
+import {EmailActivityRequest} from "@colijnit/mainapi/build/model/email-activity-request";
+
+
+
+@Injectable({
+  providedIn: "root"
+})
+
+export class SharedService {
+
+  constructor(
+    @Inject(LOCALE_ID) protected readonly locale: LanguageCode,
+    protected options: OptionsService,
+    protected connector: SharedConnectorService,
+    protected dictionary: SharedComponentsDictionaryService
+  ) {
+  }
+
+  public async init(options: any): Promise<void> {
+    await this.options.initialize(options);
+    await this.connector.connect();
+  }
+
+  public async connect(): Promise<void> {
+    await this.connector.connect();
+  }
+
+  public async getAllPrinters(): Promise<Printer[]> {
+    return await this.connector.getAllPrinters();
+  }
+
+  public async getDefaultPrinter(reportId: number, layoutCode: string): Promise<string> {
+    return await this.connector.getDefaultPrinter(reportId, layoutCode);
+  }
+
+  public async getSendMethods(): Promise<SendMethod[]> {
+    return await this.connector.getSendMethods();
+  }
+
+  public async getScreenConfigTree(): Promise<any> {
+    return await this.connector.getScreenConfigTree();
+  }
+
+  public async getScreenConfigSubRubric(parentRubricId: number, configId: number, fixedKey: string): Promise<any> {
+    return await this.connector.getScreenConfigSubRubric(parentRubricId, configId, fixedKey);
+  }
+
+  public async getTagsFullTree(category: TagCategory, includeTags: boolean = true): Promise<TagTreeItem[]> {
+    return await this.connector.getTagsFullTree(category, includeTags);
+  }
+
+  public async getJoinedTags(table: string, key: string): Promise<TagTreeItem[]> {
+    return await this.connector.getJoinedTags(table, key);
+  }
+
+  public async getDocumentContent(docId: number, thumbnail: boolean = true): Promise<string> {
+    return await this.connector.getDocumentContent(docId, thumbnail);
+  }
+
+  public async getComponentActivitiesWithoutRelationFiltering(table: TableName, key: string): Promise<Activity[]> {
+    return await this.connector.getComponentActivitiesWithoutRelationFiltering(table, key);
+  }
+
+  public async getRelationSmallObject(relationId: number): Promise<RelationSmallObject> {
+    return await this.connector.getRelationSmallObject(relationId);
+  }
+
+  public async getWorkflowStatusForActivity(table: TableName, key: string, component: string ): Promise<ActivityWorkflow> {
+    return await this.connector.getWorkflowStatusForActivity(table, key, component);
+  }
+
+  public async insertActivity(activity: Activity): Promise<boolean> {
+    return await this.connector.insertActivity(activity);
+  }
+
+  public async insertWork(activity: Activity): Promise<Work> {
+    return await this.connector.insertWork(activity);
+  }
+
+  public async insertRemark(activity: Activity): Promise<Remark> {
+    return await this.connector.insertRemark(activity);
+  }
+
+  public async insertTask(activity: Activity): Promise<Task> {
+    return await this.connector.insertTask(activity);
+  }
+
+  public async updateActivity(activity: Activity): Promise<boolean> {
+    return await this.connector.updateActivity(activity);
+  }
+
+  public async deleteActivity(activity: Activity): Promise<boolean> {
+    return await this.connector.deleteActivity(activity);
+  }
+
+  public async lockTask(id: number): Promise<boolean> {
+    return await this.connector.lockTask(id);
+  }
+
+  public canFireTrigger(activity:Activity, task: Task ): boolean {
+      return true;
+  }
+
+  public async fireTrigger(workFlowProcessId: number, sequence: number, triggerId: number): Promise<ValidationResult> {
+    return await this.connector.fireTrigger(workFlowProcessId, sequence, triggerId);
+  }
+
+  public async fireGenericTrigger(workFlowProcessId: number, genericTransitionId: number, relationId: number): Promise<ValidationResult> {
+    return await this.connector.fireGenericTrigger(workFlowProcessId, genericTransitionId, relationId);
+  }
+
+  public async getRelationListObjects(request: RelationRequest): Promise<RelationListObject[]> {
+    return await this.connector.getRelationListObjects(request);
+  }
+
+  public async getTaskCategories(): Promise<TaskCategory[]> {
+    return await this.connector.getTaskCategories();
+  }
+
+  public async getActiveProcessesByTableAndKey(table: TableName, key: string): Promise<WorkflowProcess[]> {
+    return await this.connector.getActiveProcessesByTableAndKey(table, key);
+  }
+
+  public async getDomainCollection(languageCode: string, domainName: DomainName): Promise<CoDomainValue[]> {
+    return await this.connector.getDomainCollection(languageCode, domainName);
+  }
+
+  public async getRoleEmailAddressesByWorkflowCategoryAndKey(workflowCategory: string, key: string): Promise<RoleEmailaddress[]> {
+    return await this.connector.getRoleEmailAddressesByWorkflowCategoryAndKey(workflowCategory, key);
+  }
+
+  public async getEmailSenderByWorkflowCategoryAndKey(workflowCategory: string, key: string): Promise<string> {
+    return await this.connector.getEmailSenderByWorkflowCategoryAndKey(workflowCategory, key);
+  }
+
+  public async getDefaultEmailReportTemplatesForBranch(branchNr: string, reportType: ReportType): Promise<Report[]> {
+    let reportTemplatesRequest: SelectReportTemplatesRequest = new SelectReportTemplatesRequest();
+    reportTemplatesRequest.branchNr = branchNr;
+    reportTemplatesRequest.documentCode = reportType;
+    reportTemplatesRequest.sendMethod = SendMethodType.Email;
+
+    return await this.connector.getReportTemplates(reportTemplatesRequest);
+  }
+
+  public async emailViaTemplate(template: Report,
+                                 emailTo: string,
+                                 emailBcc: string,
+                                 reply: string,
+                                 subject: string = "",
+                                 message: string = "",
+                                 attachments: CoEmailAttachment[] = [],
+                                 parameters: object = {} ): Promise<boolean> {
+    const subjectAddition: string = subject.trim();
+    const emailJob: EmailJob = this._createEmailJob(template, emailTo, emailBcc, reply, subjectAddition, message, attachments, parameters);
+    return this.connector.emailReport(emailJob);
+  }
+
+  private _createEmailJob(report: Report, emailTo: string, emailBcc: string, reply: string,  subject: string, message: string, attachments: CoEmailAttachment[], parameters: object = {}): EmailJob {
+    const emailJob: EmailJob = new EmailJob();
+    emailJob.emailTo = emailTo;
+    emailJob.emailBcc = emailBcc;
+    emailJob.reply = reply;
+    emailJob.subject = subject;
+    emailJob.message = message;
+    emailJob.attachments = attachments;
+
+    emailJob.reportId = report.reportId;
+    emailJob.parameterValues = parameters;
+    emailJob.locale = this.locale;
+    return emailJob;
+  }
+
+  public async emailActivity(emailActivityRequest: EmailActivityRequest): Promise<CoDocument | boolean> {
+    let result: CoDocument | boolean = await this.connector.emailActivity(emailActivityRequest);
+    return result;
+  }
+
+  public async insertEmailHistoryForRemark(history: ActivityEmailHistory): Promise<boolean> {
+      return await this.connector.insertEmailHistoryForRemark(history);
+  }
+
+  public async insertEmailHistoryForWork(history: ActivityEmailHistory): Promise<boolean> {
+    return await this.connector.insertEmailHistoryForWork(history);
+  }
+
+  public async insertEmailHistoryForTask(history: ActivityEmailHistory): Promise<boolean> {
+    return await this.connector.insertEmailHistoryForTask(history);
+  }
+
+  public async getWorkflowProcessInfoPerStatus(workflowCategory: string): Promise<WorkflowProcessInfoPerStatus[]> {
+    return await this.connector.getWorkflowProcessInfoPerStatus(workflowCategory);
+  }
+
+  public async getActivities(table: TableName, key: string): Promise<Activity[]> {
+    const activities: Activity[] = await this.connector.getComponentActivities(table, key);
+    const histActivities: Activity[] = await this.connector.getHistoricActivities(table, key);
+    const activeActivities: Activity[] = [];
+    const historicActivities: Activity[] = [];
+    if (activities && activities.length > 0) {
+      activities.forEach((activity: Activity) => {
+        activeActivities.push(activity);
+      });
+    }
+    if (histActivities && histActivities.length > 0) {
+      histActivities.forEach((activity: Activity) => {
+        historicActivities.push(activity);
+      });
+    }
+    return activeActivities.concat(historicActivities);
+  }
+}

package/projects/sharedcomponents/src/lib/service/stock.service.ts

@@ -0,0 +1,124 @@
+import {EventEmitter, Injectable} from "@angular/core";
+import {PrintStockStickers} from "@colijnit/sharedapi/build/model/print-stock-stickers";
+import {GetStockHistoryRequest} from "@colijnit/articleapi/build/model/get-stock-history-request";
+import {ArticleStock as ArticleStockBo} from "@colijnit/articleapi/build/model/article-stock.bo";
+import {ArticleStock} from "@colijnit/articleapi/build/model/article-stock";
+import {StockHistoryBo} from "@colijnit/articleapi/build/model/stock-history.bo";
+import {ArticleDetailsBo} from "@colijnit/articleapi/build/model/article-details.bo";
+import {ArticleStockManagement} from "@colijnit/articleapi/build/model/article-stock-management";
+import {StockStatus} from "@colijnit/articleapi/build/model/stock-status.bo";
+import {StockManagementWarehouses} from "@colijnit/articleapi/build/model/stock-management-warehouses.bo";
+import {StockLocation} from "@colijnit/articleapi/build/model/stock-location.bo";
+import {ArticleTransaction} from "@colijnit/articleapi/build/model/article-transaction";
+import {ArticleTransaction as ArticleTransactionBo} from "@colijnit/articleapi/build/model/article-transaction.bo";
+import {SharedConnectorService} from "./shared-connector.service";
+import {SendMethodParams} from "../components/send-method-dialog/send-method-params.interface";
+import {DataServiceResponseData} from '@colijnit/ioneconnector/build/model/data-service-response-data';
+import {StockForecast} from "@colijnit/articleapi/build/model/stock-forecast.bo";
+import {ArticleExtendedRequest} from "@colijnit/articleapi/build/model/article-extended-request";
+import {ArticleExtended} from "@colijnit/articleapi/build/model/article-extended.bo";
+import {ArticleFlat} from "@colijnit/articleapi/build/model/article-flat.bo";
+
+@Injectable({
+  providedIn: 'root',
+})
+export class StockService {
+
+  public stockStickers: PrintStockStickers;
+  public printLayoutParams: SendMethodParams;
+
+  constructor(
+    private _sharedService: SharedConnectorService,
+  ) {
+  }
+
+  // public async getPrintStockStickers(data: PrintStockStickers): Promise<void> {
+  //   await this._sharedService.getPrintStockStickers(data);
+  // }
+
+  // public async getPrintPriceStickers(data: PrintPriceStickers): Promise<void> {
+  //   await this._sharedService.getPrintPriceStickers(data);
+  // }
+
+  public async getStockHistory(data: GetStockHistoryRequest): Promise<StockHistoryBo[]> {
+    return await this._sharedService.getStockHistory(data);
+  }
+
+  public async getStockInformation(data: ArticleStock): Promise<ArticleStockBo[]> {
+    return await this._sharedService.getStockInformation(data);
+  }
+
+  // public async getStockStickerPrintLayouts(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+  //   return await this._connector.getStockStickerPrintLayouts(data);
+  // }
+
+  public async getArticleDetails(data: ArticleStockManagement): Promise<ArticleDetailsBo[]> {
+    return await this._sharedService.getArticleDetails(data);
+  }
+
+  public async updateArticleDetails(data: ArticleDetailsBo): Promise<boolean> {
+    return await this._sharedService.updateArticleDetails(data);
+  }
+
+  public async getStockState(): Promise<StockStatus[]> {
+    return await this._sharedService.getStockStatus();
+  }
+
+  public async getArtStockStatus(goodId: number, branchNo?: string, requestedAmount?: number, warehouseId?: number): Promise<number> {
+    return await this._sharedService.getArtStockStatus(goodId, branchNo, requestedAmount, warehouseId);
+  }
+
+  // public async getStockStickerTemplates(data: StockStickersPrintLayouts): Promise<StockStickersPrintLayouts[]> {
+  //   return await this._sharedService.getStockStickerTemplates(data);
+  // }
+
+  public async getStockManagementWarehouses(): Promise<StockManagementWarehouses[]> {
+    return await this._sharedService.getStockManagementWarehouses();
+  }
+
+  public async getStockManagementLocations(warehouseNo: number): Promise<StockLocation[]> {
+    return await this._sharedService.getStockManagementLocations(warehouseNo);
+  }
+
+  // public async getOrderConfirmationDefaultSendMethod(relationId: number): Promise<number> {
+  //   return await this._sharedService.getOrderConfirmationDefaultSendMethod(relationId);
+  // }
+
+  // public async getDefaultEmailAddressListForOrderConfirmation(transactionUUID: string): Promise<string[]> {
+  //   return await this._sharedService.getDefaultEmailAddressListForOrderConfirmation(transactionUUID);
+  // }
+
+  // public async getPurchaseOrderEmailLayouts(transactionUUID: string): Promise<StockStickersEmailLayouts[]> {
+  //   return await this._sharedService.getPurchaseOrderEmailLayouts(transactionUUID);
+  // }
+
+  public async getArticleTransaction(data: ArticleTransaction): Promise<ArticleTransactionBo[]> {
+    return await this._sharedService.getArticleTransaction(data);
+  }
+
+  public async stockPrognose(goodId: number, warehouseNumber: number): Promise<StockForecast[]> {
+    return await this._sharedService.getStockPrognose(goodId, warehouseNumber);
+  }
+
+  public async lockArticleDetails(data: ArticleStockManagement): Promise<boolean> {
+    return await this._sharedService.lockArticleDetails(data);
+  }
+
+  public commit(): Promise<DataServiceResponseData> {
+    return this._sharedService.commit();
+  }
+
+  public async getArticleFlat(sku: string): Promise<ArticleFlat> {
+    return await this._sharedService.getArticleFlat(sku);
+  }
+
+  public async searchArticles(request: ArticleExtendedRequest): Promise<ArticleExtended[]> {
+    return await this._sharedService.searchArticles(request);
+  }
+
+
+
+
+
+
+}

package/projects/sharedcomponents/src/lib/translation/shared-components-dictionary.service.ts

@@ -0,0 +1,73 @@
+import {Injectable} from '@angular/core';
+import {StringUtils} from '@colijnit/ioneconnector/build/utils/string-utils';
+import {Dictionaries} from '../res/dictionary/dictionaries';
+import {LanguageCode} from '@colijnit/ioneconnector/build/enum/language-code.enum';
+
+// The localization service, providing peers with text translation functionality.
+@Injectable({
+  providedIn: "root"
+})
+export class SharedComponentsDictionaryService {
+  public get language(): string {
+    return this._language;
+  }
+
+  // private _dictionaryPromise: Map<LanguageCode, Promise<{ [key: string]: string }>> = new Map<LanguageCode, Promise<{ [key: string]: string }>>();
+  private _dictionaryPromise: Map<LanguageCode, Promise<{ [key: string]: string }>> = new Map<LanguageCode, Promise<{ [key: string]: string }>>();
+  private _dictionaries: Map<LanguageCode, { [key: string]: string }> = new Map<LanguageCode, { [key: string]: string }>();
+  private _language: LanguageCode;
+
+  // Some dictionary values have one or more '|~' texts in them, meant to be replaced with client-side given texts.
+  private readonly _placeholder: string = "|~";
+
+  constructor(
+  ) {
+  }
+
+  // Loads the dictionary for given language in memory.
+  public async setDictionary(language: LanguageCode): Promise<void> {
+    this._language = language;
+    if (!this._dictionaryPromise.has(language)) {
+      const dictionaries: Dictionaries = new Dictionaries();
+      if (dictionaries.hasOwnProperty("text_" + language.substr(0, 2).toLowerCase())) {
+        this._dictionaries.set(language, dictionaries["text_" + language.substr(0, 2).toLowerCase()]);
+      }
+    }
+    await this._dictionaryPromise.get(language);
+  }
+
+  /**
+   * Returns the localized text for the given dictionary key.
+   * @param {string} key
+   * @param {boolean} [upperCaseFirst = true] False for first letter lowercase, true for first letter uppercase for returned dict val
+   * @param {string[]} replacementTexts Rest params for replacement of '|~' in returned dict value
+   * @returns {string} The translated text for given dictionary key
+   */
+  public get(key: string, upperCaseFirst: boolean = true, ...replacementTexts: string[]): string {
+    if (!StringUtils.IsStringWithLength(key)) {
+      return key || "";
+    } else if (!this._dictionaryLoaded(this._language)) {
+      return key;
+    }
+
+    let text: string = this._dictionaries.get(this._language)[key];
+    text = StringUtils.IsStringWithLength(text) ? text : key;
+
+    if (upperCaseFirst) {
+      text = text.charAt(0).toUpperCase() + text.slice(1);
+    } else {
+      text = text.charAt(0).toLowerCase() + text.slice(1);
+    }
+
+    if (replacementTexts.length > 0) {
+      text = StringUtils.ReplaceOccurrencesIn(text, this._placeholder, ...replacementTexts);
+    }
+
+    return text;
+  }
+
+
+  private _dictionaryLoaded(language: LanguageCode): boolean {
+    return this._dictionaries.has(language);
+  }
+}

package/projects/sharedcomponents/src/lib/translation/shared-components-translation.module.ts

@@ -0,0 +1,12 @@
+import {NgModule} from '@angular/core';
+import {SharedLocalizePipe} from './shared-localize.pipe';
+
+@NgModule({
+  declarations: [
+    SharedLocalizePipe
+  ],
+  exports: [
+    SharedLocalizePipe
+  ]
+})
+export class SharedComponentsTranslationModule {}

package/projects/sharedcomponents/src/lib/translation/shared-localize.pipe.ts

@@ -0,0 +1,21 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {SharedComponentsDictionaryService} from './shared-components-dictionary.service';
+
+@Pipe({
+  name: "sharedLocalize"
+})
+export class SharedLocalizePipe implements PipeTransform {
+
+  constructor(private _dictionaryService: SharedComponentsDictionaryService) {}
+
+  transform(value: string, upperCaseFirst: boolean = true, replace: string|string[] = []): string {
+    if (!value) {
+      return "";
+    }
+    replace = (replace !== undefined && replace !== null) ? replace : [];
+    if (!Array.isArray(replace)) {
+      replace = [replace];
+    }
+    return this._dictionaryService.get(value, upperCaseFirst, ...replace);
+  }
+}

package/projects/sharedcomponents/src/lib/typings/local/fingerprintjs2/index.d.ts

@@ -0,0 +1,42 @@
+declare class Fingerprint2 {
+    static VERSION: string;
+    constructor(options?: Fingerprint2Options);
+
+    get(callback: (result: string, components: [{ key: string, value: string }]) => void): number;
+}
+
+export interface Fingerprint2Options {
+    swfContainerId?: string;
+    swfPath?: string;
+    userDefinedFonts?: string[];
+    excludeUserAgent?: boolean;
+    excludeLanguage?: boolean;
+    excludeColorDepth?: boolean;
+    excludeScreenResolution?: boolean;
+    excludeTimezoneOffset?: boolean;
+    excludeSessionStorage?: boolean;
+    excludeIndexedDB?: boolean;
+    excludeAddBehavior?: boolean;
+    excludeOpenDatabase?: boolean;
+    excludeCpuClass?: boolean;
+    excludePlatform?: boolean;
+    excludeDoNotTrack?: boolean;
+    excludeCanvas?: boolean;
+    excludeWebGL?: boolean;
+    excludeAdBlock?: boolean;
+    excludeHasLiedLanguages?: boolean;
+    excludeHasLiedResolution?: boolean;
+    excludeHasLiedOs?: boolean;
+    excludeHasLiedBrowser?: boolean;
+    excludeJsFonts?: boolean;
+    excludeFlashFonts?: boolean;
+    excludePlugins?: boolean;
+    excludeIEPlugins?: boolean;
+    excludeTouchSupport?: boolean;
+    excludePixelRatio?: boolean;
+    excludeHardwareConcurrency?: boolean;
+}
+
+declare module "fingerprintjs2" {
+    export default Fingerprint2;
+}