@qbs-origin/origin-form 0.5.0

package/lib/services/applicationData.service.d.ts

@@ -0,0 +1,35 @@
+import { Observable } from 'rxjs';
+import { ConfigService } from '../others/config-service';
+import { ApiDocumentRequest, ApiValidateRequest, ApplicationEnrolCardDto, ApplicationGenerateDocumentsDto, ApplicationGetGeneratedDocumentsDto, ApplicationUploadDocumentsDto, ConvertDocumentToPdfRequest, ConvertDocumentToPdfResponse, GeneratedDocument, MakeActionRequest, ScanIdDto } from '../models/application.model';
+import { AppData } from '../models/forms.model';
+import { AuthHttpService } from './auth-http.service';
+import * as i0 from "@angular/core";
+export declare class ApplicationDataService {
+    private http;
+    constructor(http: AuthHttpService);
+    configService: ConfigService;
+    uploadDocuments(uploadDocumentsDto: ApplicationUploadDocumentsDto): Observable<string[]>;
+    generateDocuments(generateDocumentsCommand: ApplicationGenerateDocumentsDto): Observable<any>;
+    getGenerateDocuments(getCommand: ApplicationGetGeneratedDocumentsDto): Observable<GeneratedDocument[]>;
+    downloadFile(appDataId: string, docId: string, fileName: string): Observable<any>;
+    scanId(scanIdCommand: ScanIdDto): Observable<number>;
+    getSteps(appDataId: string): Promise<any>;
+    saveApp(appData: AppData): Observable<any>;
+    saveStep(appDataId: string, currentStep: any, selectedOfferId?: any): Observable<any>;
+    getPreviousStep(appDataId: string): Observable<any>;
+    validateApi(apiValidateRequest: ApiValidateRequest): Observable<any>;
+    doDocumentRequest(apiValidateRequest: ApiDocumentRequest): Observable<any[]>;
+    convertDocumentToPdf(request: ConvertDocumentToPdfRequest): Observable<ConvertDocumentToPdfResponse>;
+    makeActionApiCall(actionRequest: MakeActionRequest): Observable<any>;
+    makeProcessApiCall(appDataID: string): Observable<any>;
+    getProcessStatus(appDataID: string): Observable<number>;
+    getOffers(appDataId: string): Observable<any>;
+    makeStatusApiCall(appDataId: string, stepId: string, setNextStep?: boolean): Observable<any>;
+    setCurrentStep(appDataId: string, stepId: string): Promise<unknown>;
+    enrolCard(enrolCardCommand: ApplicationEnrolCardDto): Observable<any>;
+    getEnrolmentStatus(dataUrlId: string): Observable<any>;
+    getDataUrl(dataUrlId: string): Observable<any>;
+    changeLanguage(appDataUuid: string, languageISOCode: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationDataService>;
+}

package/lib/services/auth-http.service.d.ts

@@ -0,0 +1,21 @@
+import { HttpClient, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { OriginFormAuthService } from '../origin-form-auth.service';
+import * as i0 from "@angular/core";
+export declare class AuthHttpService {
+    private http;
+    private authService;
+    private isRefreshing;
+    constructor(http: HttpClient, authService: OriginFormAuthService);
+    private getHeaders;
+    get<T>(url: string): Observable<T>;
+    getExtended<T>(url: string, options?: any): Observable<T | HttpEvent<T>>;
+    post<T>(url: string, body: any): Observable<T>;
+    postExtended<T>(url: string, body: any, options?: any | null): Observable<T | HttpEvent<T>>;
+    put<T>(url: string, body: any): Observable<T>;
+    delete<T>(url: string): Observable<T>;
+    private handleError;
+    private handle401Error;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthHttpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthHttpService>;
+}

package/lib/services/dialog.service.d.ts

@@ -0,0 +1,20 @@
+import { MatDialog, MatDialogConfig, MatDialogRef } from '@angular/material/dialog';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { ComponentType } from '@angular/cdk/portal';
+import { ErrorTranslations } from '../models/forms.model';
+import { TranslatePipe } from '../others/translation.pipe';
+import * as i0 from "@angular/core";
+export declare class DialogService {
+    private snackBar;
+    private dialog;
+    private translate;
+    constructor(snackBar: MatSnackBar, dialog: MatDialog, translate: TranslatePipe);
+    popError(message: string, ...params: string[]): void;
+    popErrors(labels: string[], duration?: number): void;
+    popErrorTranslation(errorsTranslations: ErrorTranslations[], langIso: string, errorCode: string, ...params: string[]): void;
+    private popErrorsCore;
+    popSuccess(message: string, duration?: number, panelClass?: string[]): void;
+    openDialog<T, D = any, R = any>(component: ComponentType<T>, config?: MatDialogConfig<D>): MatDialogRef<T, R>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
+}

package/lib/services/dictionary.service.d.ts

@@ -0,0 +1,89 @@
+import { Observable } from 'rxjs';
+import { Dictionary, DictionaryAppDependencyDto, DictionaryDto } from '../models/dictionary.model';
+import { List } from '../models/list.model';
+import { ConfigService } from '../others/config-service';
+import { EnvironmentType } from '../others/environment-type';
+import { AuthHttpService } from './auth-http.service';
+import * as i0 from "@angular/core";
+export declare class DictionaryService {
+    private http;
+    private activeDictionaryRequests;
+    private supportsBatchLoad;
+    constructor(http: AuthHttpService);
+    configService: ConfigService;
+    getDictionaries(params: {
+        page?: number;
+        pageSize?: number;
+        sort?: string;
+        sortDirection?: string;
+        filters?: string[];
+        dictionaryIds?: number[];
+        dictionaryUUIDs?: string[];
+        languageIds?: number[];
+        env: EnvironmentType;
+    }): Observable<List<DictionaryDto>>;
+    getDictionariesLight(params: {
+        page?: number;
+        pageSize?: number;
+        sort?: string;
+        sortDirection?: string;
+        filters: string[];
+        languageIds?: number[];
+        env: EnvironmentType;
+    }): Observable<List<DictionaryDto>>;
+    delete(uuid: string, env: string): Observable<any>;
+    getDictionary(id: string, env: EnvironmentType): Observable<DictionaryDto>;
+    /**
+     * Load multiple dictionaries in parallel
+     * Reusable for any scenario that needs multiple dictionaries
+     */
+    loadMultipleDictionaries(uuids: string[], env?: EnvironmentType): Observable<Map<string, DictionaryDto>>;
+    /**
+     * Private method for batch loading (when backend supports it)
+     */
+    private getBatchDictionaries;
+    getDependencies(id: number): Observable<DictionaryDto[]>;
+    getAppDependencies(uuid: string, env: EnvironmentType): Observable<DictionaryAppDependencyDto>;
+    create(dictionary: Dictionary): Observable<string>;
+    updateDictionary(dictionary: Dictionary): Observable<Dictionary>;
+    publishDictionaryVersion(uuid: string, envFrom: EnvironmentType, envTo: EnvironmentType): Observable<DictionaryDto>;
+    getDictionaryVersion(uuid: string, env: EnvironmentType): Observable<DictionaryDto>;
+    loadAppDictionaries(appUuid: string, env?: EnvironmentType): Observable<AppDictionariesResponse>;
+    /**
+     * NEW: Get complete dictionary tree in a single API call
+     * This replaces the need for multiple recursive calls to load child dictionaries
+     */
+    getDictionaryTree(dictionaryId: string, params: {
+        env: EnvironmentType;
+        languageId?: number;
+        valueIdsToShow?: number[];
+    }): Observable<DictionaryTreeResponseDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DictionaryService>;
+}
+export interface DictionaryTreeResponseDto {
+    mainDictionary: DictionaryDto;
+    allDictionaries: DictionaryDto[];
+    metadata: {
+        totalDictionaries: number;
+        maxDepth: number;
+        loadedAt: string;
+    };
+}
+export interface AppDictionariesResponse {
+    dictionaries: {
+        [uuid: string]: DictionaryDto;
+    };
+    analysisStats: {
+        appUuid: string;
+        sectionsAnalyzed: number;
+        controlsAnalyzed: number;
+        presentationControlsAnalyzed: number;
+        initialDictionariesFound: number;
+        totalLoaded: number;
+        dependencyRounds: number;
+        loadingTimeMs: number;
+    };
+    success: boolean;
+    errors?: string[];
+}

package/lib/services/forms.service.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { ApplicationDto } from '../models/application.model';
+import { ConfigService } from '../others/config-service';
+import { EnvironmentType } from '../others/environment-type';
+import { AuthHttpService } from './auth-http.service';
+import * as i0 from "@angular/core";
+export declare class FormsService {
+    private http;
+    constructor(http: AuthHttpService);
+    configService: ConfigService;
+    loadForm(id: number, env?: string): Observable<ApplicationDto>;
+    loadFormByUuid(uuid: string, env?: string): Observable<ApplicationDto>;
+    publish(applicationUuid: string, envTo: EnvironmentType): Observable<ApplicationDto>;
+    getVersion(applicationUuid: string, env?: EnvironmentType): Observable<ApplicationDto>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormsService>;
+}

package/lib/services/labels.service.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { Label } from '../models/label.model';
+import { ConfigService } from '../others/config-service';
+import { AuthHttpService } from './auth-http.service';
+import * as i0 from "@angular/core";
+export declare class LabelService {
+    private http;
+    constructor(http: AuthHttpService);
+    configService: ConfigService;
+    getLabels(langIso: string, updateUserLanguageIso?: boolean): Observable<Label[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LabelService>;
+}

package/lib/services/language.service.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { List } from '../models/list.model';
+import { Language } from '../models/language.model';
+import { ConfigService } from '../others/config-service';
+import { AuthHttpService } from './auth-http.service';
+import * as i0 from "@angular/core";
+export declare class LanguageService {
+    private http;
+    constructor(http: AuthHttpService);
+    configService: ConfigService;
+    getLanguages(): Observable<List<Language>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LanguageService>;
+}

package/lib/services/open-banking.service.d.ts

@@ -0,0 +1,137 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ConfigService } from '../others/config-service';
+import * as i0 from "@angular/core";
+export interface Bank {
+    id: string;
+    bankCode: string;
+    displayName: string;
+    logoUrl?: string;
+    countryCode: string;
+    requiresRedirect: boolean;
+    supportedFeatures: string;
+    isActive: boolean;
+}
+export interface ConsentInitRequest {
+    bankCode: string;
+    psuEmail: string;
+    psuIntermediaryId: string;
+    periodOfValidity?: number;
+    tcAccepted: boolean;
+}
+export interface ConsentInitResponse {
+    authorizationUrl: string;
+    consentId: string;
+}
+export interface ConsentStatus {
+    consentId: string;
+    status: 'received' | 'valid' | 'rejected' | 'expired' | 'terminated' | 'revokedByPsu';
+    expiresAt?: string;
+}
+export interface ConsentCallbackParams {
+    message: string;
+    type: string;
+    internalConsentId: string;
+    code?: string;
+    state?: string;
+}
+export interface ConsentCallbackResponse {
+    message: string;
+    internalConsentId: string;
+    status: 'approved' | 'rejected';
+}
+export interface Account {
+    id: string;
+    accountId: string;
+    iban: string;
+    currency: string;
+    name: string;
+    accountHolderName: string;
+    accountHolderConfidence: string;
+    balance: number;
+    lastSyncedAt: string;
+}
+export interface Transaction {
+    transactionId: string;
+    accountId: string;
+    amount: number;
+    currency: string;
+    bookingDate: string;
+    valueDate?: string;
+    creditorName?: string;
+    creditorIBAN?: string;
+    debtorName?: string;
+    debtorIBAN?: string;
+    remittanceInformation?: string;
+    status: 'Booked' | 'Pending';
+    type: 'Debit' | 'Credit';
+    description?: string;
+    transactionDate?: string;
+    category?: string;
+    merchantName?: string;
+    reference?: string;
+}
+export interface TransactionPage {
+    items: Transaction[];
+    page: number;
+    pageNumber?: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    nextPageLink?: string;
+}
+export interface TransactionRequest {
+    consentId: string;
+    bankCode: string;
+    accountId: string;
+    fromDate?: string;
+    toDate?: string;
+    page?: number;
+    pageSize?: number;
+}
+export declare class OpenBankingService {
+    private http;
+    private configService;
+    private apiUrl;
+    constructor(http: HttpClient, configService: ConfigService);
+    /**
+     * Fix data URL format for logos
+     * Converts "data:image/svg;base64," to "data:image/svg+xml;base64,"
+     */
+    private fixDataUrlFormat;
+    /**
+     * Get list of supported banks
+     * @param countryCode Optional country code filter
+     */
+    getBanks(countryCode?: string): Observable<Bank[]>;
+    /**
+     * Initialize consent flow
+     */
+    initializeConsent(request: ConsentInitRequest): Observable<ConsentInitResponse>;
+    /**
+     * Get consent status
+     */
+    getConsentStatus(bankCode: string, consentId: string): Observable<ConsentStatus>;
+    /**
+     * Process consent callback
+     */
+    processConsentCallback(params: ConsentCallbackParams): Observable<ConsentCallbackResponse>;
+    /**
+     * Get accounts for a consent
+     */
+    getAccounts(consentId: string, bankCode: string): Observable<Account[]>;
+    /**
+     * Get maximum transaction period for a bank
+     * @param bankCode The bank code
+     * @returns Maximum number of days or -1 for unlimited
+     */
+    getMaxTransactionPeriod(bankCode: string): number;
+    /**
+     * Get transactions for an account
+     */
+    getTransactions(request: TransactionRequest): Observable<TransactionPage>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OpenBankingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OpenBankingService>;
+}

package/lib/services/origin-form-signalr-handler.service.d.ts

@@ -0,0 +1,29 @@
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OriginFormSignalrService } from './origin-form-signalr.service';
+import * as i0 from "@angular/core";
+export interface OperationResult {
+    operationIdentifier: string;
+    success: boolean;
+    data?: any;
+    error?: any;
+}
+export declare class OriginFormSignalrHandlerService implements OnDestroy {
+    private originFormSignalrService;
+    private subscriptions;
+    private applicationDataService;
+    private currentAppDataUuid;
+    private _isLoading;
+    readonly isLoading$: Observable<boolean>;
+    private _operationCompleted;
+    readonly operationCompleted$: Observable<OperationResult>;
+    constructor(originFormSignalrService: OriginFormSignalrService);
+    private subscribeToCoreEvents;
+    private setKycOperationCompleted;
+    private poolingInterval;
+    private startBackupPooling;
+    initiateKycProcessing(appDataUuid: string): Promise<void>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OriginFormSignalrHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OriginFormSignalrHandlerService>;
+}

package/lib/services/origin-form-signalr.service.d.ts

@@ -0,0 +1,24 @@
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class OriginFormSignalrService {
+    private connection;
+    private connectionPromise;
+    private hubUrl;
+    private eventSubjects;
+    kycProcessingComplete: Subject<any>;
+    private configService;
+    constructor();
+    private registerSpecificEvents;
+    initiateSignalrConnection(): Promise<void>;
+    private setSignalrClientMethods;
+    /**
+     * Allows dynamic registration of an event listener if the event name isn't known at design time
+     * or if a component wants to manage its own subject.
+     * @param eventName The name of the event from the server.
+     * @returns An RxJS Subject that will emit data when the event is received.
+     */
+    listenForEvent<T>(eventName: string): Subject<T>;
+    stopConnection(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OriginFormSignalrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OriginFormSignalrService>;
+}

package/lib/services/otp.service.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { ConfigService } from '../others/config-service';
+import { AuthHttpService } from './auth-http.service';
+import * as i0 from "@angular/core";
+export declare class OtpService {
+    private http;
+    constructor(http: AuthHttpService);
+    configService: ConfigService;
+    generate(params: {
+        phoneNumber: string | null;
+        emailAddress: string | null;
+        appDataId: string;
+        stepId: string;
+    }): Observable<any>;
+    validate(data: {
+        otpCode: string;
+        appDataId: string;
+        stepId: string;
+    }): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OtpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OtpService>;
+}

package/lib/services/proxy.service.d.ts

@@ -0,0 +1,29 @@
+import { ActivatedRoute } from '@angular/router';
+import { AuthHttpService } from './auth-http.service';
+import * as i0 from "@angular/core";
+export interface TokenResponse {
+    token: string;
+}
+export declare class ProxyService {
+    private http;
+    private route;
+    orderID: string | undefined;
+    apiURL: string;
+    token: string;
+    env: string;
+    private tokenUrl;
+    debug: boolean;
+    langIso: string;
+    constructor(http: AuthHttpService, route: ActivatedRoute);
+    getValuesForLog(): {
+        apiURL: string;
+        orderID: string | undefined;
+        env: string;
+        tokenUrl: string;
+        token: string;
+    };
+    getToken(): Promise<unknown>;
+    getTokenAndSave(): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProxyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProxyService>;
+}

package/lib/services/scroll-to-error.service.d.ts

@@ -0,0 +1,54 @@
+import { FormGroup } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class ScrollToErrorService {
+    /**
+     * Scroll to the first validation error in a form
+     */
+    scrollToFirstError(form: FormGroup): void;
+    /**
+     * Scroll to a specific field by name
+     */
+    scrollToField(fieldName: string): void;
+    /**
+     * Find first invalid control in form
+     */
+    private findFirstInvalidControl;
+    /**
+     * Find form field element by various selectors
+     */
+    private findFormFieldElement;
+    /**
+     * Fallback search through all elements
+     */
+    private fallbackElementSearch;
+    /**
+     * Check if element is visible
+     */
+    private isElementVisible;
+    /**
+     * Try to find a matching invalid field when direct search fails
+     */
+    private tryFindMatchingInvalidField;
+    /**
+     * Try to find formly field container and look for invalid elements within it
+     */
+    private tryFindFormlyFieldContainer;
+    /**
+     * Scroll to element with smooth animation
+     */
+    private scrollToElement;
+    /**
+     * Perform the actual scroll with multiple methods
+     */
+    private performScroll;
+    /**
+     * Focus on the target element
+     */
+    private focusElement;
+    /**
+     * Debug log all form elements for troubleshooting
+     */
+    debugLogFormElements(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToErrorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollToErrorService>;
+}

package/lib/services/translation.service.d.ts

@@ -0,0 +1,10 @@
+import { Label } from "../models/label.model";
+import * as i0 from "@angular/core";
+export declare class TranslationService {
+    private dictionary;
+    constructor();
+    setLabels(labels: Label[]): void;
+    translate(key: string, args?: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationService>;
+}

package/lib/shared-components/confirmation.component.d.ts

@@ -0,0 +1,77 @@
+import { OnInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class ConfirmationComponent implements OnInit {
+    private data;
+    dialog: MatDialogRef<ConfirmationComponent>;
+    commonKeys: {
+        form: {
+            email: string;
+            cancel: string;
+        };
+        actions: {
+            read: string;
+            create: string;
+            write: string;
+            view: string;
+            filter: string;
+            includeInactive: string;
+            save: string;
+            confirm: string;
+            cancel: string;
+            back: string;
+            next: string;
+            submit: string;
+            close: string;
+            add: string;
+            addValue: string;
+            edit: string;
+            delete: string;
+            check: string;
+            import: string;
+            export: string;
+            collapseAll: string;
+            logout: string;
+            upload: string;
+        };
+        pagination: {
+            noItems: string;
+            perPage: string;
+            of: string;
+        };
+        confirmation: {
+            title: string;
+            delete: string;
+        };
+        api: {
+            addMethod: string;
+            addField: string;
+        };
+        components: {
+            button: string;
+        };
+        others: {
+            translation: string;
+            type: string;
+            active: string;
+            newItem: string;
+            name: string;
+            code: string;
+            notifications: string;
+            seeAllNotifications: string;
+            viewProfile: string;
+            description: string;
+        };
+    };
+    item: any;
+    text: any;
+    constructor(data: {
+        item: any;
+        text: string;
+    }, dialog: MatDialogRef<ConfirmationComponent>);
+    ngOnInit(): void;
+    submit(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmationComponent, "app-confirmation", never, {}, {}, never, never, false, never>;
+}

package/lib/shared-components/dictionaries-tree.component.d.ts

@@ -0,0 +1,51 @@
+import { AfterViewInit, EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { DictionaryValue, DictionaryDto, DictionaryValueDto } from '../models/dictionary.model';
+import { DictionaryService } from '../services/dictionary.service';
+import { ItemNode, ItemFlatNode } from '../models/treeview.model';
+import { AppTreeviewComponent } from './treeview/treeview.component';
+import * as i0 from "@angular/core";
+export declare class DictionariesTreeComponent implements OnInit, OnChanges, AfterViewInit {
+    private dictService;
+    treeViewControl: AppTreeviewComponent;
+    dictionaryId: string;
+    selectedValueIds: number[];
+    allowCheckItems: boolean;
+    allowFilter: boolean;
+    drawReferenceDictionariesAsSeparateNode: boolean;
+    drawChildDictionariesAsSeparateNode: boolean;
+    drawRootNode: boolean;
+    filterText: string;
+    allowSelectNonLeafNodes: boolean;
+    languageId: number;
+    valuesIdsToShow: number[];
+    hideParentArrow: boolean;
+    preloadedDictionary: DictionaryDto | null;
+    preloadedDictionaries: Map<string, DictionaryDto> | null;
+    usePreloadedData: boolean;
+    selectedDictionaryValuesChanged: EventEmitter<DictionaryValue[]>;
+    allDictionaries: DictionaryDto[];
+    mainDictionary: DictionaryDto;
+    isLoading: boolean;
+    constructor(dictService: DictionaryService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    loadDictionary(): void;
+    /**
+     * NEW: Load dictionary from preloaded data instead of API calls
+     */
+    loadFromPreloadedData(): void;
+    /**
+     * NEW: Load needed dictionaries from preloaded data instead of API calls
+     */
+    loadAllNeededDictionariesFromPreloaded(dictionary: DictionaryDto): void;
+    rebuildTree(): void;
+    clearTree(): void;
+    buildDictionaryTree(dictionary: DictionaryDto): ItemNode;
+    buildTreeChildren(dictionary: DictionaryDto, node: ItemNode): void;
+    getCanSelect(node: ItemNode): boolean;
+    onTreeSelectionChanged(node: ItemFlatNode): void;
+    createCopy(objectToCopy: DictionaryValueDto[]): DictionaryValue[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DictionariesTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DictionariesTreeComponent, "app-dictionaries-tree", never, { "dictionaryId": { "alias": "dictionaryId"; "required": false; }; "selectedValueIds": { "alias": "selectedValueIds"; "required": false; }; "allowCheckItems": { "alias": "allowCheckItems"; "required": false; }; "allowFilter": { "alias": "allowFilter"; "required": false; }; "drawReferenceDictionariesAsSeparateNode": { "alias": "drawReferenceDictionariesAsSeparateNode"; "required": false; }; "drawChildDictionariesAsSeparateNode": { "alias": "drawChildDictionariesAsSeparateNode"; "required": false; }; "drawRootNode": { "alias": "drawRootNode"; "required": false; }; "filterText": { "alias": "filterText"; "required": false; }; "allowSelectNonLeafNodes": { "alias": "allowSelectNonLeafNodes"; "required": false; }; "languageId": { "alias": "languageId"; "required": false; }; "valuesIdsToShow": { "alias": "valuesIdsToShow"; "required": false; }; "hideParentArrow": { "alias": "hideParentArrow"; "required": false; }; "preloadedDictionary": { "alias": "preloadedDictionary"; "required": false; }; "preloadedDictionaries": { "alias": "preloadedDictionaries"; "required": false; }; "usePreloadedData": { "alias": "usePreloadedData"; "required": false; }; }, { "selectedDictionaryValuesChanged": "selectedDictionaryValuesChanged"; }, never, never, false, never>;
+}