@qbs-origin/origin-form 0.5.0

package/esm2022/lib/others/picker.component.mjs

@@ -0,0 +1,119 @@
+import { Component, EventEmitter, Input, Output, } from '@angular/core';
+import { Observable, map, startWith } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/material/form-field";
+import * as i5 from "@angular/material/autocomplete";
+import * as i6 from "@angular/material/core";
+import * as i7 from "@angular/material/chips";
+import * as i8 from "@angular/material/icon";
+export class PickerComponent {
+    constructor(builder) {
+        this.builder = builder;
+        this.selections = [];
+        this.readonly = false;
+        this.inputVisible = true;
+        this.displayProperty = 'name';
+        this.iconProperty = 'icon';
+        this.picked = new EventEmitter();
+        this.removed = new EventEmitter();
+        this.form = this.builder.group({
+            picker: [''],
+        });
+        this.groups = [];
+    }
+    ngOnInit() {
+        this.refresh();
+    }
+    ngOnChanges(changes) {
+        if (changes['data']) {
+            this.refresh();
+        }
+        if (changes['selections']) {
+            this.refresh();
+        }
+    }
+    refresh() {
+        if (this.data instanceof Observable) {
+            this.data.subscribe({
+                next: (data) => {
+                    this.getItems(data);
+                },
+            });
+        }
+        else {
+            this.getItems(this.data);
+        }
+    }
+    getItems(data) {
+        this.groups = [];
+        if (data && data.length) {
+            data.forEach((item) => {
+                if (item) {
+                    const letter = item[this.displayProperty][0];
+                    if (!this.groups.some((i) => i.key == letter)) {
+                        this.groups.push({ key: letter, values: [] });
+                    }
+                    const object = this.groups.find((i) => i.key == letter);
+                    object?.values.push(item);
+                }
+            });
+            this.groups.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+            this.options = this.form.get('picker').valueChanges.pipe(startWith(''), map((value) => this.filter(value || '')));
+        }
+    }
+    filter(value) {
+        if (typeof value === 'string') {
+            return this.groups
+                .map((group) => ({
+                key: group.key,
+                values: filter(group.values, this.selections, value, this.displayProperty),
+            }))
+                .filter((group) => group.values.length > 0);
+        }
+        return [];
+    }
+    selected(value) {
+        this.selections.push(value);
+        this.form.get('picker')?.setValue('');
+        this.picked.emit(value);
+    }
+    remove(value) {
+        this.selections.splice(this.selections.findIndex((i) => i[this.displayProperty] === value[this.displayProperty]), 1);
+        this.form.get('picker')?.setValue('');
+        this.removed.emit(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PickerComponent, deps: [{ token: i1.FormBuilder }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: PickerComponent, selector: "shared-picker", inputs: { data: "data", selections: "selections", placeholder: "placeholder", readonly: "readonly", inputVisible: "inputVisible", displayProperty: "displayProperty", iconProperty: "iconProperty" }, outputs: { picked: "picked", removed: "removed" }, usesOnChanges: true, ngImport: i0, template: "<form [formGroup]=\"form\">\n  <mat-form-field appearance=\"outline\" class=\"w-100 hide-hint\" [class.disabled]=\"readonly\" [hidden]=\"true\"\n    *ngIf=\"inputVisible\">\n    <input type=\"text\" matInput [placeholder]=\"placeholder ?? ''\" [readonly]=\"readonly\" [disabled]=\"readonly\"\n      formControlName=\"picker\" [matAutocomplete]=\"autocomplete\" />\n    <mat-icon matPrefix>\n      <i-tabler name=\"arrow-down-right\" class=\"icon-20 d-flex\"></i-tabler>\n    </mat-icon>\n\n    <mat-autocomplete #autocomplete=\"matAutocomplete\" (optionSelected)=\"selected($event.option.value)\">\n      <mat-optgroup *ngFor=\"let group of options | async\" [label]=\"group.key\">\n        <mat-option *ngFor=\"let value of group.values\" [value]=\"value\">\n          <div class=\"button-cell\">\n            <mat-icon *ngIf=\"value[iconProperty]\">{{ value[iconProperty] }}</mat-icon>\n            {{ value[displayProperty] }}\n          </div>\n        </mat-option>\n      </mat-optgroup>\n    </mat-autocomplete>\n  </mat-form-field>\n\n  <mat-chip-set>\n    <mat-chip *ngFor=\"let value of selections\" (removed)=\"remove(value)\" [disabled]=\"readonly\" class=\"f-s-14\">\n      <div class=\"button-cell\">\n        <mat-icon *ngIf=\"value[iconProperty]\">{{ value[iconProperty] }}</mat-icon>\n        {{ value[displayProperty] }}\n      </div>\n      <button matChipRemove>\n        <mat-icon>cancel</mat-icon>\n      </button>\n    </mat-chip>\n  </mat-chip-set>\n</form>", styles: [".button-cell{display:flex;align-items:center}::ng-deep mat-form-field.disabled{opacity:.6;pointer-events:none}::ng-deep mat-form-field.disabled .mat-form-field-outline{border-color:#bdbdbd!important}::ng-deep mat-form-field.disabled .mat-input-element{color:#9e9e9e!important;cursor:not-allowed!important}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i3.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i4.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i4.MatPrefix, selector: "[matPrefix], [matIconPrefix], [matTextPrefix]", inputs: ["matTextPrefix"] }, { kind: "component", type: i5.MatAutocomplete, selector: "mat-autocomplete", inputs: ["aria-label", "aria-labelledby", "displayWith", "autoActiveFirstOption", "autoSelectActiveOption", "requireSelection", "panelWidth", "disableRipple", "class", "hideSingleSelectionIndicator"], outputs: ["optionSelected", "opened", "closed", "optionActivated"], exportAs: ["matAutocomplete"] }, { kind: "component", type: i6.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "component", type: i6.MatOptgroup, selector: "mat-optgroup", inputs: ["label", "disabled"], exportAs: ["matOptgroup"] }, { kind: "directive", type: i5.MatAutocompleteTrigger, selector: "input[matAutocomplete], textarea[matAutocomplete]", inputs: ["matAutocomplete", "matAutocompletePosition", "matAutocompleteConnectedTo", "autocomplete", "matAutocompleteDisabled"], exportAs: ["matAutocompleteTrigger"] }, { kind: "component", type: i7.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["role", "id", "aria-label", "aria-description", "value", "color", "removable", "highlighted", "disableRipple", "disabled"], outputs: ["removed", "destroyed"], exportAs: ["matChip"] }, { kind: "directive", type: i7.MatChipRemove, selector: "[matChipRemove]" }, { kind: "component", type: i7.MatChipSet, selector: "mat-chip-set", inputs: ["disabled", "role", "tabIndex"] }, { kind: "component", type: i8.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'shared-picker', template: "<form [formGroup]=\"form\">\n  <mat-form-field appearance=\"outline\" class=\"w-100 hide-hint\" [class.disabled]=\"readonly\" [hidden]=\"true\"\n    *ngIf=\"inputVisible\">\n    <input type=\"text\" matInput [placeholder]=\"placeholder ?? ''\" [readonly]=\"readonly\" [disabled]=\"readonly\"\n      formControlName=\"picker\" [matAutocomplete]=\"autocomplete\" />\n    <mat-icon matPrefix>\n      <i-tabler name=\"arrow-down-right\" class=\"icon-20 d-flex\"></i-tabler>\n    </mat-icon>\n\n    <mat-autocomplete #autocomplete=\"matAutocomplete\" (optionSelected)=\"selected($event.option.value)\">\n      <mat-optgroup *ngFor=\"let group of options | async\" [label]=\"group.key\">\n        <mat-option *ngFor=\"let value of group.values\" [value]=\"value\">\n          <div class=\"button-cell\">\n            <mat-icon *ngIf=\"value[iconProperty]\">{{ value[iconProperty] }}</mat-icon>\n            {{ value[displayProperty] }}\n          </div>\n        </mat-option>\n      </mat-optgroup>\n    </mat-autocomplete>\n  </mat-form-field>\n\n  <mat-chip-set>\n    <mat-chip *ngFor=\"let value of selections\" (removed)=\"remove(value)\" [disabled]=\"readonly\" class=\"f-s-14\">\n      <div class=\"button-cell\">\n        <mat-icon *ngIf=\"value[iconProperty]\">{{ value[iconProperty] }}</mat-icon>\n        {{ value[displayProperty] }}\n      </div>\n      <button matChipRemove>\n        <mat-icon>cancel</mat-icon>\n      </button>\n    </mat-chip>\n  </mat-chip-set>\n</form>", styles: [".button-cell{display:flex;align-items:center}::ng-deep mat-form-field.disabled{opacity:.6;pointer-events:none}::ng-deep mat-form-field.disabled .mat-form-field-outline{border-color:#bdbdbd!important}::ng-deep mat-form-field.disabled .mat-input-element{color:#9e9e9e!important;cursor:not-allowed!important}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormBuilder }], propDecorators: { data: [{
+                type: Input
+            }], selections: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], inputVisible: [{
+                type: Input
+            }], displayProperty: [{
+                type: Input
+            }], iconProperty: [{
+                type: Input
+            }], picked: [{
+                type: Output
+            }], removed: [{
+                type: Output
+            }] } });
+export const filter = (options, selections, value, displayProperty) => {
+    return options.filter((item) => (value
+        ? item[displayProperty].toLowerCase().includes(value.toLowerCase())
+        : true) &&
+        !selections?.some((i) => i[displayProperty] == item[displayProperty]));
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"picker.component.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/others/picker.component.ts","../../../../../projects/origin-form/src/lib/others/picker.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    EventEmitter,\n    Input,\n    OnInit,\n    Output,\n    SimpleChanges,\n} from '@angular/core';\nimport { FormBuilder } from '@angular/forms';\nimport { Observable, map, startWith } from 'rxjs';\n\n@Component({\n  selector: 'shared-picker',\n  templateUrl: './picker.component.html',\n  styleUrls: ['./picker.component.scss']\n})\nexport class PickerComponent implements OnInit {\n  @Input() data: any;\n  @Input() selections: any[] = [];\n  @Input() placeholder: string | undefined;\n  @Input()\n  readonly: boolean = false;\n  @Input() inputVisible: boolean = true;\n  @Input() displayProperty: string = 'name';\n  @Input() iconProperty: string = 'icon';\n  @Output() picked = new EventEmitter<any>();\n  @Output() removed = new EventEmitter<any>();\n\n  form = this.builder.group({\n    picker: [''],\n  });\n\n  groups: Group[] = [];\n  options: Observable<Group[]> | undefined;\n\n  constructor(private builder: FormBuilder) {}\n\n  ngOnInit(): void {\n    this.refresh();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['data']) {\n      this.refresh();\n    }\n    if (changes['selections']) {\n      this.refresh();\n    }\n  }\n\n  refresh() {\n    if (this.data instanceof Observable) {\n      this.data.subscribe({\n        next: (data: any[]) => {\n          this.getItems(data);\n        },\n      });\n    } else {\n      this.getItems(this.data as any[]);\n    }\n  }\n\n  getItems(data: any[]) {\n    this.groups = [];\n    if (data && data.length) {\n      data.forEach((item: any) => {\n        if (item) {\n          const letter = item[this.displayProperty][0];\n\n          if (!this.groups.some((i) => i.key == letter)) {\n            this.groups.push({ key: letter, values: [] });\n          }\n\n          const object = this.groups.find((i) => i.key == letter);\n          object?.values.push(item);\n        }\n      });\n\n      this.groups.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));\n\n      this.options = this.form.get('picker')!.valueChanges.pipe(\n        startWith(''),\n        map((value) => this.filter(value || ''))\n      );\n    }\n  }\n\n  private filter(value: string): Group[] {\n    if (typeof value === 'string') {\n      return this.groups\n        .map((group) => ({\n          key: group.key,\n          values: filter(\n            group.values,\n            this.selections,\n            value,\n            this.displayProperty\n          ),\n        }))\n        .filter((group) => group.values.length > 0);\n    }\n\n    return [];\n  }\n\n  selected(value: any): void {\n    this.selections.push(value);\n    this.form.get('picker')?.setValue('');\n\n    this.picked.emit(value);\n  }\n\n  remove(value: any): void {\n    this.selections.splice(\n      this.selections.findIndex(\n        (i) => i[this.displayProperty] === value[this.displayProperty]\n      ),\n      1\n    );\n    this.form.get('picker')?.setValue('');\n\n    this.removed.emit(value);\n  }\n}\n\nexport interface Group {\n  key: string;\n  values: any[];\n}\n\nexport const filter = (\n  options: any[],\n  selections: any[],\n  value: string,\n  displayProperty: string\n): string[] => {\n  return options.filter(\n    (item) =>\n      (value\n        ? item[displayProperty].toLowerCase().includes(value.toLowerCase())\n        : true) &&\n      !selections?.some((i) => i[displayProperty] == item[displayProperty])\n  );\n};\n","<form [formGroup]=\"form\">\n  <mat-form-field appearance=\"outline\" class=\"w-100 hide-hint\" [class.disabled]=\"readonly\" [hidden]=\"true\"\n    *ngIf=\"inputVisible\">\n    <input type=\"text\" matInput [placeholder]=\"placeholder ?? ''\" [readonly]=\"readonly\" [disabled]=\"readonly\"\n      formControlName=\"picker\" [matAutocomplete]=\"autocomplete\" />\n    <mat-icon matPrefix>\n      <i-tabler name=\"arrow-down-right\" class=\"icon-20 d-flex\"></i-tabler>\n    </mat-icon>\n\n    <mat-autocomplete #autocomplete=\"matAutocomplete\" (optionSelected)=\"selected($event.option.value)\">\n      <mat-optgroup *ngFor=\"let group of options | async\" [label]=\"group.key\">\n        <mat-option *ngFor=\"let value of group.values\" [value]=\"value\">\n          <div class=\"button-cell\">\n            <mat-icon *ngIf=\"value[iconProperty]\">{{ value[iconProperty] }}</mat-icon>\n            {{ value[displayProperty] }}\n          </div>\n        </mat-option>\n      </mat-optgroup>\n    </mat-autocomplete>\n  </mat-form-field>\n\n  <mat-chip-set>\n    <mat-chip *ngFor=\"let value of selections\" (removed)=\"remove(value)\" [disabled]=\"readonly\" class=\"f-s-14\">\n      <div class=\"button-cell\">\n        <mat-icon *ngIf=\"value[iconProperty]\">{{ value[iconProperty] }}</mat-icon>\n        {{ value[displayProperty] }}\n      </div>\n      <button matChipRemove>\n        <mat-icon>cancel</mat-icon>\n      </button>\n    </mat-chip>\n  </mat-chip-set>\n</form>"]}

package/esm2022/lib/others/translation.pipe.mjs

@@ -0,0 +1,21 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/translation.service";
+export class TranslatePipe {
+    constructor(translationService) {
+        this.translationService = translationService;
+    }
+    transform(value, args) {
+        return this.translationService.translate(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslatePipe, deps: [{ token: i1.TranslationService }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TranslatePipe, name: "translate", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'translate',
+                    pure: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslationService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRpb24ucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29yaWdpbi1mb3JtL3NyYy9saWIvb3RoZXJzL3RyYW5zbGF0aW9uLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7OztBQU9wRCxNQUFNLE9BQU8sYUFBYTtJQUN4QixZQUFvQixrQkFBc0M7UUFBdEMsdUJBQWtCLEdBQWxCLGtCQUFrQixDQUFvQjtJQUFJLENBQUM7SUFFL0QsU0FBUyxDQUFDLEtBQVUsRUFBRSxJQUFVO1FBQzlCLE9BQU8sSUFBSSxDQUFDLGtCQUFrQixDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNsRCxDQUFDOytHQUxVLGFBQWE7NkdBQWIsYUFBYTs7NEZBQWIsYUFBYTtrQkFKekIsSUFBSTttQkFBQztvQkFDSixJQUFJLEVBQUUsV0FBVztvQkFDakIsSUFBSSxFQUFFLEtBQUs7aUJBQ1oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUcmFuc2xhdGlvblNlcnZpY2UgfSBmcm9tICcuLi9zZXJ2aWNlcy90cmFuc2xhdGlvbi5zZXJ2aWNlJztcblxuQFBpcGUoe1xuICBuYW1lOiAndHJhbnNsYXRlJyxcbiAgcHVyZTogZmFsc2UsXG59KVxuZXhwb3J0IGNsYXNzIFRyYW5zbGF0ZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSB0cmFuc2xhdGlvblNlcnZpY2U6IFRyYW5zbGF0aW9uU2VydmljZSkgeyB9XG5cbiAgdHJhbnNmb3JtKHZhbHVlOiBhbnksIGFyZ3M/OiBhbnkpOiBhbnkge1xuICAgIHJldHVybiB0aGlzLnRyYW5zbGF0aW9uU2VydmljZS50cmFuc2xhdGUodmFsdWUpO1xuICB9XG59XG4iXX0=

package/esm2022/lib/others/translations-helper.mjs

@@ -0,0 +1,258 @@
+import { Injectable } from "@angular/core";
+import { StepControlType } from "../models/flux.model";
+import * as i0 from "@angular/core";
+export class TranslationsHelper {
+    static createComponentErrorsTranslations(langs, componentType) {
+        switch (componentType) {
+            case StepControlType.ManualInput: return this.createInputErrorsTranslations(langs);
+            case StepControlType.CheckBox:
+            case StepControlType.Dictionary: return this.createDefaultErrorsTranslations(langs);
+            case StepControlType.DownloadDocuments: return this.createDownloadErrorsTranslations(langs);
+            case StepControlType.UploadDocuments: return this.createUploadErrorsTranslations(langs);
+            case StepControlType.ViewDocuments: return this.createViewErrorsTranslations(langs);
+        }
+        return [];
+    }
+    static createDownloadErrorsTranslations(langs) {
+        const tInfo = [
+            {
+                code: 'failToDownload',
+                translations: this.createLabelsInfo(langs, 'Failed to download.', 'Nu am reușit sa descarc.')
+            },
+            {
+                code: 'noDocumentsToDownload',
+                translations: this.createLabelsInfo(langs, 'No documents to download.', 'Nu sunt documente de descărcat.')
+            },
+        ];
+        return tInfo;
+    }
+    static createUploadErrorsTranslations(langs) {
+        const tInfo = [
+            {
+                code: 'invalidType',
+                translations: this.createLabelsInfo(langs, 'Invalid type', 'Tip invalid')
+            },
+            {
+                code: 'maxSize',
+                translations: this.createLabelsInfo(langs, 'The item exceeds the maximum size of {0}.', 'Fișierul depașeste dimensiunea maxima de {0}.')
+            },
+            {
+                code: 'isMandatory',
+                translations: this.createLabelsInfo(langs, 'The item is mandatory.', 'Acest fișier este obligatoriu.')
+            },
+            {
+                code: 'waitForUpload',
+                translations: this.createLabelsInfo(langs, 'Please wait for upload to finish.', 'Vă rugam așteptați incărcarea fișierelor.')
+            },
+        ];
+        return tInfo;
+    }
+    static createViewErrorsTranslations(langs) {
+        const tInfo = [
+            {
+                code: 'failToView',
+                translations: this.createLabelsInfo(langs, 'Failed to view', 'Nu am reușit sa vizualizez')
+            },
+            {
+                code: 'noDocumentsToShow',
+                translations: this.createLabelsInfo(langs, 'No documents to show', 'Nu sunt documente de afișat')
+            },
+        ];
+        return tInfo;
+    }
+    static createInputErrorsTranslations(langs) {
+        const tInfo = [
+            {
+                code: 'isMandatoryValidation',
+                translations: this.createLabelsInfo(langs, 'This field is required.', 'Acest câmp este obligatoriu.')
+            },
+            {
+                code: 'simpleValidation',
+                translations: this.createLabelsInfo(langs, 'This field is invalid.', 'Acest câmp este invalid.')
+            },
+            {
+                code: 'throughApiValidation',
+                translations: this.createLabelsInfo(langs, 'This field is invalid.', 'Acest câmp este invalid.')
+            },
+        ];
+        return tInfo;
+    }
+    static createDefaultErrorsTranslations(langs) {
+        const tInfo = [
+            {
+                code: 'isMandatoryValidation',
+                translations: this.createLabelsInfo(langs, 'This field is required.', 'Acest câmp este obligatoriu.')
+            }
+        ];
+        return tInfo;
+    }
+    static createCheckEmailTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Check email', 'Verifica email'),
+            this.createTranslation(langs, 'description', 'common.others.description', '', ''),
+            this.createTranslation(langs, 'emailLabel', 'flux.systemSteps.email.emailLabel', 'Email', 'Email'),
+            this.createTranslation(langs, 'emailButtonLabel', 'flux.systemSteps.email.emailButtonLabel', 'Send code', 'Trimite cod'),
+            this.createTranslation(langs, 'otpLabel', 'flux.systemSteps.email.otpLabel', 'Verification code', 'Cod de verificare'),
+            this.createTranslation(langs, 'otpButtonLabel', 'flux.systemSteps.email.otpButtonLabel', 'Verify', 'Verifică'),
+            this.createTranslation(langs, 'emailRequiredLabel', 'flux.components.email.emailRequiredLabel', 'Email is required', 'Email-ul este obligatoriu'),
+            this.createTranslation(langs, 'emailErrorLabel', 'flux.systemSteps.email.emailErrorLabel', 'Email is not valid', 'Email-ul nu este valid'),
+            this.createTranslation(langs, 'otpErrorLabel', 'flux.systemSteps.email.otpErrorLabel', 'Code verification error', 'Eroare la verificare cod'),
+            this.createTranslation(langs, 'otpSuccessLabel', 'flux.systemSteps.email.otpSuccessLabel', 'Code verification successful', 'Verificarea codului a fost realizată cu succes'),
+        ];
+        return tInfo;
+    }
+    static createCheckPhoneTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Check phone', 'Verifica telefon'),
+            this.createTranslation(langs, 'description', 'common.others.description', '', ''),
+            this.createTranslation(langs, 'phoneLabel', 'flux.systemSteps.phone.phoneLabel', 'Phone', 'Telefon'),
+            this.createTranslation(langs, 'phoneButtonLabel', 'flux.systemSteps.phone.phoneButtonLabel', 'Send code', 'Trimite cod'),
+            this.createTranslation(langs, 'otpLabel', 'flux.systemSteps.email.otpLabel', 'Verification code', 'Cod de verificare'),
+            this.createTranslation(langs, 'otpButtonLabel', 'flux.systemSteps.email.otpButtonLabel', 'Verify', 'Verifică'),
+            this.createTranslation(langs, 'phoneRequiredLabel', 'flux.components.phone.phoneRequiredLabel', 'Phone number is required', 'Numărul de telefon este obligatoriu'),
+            this.createTranslation(langs, 'phoneErrorLabel', 'flux.systemSteps.phone.phoneErrorLabel', 'Phone number is not valid', 'Numărul de telefon nu este valid'),
+            this.createTranslation(langs, 'otpErrorLabel', 'flux.systemSteps.email.otpErrorLabel', 'Code verification error', 'Eroare la verificare cod'),
+            this.createTranslation(langs, 'otpSuccessLabel', 'flux.systemSteps.email.otpSuccessLabel', 'Code verification successful', 'Verificarea codului a fost realizată cu succes'),
+        ];
+        return tInfo;
+    }
+    static createIdScanTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Id scan', 'Scanare act identitate'),
+            this.createTranslation(langs, 'description', 'common.others.description', 'Step to scan id document', 'Pas pentru încarcarea documentului de identitate'),
+            this.createTranslation(langs, 'uploadFileButtonLabel', 'flux.systemSteps.idScan.uploadButtonTextLabel', 'Upload file', 'Încarcă fișier'),
+            this.createTranslation(langs, 'takePictureButtonLabel', 'flux.systemSteps.idScan.takePictureButtonTextLabel', 'Take picture', 'Realizează o fotografie'),
+        ];
+        return tInfo;
+    }
+    static createPauseTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Pause', 'Pauză'),
+            this.createTranslation(langs, 'description', 'common.others.description', '', ''),
+            this.createTranslation(langs, 'offerReadyMessage', 'flux.systemSteps.pause.offerReadyMessageLabel', 'Your offer has been processed. Click on the link below to continue the flow.', 'Oferta dumneavoastra a fost procesata. Click pe link-ul de mai jos pentru a continua fluxul.'),
+            this.createTranslation(langs, 'continueOffersLinkMessageLabel', 'flux.systemSteps.pause.continueOffersLinkMessageLabel', 'Continue flow', 'Continuare flux'),
+            this.createTranslation(langs, 'offerReadySmsMessageLabel', 'flux.systemSteps.pause.offerReadySmsMessageLabel', 'Your offer has been processed. Click on the link below to continue the flow.', 'Oferta dumneavoastra a fost procesata. Click pe link-ul de mai jos pentru a continua fluxul.'),
+        ];
+        return tInfo;
+    }
+    static createActionTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'loadingMessageTranslations', 'appConfigEdit.flux.customStep.loadingMessage', 'Loading message', 'Mesaj de așteptare'),
+        ];
+        return tInfo;
+    }
+    static createStatusTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'loadingMessageTranslations', 'appConfigEdit.flux.customStep.loadingMessage', 'Loading message', 'Mesaj de așteptare'),
+        ];
+        return tInfo;
+    }
+    static createKycTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'KYC', 'KYC'),
+            this.createTranslation(langs, 'description', 'common.others.description', '', ''),
+            this.createTranslation(langs, 'loadingMessageTranslations', 'appConfigEdit.flux.customStep.loadingMessage', 'Loading identification step...', 'Se încarcă pasul de identificare...'),
+        ];
+        return tInfo;
+    }
+    static createPaymentsTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Payment', 'Plată'),
+            this.createTranslation(langs, 'description', 'common.others.description', '', ''),
+            this.createTranslation(langs, 'cardenrolButtonLabel', 'cardenrol.cardenrolButtonLabel', 'Enrol card', 'Înrolează card'),
+            this.createTranslation(langs, 'cardenrolFailureLabel', 'cardenrol.cardenrolFailureLabel', 'Error enrolling card', 'Eroare la înrolare card'),
+            this.createTranslation(langs, 'cardenrolSuccessLabel', 'cardenrol.cardenrolSuccessLabel', 'Success enrolling card', 'Succes la înrolare card'),
+        ];
+        return tInfo;
+    }
+    static createOpenBankingTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Open Banking', 'Open Banking'),
+            this.createTranslation(langs, 'description', 'common.others.description', 'Connect your bank account', 'Conectați contul bancar'),
+            this.createTranslation(langs, 'initialMessageTranslations', 'flux.systemSteps.openBanking.initialMessage', 'To continue, we need to verify your bank account information. Click Next to proceed.', 'Pentru a continua, trebuie să verificăm informațiile contului dvs. bancar. Faceți clic pe Următorul pentru a continua.'),
+            this.createTranslation(langs, 'waitingMessageTranslations', 'flux.systemSteps.openBanking.waitingMessage', 'Please wait while we retrieve your account information...', 'Vă rugăm să așteptați până când preluăm informațiile contului dvs...'),
+            this.createTranslation(langs, 'consentErrorMessageTranslations', 'flux.systemSteps.openBanking.consentErrorMessage', 'You must provide consent to continue. Please try again.', 'Trebuie să oferiți consimțământul pentru a continua. Vă rugăm să încercați din nou.'),
+            this.createTranslation(langs, 'completionMessageTranslations', 'flux.systemSteps.openBanking.completionMessage', 'Account information successfully retrieved.', 'Informațiile contului au fost preluate cu succes.'),
+            this.createTranslation(langs, 'retryButtonLabelTranslations', 'flux.systemSteps.openBanking.retryButtonLabel', 'Retry', 'Reîncearcă'),
+            // Button translations
+            this.createTranslation(langs, 'nextButtonTranslations', 'flux.systemSteps.openBanking.nextButton', 'Next', 'Următorul'),
+            this.createTranslation(langs, 'continueButtonTranslations', 'flux.systemSteps.openBanking.continueButton', 'Continue', 'Continuă'),
+            // UI labels
+            this.createTranslation(langs, 'selectBankTranslations', 'flux.systemSteps.openBanking.selectBank', 'Select your bank', 'Selectați banca dvs.'),
+            this.createTranslation(langs, 'consentTitleTranslations', 'flux.systemSteps.openBanking.consentTitle', 'Bank Authorization', 'Autorizare bancară'),
+            this.createTranslation(langs, 'consentDescriptionTranslations', 'flux.systemSteps.openBanking.consentDescription', 'Please complete the authorization process with your bank', 'Vă rugăm să completați procesul de autorizare cu banca dvs.'),
+            this.createTranslation(langs, 'waitingForAuthorizationTranslations', 'flux.systemSteps.openBanking.waitingForAuthorization', 'Waiting for authorization...', 'Se așteaptă autorizarea...'),
+            this.createTranslation(langs, 'popupWindowMessageTranslations', 'flux.systemSteps.openBanking.popupWindowMessage', 'A new window has opened for bank authorization. Please complete the process there.', 'S-a deschis o fereastră nouă pentru autorizare bancară. Vă rugăm să completați procesul acolo.'),
+            this.createTranslation(langs, 'popupBlockerMessageTranslations', 'flux.systemSteps.openBanking.popupBlockerMessage', 'If the window didn\'t open, please check your popup blocker settings.', 'Dacă fereastra nu s-a deschis, vă rugăm să verificați setările blocatorului de popup-uri.'),
+            this.createTranslation(langs, 'accountsRetrievedTranslations', 'flux.systemSteps.openBanking.accountsRetrieved', 'Accounts retrieved', 'Conturi preluate'),
+            this.createTranslation(langs, 'transactionsRetrievedTranslations', 'flux.systemSteps.openBanking.transactionsRetrieved', 'Transactions retrieved', 'Tranzacții preluate'),
+            this.createTranslation(langs, 'accountsFoundTranslations', 'flux.systemSteps.openBanking.accountsFound', '{0} account(s) found', '{0} cont(uri) găsite'),
+            this.createTranslation(langs, 'transactionsSummaryTranslations', 'flux.systemSteps.openBanking.transactionsSummary', '{0} transaction(s) retrieved for the last {1} month(s)', '{0} tranzacție(i) preluate pentru ultimele {1} lună(i)'),
+        ];
+        return tInfo;
+    }
+    static createCustomStepTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Custom step', 'Pas custom'),
+            this.createTranslation(langs, 'description', 'common.others.description', '', ''),
+        ];
+        return tInfo;
+    }
+    static createViewOfferStepTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'View offer', 'Vizualizare ofertă'),
+            this.createTranslation(langs, 'description', 'common.others.description', 'View offer step', 'Pas pentru vizualizare ofertă'),
+        ];
+        return tInfo;
+    }
+    static createSignTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Sign documents', 'Semnare documente'),
+            this.createTranslation(langs, 'description', 'common.others.description', 'Sign documents step', 'Pas pentru semnare documente'),
+        ];
+        return tInfo;
+    }
+    static createGenerateDocumentsTranslations(langs) {
+        const tInfo = [
+            this.createTranslation(langs, 'name', 'common.others.name', 'Generate documents', 'Generare documente'),
+            this.createTranslation(langs, 'description', 'common.others.description', 'Generate documents step', 'Pas pentru generare documente'),
+        ];
+        return tInfo;
+    }
+    static createTranslation(langs, name, translationKey, enValue, roValue) {
+        return {
+            name: name,
+            translationKey: translationKey,
+            values: this.createLabelsInfo(langs, enValue, roValue),
+        };
+    }
+    static createLabelsInfo(supportedLanguages, enValue, roValue) {
+        return this.createLabelsInfoCore(supportedLanguages, [
+            { iso: 'en', value: enValue },
+            { iso: 'ro', value: roValue },
+        ]);
+    }
+    static createLabelsInfoCore(supportedLanguages, values) {
+        let list = [];
+        values.forEach((v) => {
+            const langId = supportedLanguages.find((lang) => lang.iso === v.iso)?.id;
+            if (langId && langId > 0) {
+                list.push({
+                    languageId: langId,
+                    languageIso: v.iso,
+                    value: v.value,
+                });
+            }
+        });
+        return list;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationsHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationsHelper, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TranslationsHelper, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translations-helper.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/others/translations-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { StepControlType } from \"../models/flux.model\";\nimport { ErrorTranslations } from \"../models/forms.model\";\nimport { TranslationInfo, LabelInfo } from \"../models/label-info.model\";\nimport { Language } from \"../models/language.model\";\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TranslationsHelper {\n\n  public static createComponentErrorsTranslations(\n    langs: Language[],\n    componentType: StepControlType\n  ): ErrorTranslations[] {\n    switch (componentType) {\n      case StepControlType.ManualInput: return this.createInputErrorsTranslations(langs);\n      case StepControlType.CheckBox:\n      case StepControlType.Dictionary: return this.createDefaultErrorsTranslations(langs);\n      case StepControlType.DownloadDocuments: return this.createDownloadErrorsTranslations(langs);\n      case StepControlType.UploadDocuments: return this.createUploadErrorsTranslations(langs);\n      case StepControlType.ViewDocuments: return this.createViewErrorsTranslations(langs);\n    }\n    return [];\n  }\n\n  private static createDownloadErrorsTranslations(\n    langs: Language[]\n  ): ErrorTranslations[] {\n    const tInfo: ErrorTranslations[] = [\n      {\n        code: 'failToDownload',\n        translations: this.createLabelsInfo(langs, 'Failed to download.', 'Nu am reușit sa descarc.')\n      },\n      {\n        code: 'noDocumentsToDownload',\n        translations: this.createLabelsInfo(langs, 'No documents to download.', 'Nu sunt documente de descărcat.')\n      },\n    ];\n    return tInfo;\n  }\n\n  private static createUploadErrorsTranslations(\n    langs: Language[]\n  ): ErrorTranslations[] {\n    const tInfo: ErrorTranslations[] = [\n      {\n        code: 'invalidType',\n        translations: this.createLabelsInfo(langs, 'Invalid type', 'Tip invalid')\n      },\n      {\n        code: 'maxSize',\n        translations: this.createLabelsInfo(langs, 'The item exceeds the maximum size of {0}.', 'Fișierul depașeste dimensiunea maxima de {0}.')\n      },\n      {\n        code: 'isMandatory',\n        translations: this.createLabelsInfo(langs, 'The item is mandatory.', 'Acest fișier este obligatoriu.')\n      },\n      {\n        code: 'waitForUpload',\n        translations: this.createLabelsInfo(langs, 'Please wait for upload to finish.', 'Vă rugam așteptați incărcarea fișierelor.')\n      },\n    ];\n\n    return tInfo;\n  }\n\n  private static createViewErrorsTranslations(\n    langs: Language[]\n  ): ErrorTranslations[] {\n    const tInfo: ErrorTranslations[] = [\n      {\n        code: 'failToView',\n        translations: this.createLabelsInfo(langs, 'Failed to view', 'Nu am reușit sa vizualizez')\n      },\n      {\n        code: 'noDocumentsToShow',\n        translations: this.createLabelsInfo(langs, 'No documents to show', 'Nu sunt documente de afișat')\n      },\n    ];\n    return tInfo;\n  }\n\n  private static createInputErrorsTranslations(\n    langs: Language[]\n  ): ErrorTranslations[] {\n    const tInfo: ErrorTranslations[] = [\n      {\n        code: 'isMandatoryValidation',\n        translations: this.createLabelsInfo(langs, 'This field is required.', 'Acest câmp este obligatoriu.')\n      },\n      {\n        code: 'simpleValidation',\n        translations: this.createLabelsInfo(langs, 'This field is invalid.', 'Acest câmp este invalid.')\n      },\n      {\n        code: 'throughApiValidation',\n        translations: this.createLabelsInfo(langs, 'This field is invalid.', 'Acest câmp este invalid.')\n      },\n    ];\n    return tInfo;\n  }\n\n  private static createDefaultErrorsTranslations(\n    langs: Language[]\n  ): ErrorTranslations[] {\n    const tInfo: ErrorTranslations[] = [\n      {\n        code: 'isMandatoryValidation',\n        translations: this.createLabelsInfo(langs, 'This field is required.', 'Acest câmp este obligatoriu.')\n      }\n    ];\n    return tInfo;\n  }\n\n  public static createCheckEmailTranslations(\n    langs: Language[]\n  ): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Check email',\n        'Verifica email'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        '',\n        ''\n      ),\n      this.createTranslation(\n        langs,\n        'emailLabel',\n        'flux.systemSteps.email.emailLabel',\n        'Email',\n        'Email'\n      ),\n      this.createTranslation(\n        langs,\n        'emailButtonLabel',\n        'flux.systemSteps.email.emailButtonLabel',\n        'Send code',\n        'Trimite cod'\n      ),\n      this.createTranslation(\n        langs,\n        'otpLabel',\n        'flux.systemSteps.email.otpLabel',\n        'Verification code',\n        'Cod de verificare'\n      ),\n      this.createTranslation(\n        langs,\n        'otpButtonLabel',\n        'flux.systemSteps.email.otpButtonLabel',\n        'Verify',\n        'Verifică'\n      ),\n      this.createTranslation(\n        langs,\n        'emailRequiredLabel',\n        'flux.components.email.emailRequiredLabel',\n        'Email is required',\n        'Email-ul este obligatoriu'\n      ),\n      this.createTranslation(\n        langs,\n        'emailErrorLabel',\n        'flux.systemSteps.email.emailErrorLabel',\n        'Email is not valid',\n        'Email-ul nu este valid'\n      ),\n      this.createTranslation(\n        langs,\n        'otpErrorLabel',\n        'flux.systemSteps.email.otpErrorLabel',\n        'Code verification error',\n        'Eroare la verificare cod'\n      ),\n      this.createTranslation(\n        langs,\n        'otpSuccessLabel',\n        'flux.systemSteps.email.otpSuccessLabel',\n        'Code verification successful',\n        'Verificarea codului a fost realizată cu succes'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createCheckPhoneTranslations(\n    langs: Language[]\n  ): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Check phone',\n        'Verifica telefon'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        '',\n        ''\n      ),\n      this.createTranslation(\n        langs,\n        'phoneLabel',\n        'flux.systemSteps.phone.phoneLabel',\n        'Phone',\n        'Telefon'\n      ),\n      this.createTranslation(\n        langs,\n        'phoneButtonLabel',\n        'flux.systemSteps.phone.phoneButtonLabel',\n        'Send code',\n        'Trimite cod'\n      ),\n      this.createTranslation(\n        langs,\n        'otpLabel',\n        'flux.systemSteps.email.otpLabel',\n        'Verification code',\n        'Cod de verificare'\n      ),\n      this.createTranslation(\n        langs,\n        'otpButtonLabel',\n        'flux.systemSteps.email.otpButtonLabel',\n        'Verify',\n        'Verifică'\n      ),\n      this.createTranslation(\n        langs,\n        'phoneRequiredLabel',\n        'flux.components.phone.phoneRequiredLabel',\n        'Phone number is required',\n        'Numărul de telefon este obligatoriu'\n      ),\n      this.createTranslation(\n        langs,\n        'phoneErrorLabel',\n        'flux.systemSteps.phone.phoneErrorLabel',\n        'Phone number is not valid',\n        'Numărul de telefon nu este valid'\n      ),\n      this.createTranslation(\n        langs,\n        'otpErrorLabel',\n        'flux.systemSteps.email.otpErrorLabel',\n        'Code verification error',\n        'Eroare la verificare cod'\n      ),\n      this.createTranslation(\n        langs,\n        'otpSuccessLabel',\n        'flux.systemSteps.email.otpSuccessLabel',\n        'Code verification successful',\n        'Verificarea codului a fost realizată cu succes'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createIdScanTranslations(langs: Language[]): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Id scan',\n        'Scanare act identitate'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        'Step to scan id document',\n        'Pas pentru încarcarea documentului de identitate'\n      ),\n      this.createTranslation(\n        langs,\n        'uploadFileButtonLabel',\n        'flux.systemSteps.idScan.uploadButtonTextLabel',\n        'Upload file',\n        'Încarcă fișier'\n      ),\n      this.createTranslation(\n        langs,\n        'takePictureButtonLabel',\n        'flux.systemSteps.idScan.takePictureButtonTextLabel',\n        'Take picture',\n        'Realizează o fotografie'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createPauseTranslations(langs: Language[]): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Pause',\n        'Pauză'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        '',\n        ''\n      ),\n\n      this.createTranslation(\n        langs,\n        'offerReadyMessage',\n        'flux.systemSteps.pause.offerReadyMessageLabel',\n        'Your offer has been processed. Click on the link below to continue the flow.',\n        'Oferta dumneavoastra a fost procesata. Click pe link-ul de mai jos pentru a continua fluxul.'\n      ),\n\n      this.createTranslation(\n        langs,\n        'continueOffersLinkMessageLabel',\n        'flux.systemSteps.pause.continueOffersLinkMessageLabel',\n        'Continue flow',\n        'Continuare flux'\n      ),\n\n      this.createTranslation(\n        langs,\n        'offerReadySmsMessageLabel',\n        'flux.systemSteps.pause.offerReadySmsMessageLabel',\n        'Your offer has been processed. Click on the link below to continue the flow.',\n        'Oferta dumneavoastra a fost procesata. Click pe link-ul de mai jos pentru a continua fluxul.'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createActionTranslations(langs: Language[]): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'loadingMessageTranslations',\n        'appConfigEdit.flux.customStep.loadingMessage',\n        'Loading message',\n        'Mesaj de așteptare'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createStatusTranslations(langs: Language[]): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'loadingMessageTranslations',\n        'appConfigEdit.flux.customStep.loadingMessage',\n        'Loading message',\n        'Mesaj de așteptare'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createKycTranslations(langs: Language[]): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(langs, 'name', 'common.others.name', 'KYC', 'KYC'),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        '',\n        ''\n      ),\n      this.createTranslation(\n        langs,\n        'loadingMessageTranslations',\n        'appConfigEdit.flux.customStep.loadingMessage',\n        'Loading identification step...',\n        'Se încarcă pasul de identificare...'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createPaymentsTranslations(\n    langs: Language[]\n  ): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Payment',\n        'Plată'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        '',\n        ''\n      ),\n      this.createTranslation(\n        langs,\n        'cardenrolButtonLabel',\n        'cardenrol.cardenrolButtonLabel',\n        'Enrol card',\n        'Înrolează card'\n      ),\n      this.createTranslation(\n        langs,\n        'cardenrolFailureLabel',\n        'cardenrol.cardenrolFailureLabel',\n        'Error enrolling card',\n        'Eroare la înrolare card'\n      ),\n      this.createTranslation(\n        langs,\n        'cardenrolSuccessLabel',\n        'cardenrol.cardenrolSuccessLabel',\n        'Success enrolling card',\n        'Succes la înrolare card'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createOpenBankingTranslations(\n    langs: Language[]\n  ): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Open Banking',\n        'Open Banking'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        'Connect your bank account',\n        'Conectați contul bancar'\n      ),\n      this.createTranslation(\n        langs,\n        'initialMessageTranslations',\n        'flux.systemSteps.openBanking.initialMessage',\n        'To continue, we need to verify your bank account information. Click Next to proceed.',\n        'Pentru a continua, trebuie să verificăm informațiile contului dvs. bancar. Faceți clic pe Următorul pentru a continua.'\n      ),\n      this.createTranslation(\n        langs,\n        'waitingMessageTranslations',\n        'flux.systemSteps.openBanking.waitingMessage',\n        'Please wait while we retrieve your account information...',\n        'Vă rugăm să așteptați până când preluăm informațiile contului dvs...'\n      ),\n      this.createTranslation(\n        langs,\n        'consentErrorMessageTranslations',\n        'flux.systemSteps.openBanking.consentErrorMessage',\n        'You must provide consent to continue. Please try again.',\n        'Trebuie să oferiți consimțământul pentru a continua. Vă rugăm să încercați din nou.'\n      ),\n      this.createTranslation(\n        langs,\n        'completionMessageTranslations',\n        'flux.systemSteps.openBanking.completionMessage',\n        'Account information successfully retrieved.',\n        'Informațiile contului au fost preluate cu succes.'\n      ),\n      this.createTranslation(\n        langs,\n        'retryButtonLabelTranslations',\n        'flux.systemSteps.openBanking.retryButtonLabel',\n        'Retry',\n        'Reîncearcă'\n      ),\n      // Button translations\n      this.createTranslation(\n        langs,\n        'nextButtonTranslations',\n        'flux.systemSteps.openBanking.nextButton',\n        'Next',\n        'Următorul'\n      ),\n      this.createTranslation(\n        langs,\n        'continueButtonTranslations',\n        'flux.systemSteps.openBanking.continueButton',\n        'Continue',\n        'Continuă'\n      ),\n      // UI labels\n      this.createTranslation(\n        langs,\n        'selectBankTranslations',\n        'flux.systemSteps.openBanking.selectBank',\n        'Select your bank',\n        'Selectați banca dvs.'\n      ),\n      this.createTranslation(\n        langs,\n        'consentTitleTranslations',\n        'flux.systemSteps.openBanking.consentTitle',\n        'Bank Authorization',\n        'Autorizare bancară'\n      ),\n      this.createTranslation(\n        langs,\n        'consentDescriptionTranslations',\n        'flux.systemSteps.openBanking.consentDescription',\n        'Please complete the authorization process with your bank',\n        'Vă rugăm să completați procesul de autorizare cu banca dvs.'\n      ),\n      this.createTranslation(\n        langs,\n        'waitingForAuthorizationTranslations',\n        'flux.systemSteps.openBanking.waitingForAuthorization',\n        'Waiting for authorization...',\n        'Se așteaptă autorizarea...'\n      ),\n      this.createTranslation(\n        langs,\n        'popupWindowMessageTranslations',\n        'flux.systemSteps.openBanking.popupWindowMessage',\n        'A new window has opened for bank authorization. Please complete the process there.',\n        'S-a deschis o fereastră nouă pentru autorizare bancară. Vă rugăm să completați procesul acolo.'\n      ),\n      this.createTranslation(\n        langs,\n        'popupBlockerMessageTranslations',\n        'flux.systemSteps.openBanking.popupBlockerMessage',\n        'If the window didn\\'t open, please check your popup blocker settings.',\n        'Dacă fereastra nu s-a deschis, vă rugăm să verificați setările blocatorului de popup-uri.'\n      ),\n      this.createTranslation(\n        langs,\n        'accountsRetrievedTranslations',\n        'flux.systemSteps.openBanking.accountsRetrieved',\n        'Accounts retrieved',\n        'Conturi preluate'\n      ),\n      this.createTranslation(\n        langs,\n        'transactionsRetrievedTranslations',\n        'flux.systemSteps.openBanking.transactionsRetrieved',\n        'Transactions retrieved',\n        'Tranzacții preluate'\n      ),\n      this.createTranslation(\n        langs,\n        'accountsFoundTranslations',\n        'flux.systemSteps.openBanking.accountsFound',\n        '{0} account(s) found',\n        '{0} cont(uri) găsite'\n      ),\n      this.createTranslation(\n        langs,\n        'transactionsSummaryTranslations',\n        'flux.systemSteps.openBanking.transactionsSummary',\n        '{0} transaction(s) retrieved for the last {1} month(s)',\n        '{0} tranzacție(i) preluate pentru ultimele {1} lună(i)'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createCustomStepTranslations(\n    langs: Language[]\n  ): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Custom step',\n        'Pas custom'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        '',\n        ''\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createViewOfferStepTranslations(\n    langs: Language[]\n  ): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'View offer',\n        'Vizualizare ofertă'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        'View offer step',\n        'Pas pentru vizualizare ofertă'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createSignTranslations(langs: Language[]): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Sign documents',\n        'Semnare documente'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        'Sign documents step',\n        'Pas pentru semnare documente'\n      ),\n    ];\n    return tInfo;\n  }\n\n  public static createGenerateDocumentsTranslations(\n    langs: Language[]\n  ): TranslationInfo[] {\n    const tInfo: TranslationInfo[] = [\n      this.createTranslation(\n        langs,\n        'name',\n        'common.others.name',\n        'Generate documents',\n        'Generare documente'\n      ),\n      this.createTranslation(\n        langs,\n        'description',\n        'common.others.description',\n        'Generate documents step',\n        'Pas pentru generare documente'\n      ),\n    ];\n    return tInfo;\n  }\n\n  private static createTranslation(\n    langs: Language[],\n    name: string,\n    translationKey: string,\n    enValue: string,\n    roValue: string\n  ): TranslationInfo {\n    return {\n      name: name,\n      translationKey: translationKey,\n      values: this.createLabelsInfo(langs, enValue, roValue),\n    };\n  }\n\n  public static createLabelsInfo(supportedLanguages: Language[], enValue: string, roValue: string): LabelInfo[] {\n    return this.createLabelsInfoCore(supportedLanguages, [\n      { iso: 'en', value: enValue },\n      { iso: 'ro', value: roValue },\n    ]);\n  }\n\n  private static createLabelsInfoCore(\n    supportedLanguages: Language[],\n    values: { iso: string; value: string }[]\n  ): LabelInfo[] {\n    let list: LabelInfo[] = [];\n    values.forEach((v) => {\n      const langId = supportedLanguages.find((lang) => lang.iso === v.iso)?.id;\n      if (langId && langId > 0) {\n        list.push({\n          languageId: langId,\n          languageIso: v.iso,\n          value: v.value,\n        });\n      }\n    });\n    return list;\n  }\n}\n"]}