import { HttpClient } from "@angular/common/http";
import { UntypedFormBuilder, UntypedFormGroup } from "@angular/forms";
import { BaseField } from "../models/baseField.model";
import { Context } from "../models/context.model";
import { EndPointConfiguration, EndPointData, EndPointDataParams } from "../models/endPointConfiguration.model";
import { TextField } from "../models/fields/textField.model";
import { Form } from "../models/form.model";
import { Record } from "../models/record.model";
import { SpinnerService } from "./spinner.service";
import { DynAttachment } from "../models/dynAttachment";
import * as i0 from "@angular/core";
export declare class UtilityHelperService {
    private formBuilder;
    private http;
    private spinnerService;
    static context: Context;
    debugMode: boolean;
    debugLog(message: string, item?: any): void;
    constructor(formBuilder: UntypedFormBuilder, http: HttpClient, spinnerService: SpinnerService);
    static EvaluateFieldFormula(formula: string, rec: Record, ctx: any): any;
    static SetContext(ctx: Context): void;
    static isNumeric(n: any): boolean;
    static initStyles(stylecss: any): any;
    static GetFieldType(field: BaseField): TextField;
    /**
     * Metodo per impostare i valori da suggerire nell'autocomplete per i campi in cui l'utente deve scrivere comandi javascript.
     * In base all'ultimo carattere digitato viene impostato un elenco di oggetti o proprietà che l'utente ha a disposizione in quel momento.
     * @param fields Array di BaseField aggiunti alla Form
     * @param typedFormula Stringa digitata dall'utente
     * @summary Il metodo imposta i suggerimenti basandosi su 3 casi:
     *  1) l'utente non ha digitato nulla o la stringa digitata dall'utente finisce con uno spazio vuoto
     *  2) la stringa digitata dall'utente finisce con un "."
     *  3) la stringa digitata dall'utente non coincide con nessun altro caso sopra (finisce con un carattere qualunque)
     */
    static GetAutocompleteOptions(fields: Array<BaseField>, typedFormula: string): Array<{
        label: string;
        value: string;
    }>;
    /**
     * Metodo invocato dall'html per impostare le classi css per visualizzare il campo all'interno della form.
     * Se per il field sono state specificate delle classi allora vengono applcate quelle, altrimenti vengono usate
     * delle classi di default.
     * @param field BaseField da visualizzare.
     * @returns Restituisce una stringa contenente le classi css da applicare.
     */
    getFieldSyleClass(field: BaseField, showAllFields?: boolean): string;
    /**
     * Metodo invocato dall'html per impostare le classi css per visualizzare il campo all'interno della form.
     * Se per il field sono state specificate delle classi allora vengono applcate quelle, altrimenti vengono usate
     * delle classi di default.
     * @param field BaseField da visualizzare.
     * @returns Restituisce una stringa contenente le classi css da applicare.
     */
    getFieldAnswerStyleClass(field: BaseField): string;
    private getDefaultStyleClass;
    getFieldFilterStyleClass(field: BaseField, numberOfColumns: number): string;
    private getDefaultStyleClassWithNumberColumns;
    /**
     * Metodo per creare il FormGroup che rappresenta una Form a partire dai suoi BaseField.
     * @param formFields Lista dei BaseField che compongono la form.
     * @param record Oggetto di tipo Record che contiene i valori dei campi.
     * @param onlyView Se TRUE disabilita la form per renderla in sola lettura.
     * @param includeCurrentFormInField Se TRUE popola la proprietà FormFormGroup all'interno di ogni BaseField con il FormGroup corrente.
     * @returns Restituisce un FormGroup rappresentate la Form a cui appartengono i BaseField ricevuti in input.
     */
    CreateFormFormGroup(formFields: Array<BaseField>, record: Record, onlyView?: boolean, includeCurrentFormInField?: boolean): UntypedFormGroup;
    /**
     * Funzione per creare e aggiungere al FormGroup rappresentante la form un nuovo FormControl a partire da un Field.
     * In nuovo FormControl avrà il nome del campo passato e verranno impostati i Validators in base al tipo del campo stesso.
     * @param field BaseField per cui creare il FormControl da inserire nel FormGroup dela form.
     */
    /**
     * Validator "required" che legge dal record invece che da control.value.
     * Serve per far funzionare la validazione quando il valore viene impostato via formula/ActionButton
     * (che aggiornano record[fieldName] direttamente senza passare dal FormControl).
     */
    private createRecordRequiredValidator;
    private createFieldFormControl;
    /**
     * Metodo per configurare gli endpoint da usare di default a partire dall'url base del server
     * a cui si deve connettere e al token da passare per autenticarsi.
     * @param baseServerUrl Stringa dell'url base del server (es: "http://localhost:5000").
     * @param userToken Token dell'utente loggato da usare per autenticarsi se necessario.
     * @returns Resituisce la configurazione completa degli endPoint da usare di default.
     */
    ConfigureDefaultEndPoints(baseServerUrl: string, userToken: string): EndPointConfiguration;
    /**
     *
     * @param expression prende una stringa in input e verifica che ogni parentesi aperta venga anche chiusa
     * @returns true se le parentesi sono pari e ogni parentesi chiude se stessa, false se mancano parentesi o non vengono chiuse
     */
    static stringCheckParentesis(expression: any, required?: boolean): boolean;
    /**
     * Metodo che data la configurazione di un endpoint costruisce l'url da chiamare, gli eventuali parametri
     * da passare (nel body o nella rotta) ed effettua la chiamata. Al termine della chiamata esegue le eventuali
     * funzioni di callback (sia in caso di successo che in caso di errore) passate in input.
     * @param endPointData Cofigurazione dell'endpoint da chiamare.
     * @param dynamicModuleParams Array dei parametri aggiunti dal modulo dinamico a quelli già configurati
     * (ad esempio il record o la form da salvare oppure l'ID per recuperare una particolare entità).
     * @param callback Metodo da eseguire in caso di successo dopo la chiamata http.
     * NOTA: in input viene passata la risposta della chiamata stessa.
     * @param errorCallBack Metodo da eseguire in caso di errore dopo la chiamata http.
     * NOTA: in input viene passato l'errore generato della chiamata stessa.
     */
    RunEndPointCall(endPointData: EndPointData, dynamicModuleParams?: Array<EndPointDataParams>, callback?: (e: Form | Array<Form> | Record | Array<Record> | DynAttachment | Array<DynAttachment> | string | {
        Form: Form;
        Warnings: string[];
        CostCents: number;
        ElapsedMs: number;
    }) => void, errorCallBack?: (err: unknown) => void): void;
    /**
     * Variante SSE di RunEndPointCall: legge la risposta come stream text/event-stream.
     * Emette tre callback: onEstimate (stima pre-call SKILLFORK), onResult (payload completo), onError.
     */
    RunSseEndPointCall(endPointData: EndPointData, dynamicModuleParams: Array<EndPointDataParams>, onEstimate: (estimatedSeconds: number) => void, onResult: (res: any) => void, onError: (err: any) => void, skipSpinner?: boolean): void;
    static base64ToBlob(b64Data: any, contentType?: string, sliceSize?: number): Blob;
    static parseValueString(field: any, record: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<UtilityHelperService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UtilityHelperService>;
}