markuno_lib 1.2.82 → 1.2.84

package/types/markuno.d.ts

@@ -1,9 +1,9 @@
 export class Ambiente {
-    constructor(cat?: string, maxdelays?: number, righevuote?: boolean);
+    constructor(t?: string, e?: number, a?: boolean);
     righevuote: boolean;
     maxdelays: number;
     pick: Pickers;
-    setcatalog(cat: any): any;
+    setcatalog(t: any): any;
     cat: any;
     item: any;
     rule: any;
@@ -14,56 +14,53 @@ export class Ambiente {
         muEval: typeof muEval;
         tipifree: string[];
     };
-    azzera(mode?: boolean): void;
-    /** @type {Variabile} */
+    azzera(t?: boolean): void;
     imgpreview: {};
     vari: Variabile;
     ruleset: {};
     ruleheader: string;
-    /** @type {Object.<string, Macro>} */
     macro: {};
-    /** @type {Object.<string, Variante>} */
     varianti: {};
     varelenco: {};
     macroelenco: {};
     scripts: {};
-    setimgpreview(cod: any, img: any): void;
-    getimgpreview(cod: any): any;
-    setfndot(fndotcallback: any): void;
+    setimgpreview(t: any, e: any): void;
+    getimgpreview(t: any): any;
+    setfndot(t: any): void;
     fndotcallback: any;
-    parseheaderfrominfo(tm: any): void;
-    setitem(item: any, rule: any, model: any, ruleset?: any[], datadelgiorno?: number): void;
+    parseheaderfrominfo(t: any): void;
+    setitem(t: any, e: any, a: any, s?: any[], i?: number): void;
     data: any;
-    getheader(cod: any): Promise<any>;
+    getheader(t: any): Promise<any>;
     getalias(): Promise<any>;
     get deriva(): any;
-    getmacro(riga: any): Promise<{
+    getmacro(t: any): Promise<{
         macro: any;
-        pars: string[];
+        pars: any;
     } | {
         macro?: undefined;
         pars?: undefined;
     }>;
-    getvariante(cod: any): Promise<any>;
-    varcompila(v: any, callback: any): Promise<void>;
-    macrocompila(v: any, callback: any): Promise<void>;
-    barrecompila(articolibarre: any, titolibarre: any, callback: any): Promise<CodiceBarra>;
-    tojson(d: any): Promise<any>;
-    compila(info: any, callback: any): Promise<void>;
-    checkvarianti(cat: any, vars: any): Promise<void>;
-    getheaderfromdb(name: any): Promise<{
+    getvariante(t: any): Promise<any>;
+    varcompila(t: any, e: any): Promise<void>;
+    macrocompila(t: any, e: any): Promise<void>;
+    barrecompila(t: any, e: any, a: any): Promise<CodiceBarra>;
+    tojson(t: any): Promise<any>;
+    compila(t: any, e: any): Promise<void>;
+    checkvarianti(e: any, a: any): Promise<void>;
+    getheaderfromdb(e: any): Promise<{
         head: any;
         rows: any;
         macros: any;
     }>;
-    getlinkedmacros(rule: any, macros: any): Promise<void>;
-    checkscripts(vv: any): void;
-    setruleheader(rule: any, pars: any, ruleset: any): Promise<any>;
+    getlinkedmacros(t: any, a: any): Promise<void>;
+    checkscripts(t: any): void;
+    setruleheader(t: any, e: any, a: any): Promise<any>;
     getruleheader(): any;
-    setvariante(cod: any, opz: any): Promise<any>;
-    valuta(codice: any): Promise<any>;
-    setinfos(tm: any): void;
-    splitteroggetti(name: any): Promise<{
+    setvariante(t: any, e: any): Promise<any>;
+    valuta(t: any): Promise<any>;
+    setinfos(t: any): void;
+    splitteroggetti(t: any): Promise<{
         tipo: string;
         cod: string;
         des: string;
@@ -75,7 +72,7 @@ export class Ambiente {
 export class CodiceBarra {
     barre: {};
     azzera(): void;
-    oriented(t: any, l: any, a: any, p: any): {
+    oriented(t: any, e: any, a: any, s: any): {
         t: string;
         x: any;
         y?: undefined;
@@ -86,14 +83,13 @@ export class CodiceBarra {
         y: any;
         z: any;
     };
-    getcode(codicebarratot: any, l: any, a: any, p: any, callback: any): Promise<any>;
-    compila(vettore: any, headers: any): void;
+    getcode(t: any, e: any, a: any, s: any, i: any): Promise<any>;
+    compila(t: any, e: any): void;
 }
 export class Macro {
-    constructor(amb: any, _name: any);
-    name: string;
-    cat: string;
-    /** @type {Ambiente} */
+    constructor(t: any, e: any);
+    name: any;
+    cat: any;
     amb: any;
     azzera(): void;
     key: string;
@@ -115,59 +111,51 @@ export class Macro {
     get iscodice(): any;
     get isheader(): number;
     geterrori(): any[];
-    getparametri(op?: {}): {};
-    setparametri(pars: any): Promise<{}>;
-    setparametro(name: any, value: any, propaga?: boolean, pars?: {}): Promise<any>;
-    isderivato(hd: any): boolean;
-    impostaparametri(parimposta: any, parcall: any, ismacro: boolean, progettokeys: any): Promise<void>;
-    checkvalid(formula: any): Promise<boolean>;
+    getparametri(t?: {}): {};
+    setparametri(t: any): Promise<{}>;
+    setparametro(t: any, e: any, a?: boolean, s?: {}): Promise<any>;
+    getmarker(): any;
+    isderivato(t: any): boolean;
+    impostaparametri(t: any, e: any, a: boolean, s: any): Promise<void>;
+    checkvalid(t: any): Promise<boolean>;
     getmacrostr(): string;
     getmacro(): any;
-    setmacro(vv: any): void;
-    load(xname: any, xcat: any): Promise<boolean>;
-    loadAndCompile(file: any, _cat: any, acapo?: boolean): Promise<any>;
-    parsedata(res: any, acapo?: boolean): Promise<void>;
-    cleanfiltraparametri(key: any, codice: any, acapo: any): any[];
+    setmacro(t: any): void;
+    load(t: any, a: any): Promise<boolean>;
+    loadAndCompile(t: any, e: any, a?: boolean): Promise<any>;
+    parsedata(t: any, e?: boolean): Promise<void>;
+    cleanfiltraparametri(t: any, e: any, a: any): {
+        tipo: any;
+        contenuto: any;
+    }[];
     #private;
 }
 export class Variabile {
-    static isValidKey(key: any): boolean;
-    static sanitizeKey(key: any): any;
+    static isValidKey(t: any): boolean;
+    static sanitizeKey(t: any): any;
     stl: {};
     dictionary: {};
     vec: any[];
     counter: number;
-    setfndot(fndotcallback: any): void;
+    setfndot(t: any): void;
     fndotcallback: any;
-    /**
-         * Salva lo stato corrente delle variabili nello stack
-         */ push(): void;
-    /**
-         * Ripristina l'ultimo stato salvato delle variabili
-         */ pop(): void;
-    savevars(str: any): void;
-    /**
-         * Rimuove tutte le variabili e pulisce lo stack
-         */ clear(): void;
+    push(): void;
+    pop(): void;
+    savevars(t: any): void;
+    clear(): void;
     azzera: () => void;
-    var(key: any): any;
-    getvar(key: any): any;
-    colonna(value: any, index: any): any;
-    /**
-         * Restituisce un dump delle variabili
-         */ dump(isstr?: boolean): string[] | {
+    var(t: any): any;
+    getvar(t: any): any;
+    colonna(t: any, e: any): any;
+    dump(t?: boolean): string[] | {
         cod: string;
         val: any;
     }[];
-    /**
-         * Aggiunge o rimuove una variabile
-         */ add(key: any, value: any): void;
-    removeallvars(exclude: any): void;
-    /**
-         * Valuta un'espressione con supporto per callback asincroni
-         */ valutasync(str: any): any;
-    valuta(ex: any, callback: any): Promise<any>;
-    parametrokeyval(p: any): Promise<{
+    add(t: any, e: any): void;
+    removeallvars(t: any): void;
+    valutasync(t: any): any;
+    valuta(t: any, e: any): Promise<any>;
+    parametrokeyval(t: any): Promise<{
         k?: undefined;
         v?: undefined;
     } | {
@@ -175,105 +163,46 @@ export class Variabile {
         v: any;
     }>;
 }
-/**
- * Classe per gestire le varianti di un prodotto.
- * Permette di caricare, manipolare e convertire varianti di prodotto con relativi attributi e limiti.
- * @class
- * @exports
- */ export class Variante {
-    /**
-         * Crea una nuova istanza di Variante
-         * @param {Object} amb - Ambiente di esecuzione contenente il contesto applicativo
-         */
-    constructor(amb: any);
+export class Variante {
+    constructor(t: any);
     rows: {};
     name: string;
     key: string;
-    /** @type {Ambiente} */
     amb: any;
-    /**
-         * Imposta i dati principali della variante
-         * @param {string} id - Identificativo univoco della variante
-         * @param {string} cat - Categoria di appartenenza
-         * @returns {Object} Oggetto contenente nome e categoria normalizzati
-         */ setheader(id: string, _cat: any): any;
-    cat: string;
+    setheader(t: any, e: any): {
+        name: any;
+        cat: any;
+    };
+    cat: any;
     alias: string;
     obbligo: boolean;
-    des: string;
-    vdef: any[] | string[];
-    h: any[] | {
-        des: string;
-    }[];
-    /**
-         * Cerca la riga con dimensione più vicina a quella richiesta
-         * @param {number|string} dim - Dimensione target da cercare
-         * @param {number} colonna - Indice della colonna (1-based) contenente la dimensione
-         * @returns {string} Riga formattata nel formato CSV
-         */ fromdim(dim: number | string, colonna?: number): string;
-    /**
-         * Carica una variante dal database o da file
-         * @param {string} id - Identificativo della variante
-         * @param {string} cat - Categoria della variante
-         * @param {boolean} nofilter - Se true, non carica i filtri associati
-         * @returns {Promise<boolean>} Promise che risolve a true se il caricamento ha successo
-         */ load(id: string, _cat: any, nofilter?: boolean): Promise<boolean>;
+    des: any;
+    vdef: any;
+    h: any;
+    fromdim(t: any, e?: number): string;
+    load(e: any, a: any, i?: boolean): Promise<boolean>;
     limits: {}[] | {
         v: any[];
         datai: number;
         dataf: number;
     }[];
-    /**
-         * Carica il contenuto della variante da array di stringhe
-         * @private
-         * @param {string[]} lines - Array di stringhe contenenti la definizione della variante
-         * @returns {Promise<boolean>} Promise che risolve a true se il caricamento ha successo
-         */ private _loadContent;
+    _loadContent(t: any): Promise<boolean>;
     noerp: boolean;
-    /**
-         * Converte la variante in un vettore di righe
-         * @returns {string[]} Array di righe formattate
-         */ tovec(): string[];
-    /**
-         * Converte un codice nella sua rappresentazione CSV
-         * @param {string} cod - Codice da convertire
-         * @returns {string} Stringa CSV o codice originale se non trovato
-         */ tovar(cod: string, vcod?: string): string;
-    /**
-         * Verifica se un'opzione è valida
-         * @param {string} opz - Opzione da verificare
-         * @returns {boolean} True se l'opzione è valida
-         */ isvalidopz(opz: string): boolean;
-    /**
-         * Trova la prima opzione valida tra quelle disponibili
-         * @param {string} opz - Opzione da controllare per prima
-         * @returns {string|undefined} Prima opzione valida trovata o undefined
-         */ firstvalid(opz: string, defs?: any): string | undefined;
-    /**
-         * Resetta tutti i filtri applicati alla variante
-         */ resetfilter(): void;
-    /**
-         * Restituisce le chiavi valide ordinate alfabeticamente
-         * @returns {string[]} Array di chiavi valide
-         */ validkeys(): string[];
-    limitfiltra(filtra: any): void;
-    /**
-         * Applica i limiti configurati alle opzioni della variante
-         * @returns {Array|void} Array di limiti applicati o void se reset
-         */ limita(filtra: any): any[] | void;
-    /**
-         * Carica il contenuto esteso della variante
-         * @param {Object|string} content - Contenuto da caricare, può essere un oggetto o una stringa
-         * @returns {Promise<void>} Promise che si risolve al completamento del caricamento
-         */ loadContentExtended(content: any | string): Promise<void>;
+    tovec(): string[];
+    tovar(t: any, e?: string): any;
+    isvalidopz(t: any): boolean;
+    firstvalid(t: any, e?: any): any;
+    resetfilter(): void;
+    validkeys(): string[];
+    limitfiltra(t: any): void;
+    limita(t: any): void | {}[];
+    loadContentExtended(t: any): Promise<void>;
     todata(): {
         name: string;
-        des: string;
+        des: any;
         alias: string;
         obbligo: boolean;
-        h: any[] | {
-            des: string;
-        }[];
+        h: any;
         rows: {};
         limits: {}[] | {
             v: any[];
@@ -284,167 +213,69 @@ export class Variabile {
     };
     #private;
 }
-/**
- * Valida e separa un identificatore e una categoria
- * @param {string} id - Identificatore da validare (formato: "categoria/nome" o solo "nome")
- * @param {string} cat - Categoria di default
- * @throws {Error} Se manca la categoria
- * @returns {{name: string, cat: string}} Oggetto con nome e categoria validati
- */ export function checkmu(id: string, cat: string): {
-    name: string;
-    cat: string;
+export function checkmu(t: any, e: any): {
+    name: any;
+    cat: any;
 };
-/**
- * Valida un identificatore verificando che contenga solo caratteri permessi
- * @param {string} id - Identificatore da validare
- * @param {boolean} vuoto - Default false: Accetta valori vuoti!
- * @throws {Error} Se l'identificatore contiene caratteri non validi
- * @returns {string} Identificatore validato in minuscolo
- */ export function checkname(id: string, vuoto?: boolean): string;
-export function clamp(n: any, min?: number, max?: number): any;
-export function clean(k: any, locase?: boolean): any;
-export function dammivariante(amb: any, macro: any, ky: any): Promise<any>;
-export const errori: {
-    /**
-         * Azzera la lista degli errori
-         */ azzera(): void;
+export function checkname(t: any, e?: boolean): any;
+export function clamp(t: any, e?: number, a?: number): any;
+export function clean(t: any, e?: boolean): any;
+export function dammivariante(t: any, e: any, a: any): Promise<any>;
+declare const n: {
+    azzera(): void;
     err: any[];
-    /**
-         * Aggiunge un errore alla lista
-         * @param {string} msg - Messaggio di errore
-         * @param {Object} row - Informazioni aggiuntive sull'errore
-         */ add(msg: string, row: any): void;
-    /**
-         * Restituisce la lista completa degli errori
-         * @returns {Array} Lista degli errori
-         */ get(): any[];
-    /**
-         * Restituisce il numero di errori presenti
-         * @returns {number} Numero di errori
-         */ readonly length: number;
-    /**
-         * Converte la lista degli errori in stringa
-         * @returns {string} Rappresentazione testuale degli errori
-         */ toString(): string;
+    add(t: any, e: any): void;
+    get(): any[];
+    readonly length: number;
+    toString(): string;
 };
-/**
- * Converte una stringa in un oggetto JSON, gestendo errori e restituendo un valore di default se non valido
- * @param {string|Array|Object} str - Stringa da convertire in JSON, array o oggetto da restituire direttamente
- * @param {*} [def={}] - Valore di default da restituire in caso di errore di parsing
- * @throws {Error} Non genera eccezioni, gli errori vengono loggati internamente
- * @returns {*} L'oggetto JSON convertito dalla stringa, l'input originale se è un array/oggetto, o il valore di default in caso di errore
- * @example
- * fromjson('{"a": 1}') // returns {a: 1}
- * fromjson([1,2,3]) // returns [1,2,3]
- * fromjson('invalid json', {}) // returns {}
- */ export function fromjson(str: string | any[] | any, def?: any): any;
-/**
- * Estrae le proprietà non-funzione da un oggetto, escludendo chiavi specificate
- * @param {Object} obj - Oggetto da cui estrarre le proprietà
- * @param {string[]} [exclude] - Array di chiavi da escludere
- * @returns {Object} Nuovo oggetto con le proprietà estratte
- */ export function getOggetto(obj: any, exclude?: string[]): any;
-/**
- * Converte una stringa in array di colonne, gestendo diversi formati
- * @param {string} value - Stringa da convertire
- * @returns {string[]} Array di colonne
- */ export function getcolonne(value: string, keepquote?: boolean): string[];
-/**
- * Analizza una stringa per estrarre una coppia chiave-valore
- * @param {string} r - Stringa da analizzare (es: "chiave=valore")
- * @param {string} [sep='='] - Carattere separatore
- * @returns {{v: string, o: string, fl: boolean}} Oggetto contenente chiave (v), valore (o) e flag presenza separatore (fl)
- */ export function getcouple(r: string, sep?: string, locase?: boolean): {
-    v: string;
-    o: string;
+export function fromjson(t: any, e: any): any;
+export function getOggetto(t: any, e?: any[]): any;
+export function getcolonne(t: any, e?: boolean): any;
+export function getcouple(t: any, e?: string, a?: boolean): {
+    v: any;
+    o: any;
     fl: boolean;
 };
-/**
- * Formatta un messaggio di errore rimuovendo informazioni non necessarie
- * @param {Error|string} err - L'errore da formattare
- * @returns {string} Il messaggio di errore formattato
- */ export function geterrdes(err: Error | string): string;
-export function getheaddims(dims: any): any;
-export function gettipocolonna(cod: any): string;
-export function gettipofolder(cod: any): string;
-export function hash(obj: any): string;
-export function impostavariante(amb: any, macro: any, a: any, b: any, head: any): Promise<any>;
-export function intvaluta(amb: any, mac: any, str: any): Promise<any>;
-export function isJsonStr(str: any): boolean;
-export function isObject(value: any): boolean;
-export function muInit(cat: any, cbGetMacro: any, cbGetVariante: any, cbFunc: any, cbInfo: any, cbGetFile: any, cbLogga: any): Ambiente;
-/**
- * Funzione di logging che utilizza un callback personalizzato se disponibile
- * @param {...any} args - Argomenti da loggare
- */ export function logga(...args: any[]): void;
-/**
- * Valuta un'espressione matematica o logica e restituisce il risultato
- * @param {string|number} expression - L'espressione da valutare
- * @returns {number} Il risultato della valutazione dell'espressione
- * @description
- * Supporta operazioni matematiche di base, funzioni trigonometriche,
- * operatori di confronto e operazioni logiche.
- * Le funzioni supportate includono: sqrt, floor, abs, sin, cos, random, clamp, round
- */ export function muCalc(expression: string | number): number;
-/**
- * Rimuove i commenti dal codice sorgente mantenendo la struttura del codice
- * @param {string} codice - Il codice sorgente da processare
- * @param {boolean} tienivuoti - Se true mantiene le righe vuote
- * @returns {string[]} Array di righe di codice senza commenti
- */ export function muClComments(codice: string, tienivuoti: boolean): string[];
-/**
- * Analizza e organizza il codice in una struttura dati gerarchica
- * @param {string[]} tt - Array di righe di codice da analizzare
- * @param {boolean} acapo - Se true mantiene i ritorni a capo nel contenuto
- * @returns {Object[]} Array di oggetti rappresentanti la struttura del codice
- * @throws {Error} Se tt non è un array
- */ export function muClean(tt: string[], acapo?: boolean): any[];
-export function muCompileScript(codice: any): any;
-export function muEval(amb: any, mac: any, codice: any, options: any): any;
-export function muEvalScript(amb: Ambiente, codice: any, pars: any, reset?: boolean): Promise<{
+export function geterrdes(t: any): any;
+export function getheaddims(t: any): any;
+export function gettipocolonna(t: any): string;
+export function gettipofolder(t: any): string;
+export function hash(t: any): string;
+export function impostavariante(t: any, e: any, a: any, s: any, i: any): Promise<any>;
+export function intvaluta(t: any, e: any, a: any): Promise<any>;
+export function isJsonStr(t: any): boolean;
+export function isObject(t: any): boolean;
+export function muInit(t: any, e: any, a: any, s: any, i: any, r: any, n: any): Ambiente;
+export function logga(...t: any[]): void;
+export function muCalc(t: any): any;
+export function muClComments(t: any, e: any): any[];
+export function muClean(t: any, e?: boolean): {
+    tipo: any;
+    contenuto: any;
+}[];
+export function muCompileScript(t: any): any;
+export function muEval(t: any, e: any, a: any, s: any): any;
+export function muEvalScript(t: any, e: any, a: any, s?: boolean): Promise<{
     output: any;
-    vari: {};
+    vari: any;
     errori: {
-        /**
-             * Azzera la lista degli errori
-             */ azzera(): void;
+        azzera(): void;
         err: any[];
-        /**
-             * Aggiunge un errore alla lista
-             * @param {string} msg - Messaggio di errore
-             * @param {Object} row - Informazioni aggiuntive sull'errore
-             */ add(msg: string, row: any): void;
-        /**
-             * Restituisce la lista completa degli errori
-             * @returns {Array} Lista degli errori
-             */ get(): any[];
-        /**
-             * Restituisce il numero di errori presenti
-             * @returns {number} Numero di errori
-             */ readonly length: number;
-        /**
-             * Converte la lista degli errori in stringa
-             * @returns {string} Rappresentazione testuale degli errori
-             */ toString(): string;
+        add(t: any, e: any): void;
+        get(): any[];
+        readonly length: number;
+        toString(): string;
     };
 }>;
-export function muGenerate(macro: any, amb: any, genera: any, callback: any, isTestmode?: number): Promise<boolean>;
-/**
- * Analizza e processa i limiti definiti nel codice
- * @param {string} dati - Dati contenenti le definizioni dei limiti
- * @returns {Object[]} Array di oggetti rappresentanti i limiti processati
- */ export function muLimits(dati: string): any[];
-/**
- * Analizza il codice sorgente e restituisce un array di token con classi CSS
- * @param {string} tt - Il codice sorgente da analizzare
- * @param {boolean} isvar - Flag che indica se analizzare come variabile
- * @returns {Array<{class: string, text: string}>} Array di token con classi CSS
- */ export function muParsecode(tt: string, isvar: boolean): Array<{
+export function muGenerate(t: any, e: any, a: any, s: any, i?: number): Promise<boolean>;
+export function muLimits(t: any): {}[];
+export function muParsecode(t: any, e: any): {
     class: string;
-    text: string;
-}>;
-export function muValuta(mu: any, codice: any, azzera: any): any;
-export namespace mustr {
+    text: any;
+}[];
+export function muValuta(t: any, e: any, a: any): any;
+declare namespace x {
     namespace mus {
         namespace variants {
             let cod: string;
@@ -501,55 +332,36 @@ export namespace mustr {
         }
     }
 }
-export function newAmbiente(cat: any, maxmillis?: number): Ambiente;
-export function newMacro(amb: any, name: any): Macro;
+export function newAmbiente(t: any, e?: number): Ambiente;
+export function newMacro(t: any, e: any): Macro;
 export function newVariabile(): Variabile;
-export function newVariante(cod: any, cat: any, amb: any): Promise<Variante>;
-export function noquote(e: any): any;
-export function parselimitifromdb(rr: any): {}[];
-export function parselimitifromrule(limvec: any): {
+export function newVariante(t: any, e: any, a: any): Promise<Variante>;
+export function noquote(t: any): any;
+export function parselimitifromdb(t: any): {}[];
+export function parselimitifromrule(t: any): {
     v: any[];
     datai: number;
     dataf: number;
 }[];
-/**
- * Analizza variabili in un'espressione usando delimitatori
- * @param {string} ex - Espressione da analizzare
- * @param {number} k0 - Posizione iniziale
- * @param {string} inipar - Delimitatore iniziale ([, (, {)
- * @param {string} endpar - Delimitatore finale (], ), })
- * @param {boolean} [nonewline=false] - Se true, termina all'incontro di un newline
- * @returns {{i: number, res: string[]}} Risultato dell'analisi con posizione finale e array risultati
- */ export function parsevar(ex: string, k0: number, inipar: string, endpar: string, nonewline?: boolean): {
+export function parsevar(t: any, e: any, a: any, s: any, i?: boolean): {
+    i: any;
+    res: any[];
+} | {
     i: number;
-    res: string[];
+    res: any;
 };
-export function poppars(amb: any, tm: any): void;
-export function pushpars(amb: any, macro: any, parsfunzione: any, parsinit: any): Promise<{
-    v: string;
+export function poppars(t: any, e: any): void;
+export function pushpars(t: any, e: any, a: any, s: any): Promise<{
+    v: any;
     o: any;
 }[]>;
-export function quote(v: any): any;
-export function seedarray(arr: any, seed: any): any;
-export function seeder(n: any, seed?: string): number;
-/**
- * Classe per la gestione degli errori con funzionalità di accumulo e formattazione
- */
-/**
- * Copia le proprietà non-funzione da un oggetto sorgente a uno destinazione
- * @param {Object} objDestinazione - Oggetto destinazione
- * @param {Object} objSorgente - Oggetto sorgente
- */
-export function setOggetto(objDestinazione: any, objSorgente: any): void;
-export function sortrows(rows: any): {};
-/**
- * Esegue una semplice somma sincrona di due numeri
- * @param {number} a - Primo numero da sommare
- * @param {number} b - Secondo numero da sommare
- * @returns {number} La somma dei due numeri
- */
-export function testsync(a: number, b: number): number;
-export const tipicolonna: ({
+export function quote(t: any): any;
+export function seedarray(t: any, e: any): any;
+export function seeder(t: any, e?: string): number;
+export function setOggetto(t: any, e: any): void;
+export function sortrows(t: any): {};
+export function testsync(t: any, e: any): any;
+declare const k: ({
     cod: string;
     des: string;
     folder?: undefined;
@@ -558,22 +370,16 @@ export const tipicolonna: ({
     des: string;
     folder: string;
 })[];
-export const tipifree: string[];
-export const tipiheader: {
+declare const w: string[];
+declare const y: {
     cod: string;
     des: string;
 }[];
-/**
- * Restituisce il timestamp corrente in millisecondi
- * @returns {number} Timestamp corrente
- */ export function tk(): number;
-export function toCadPars(str: any): {};
+export function tk(): number;
+export function toCadPars(t: any): {};
 export function toJson(t: any): string;
-export function tonum(s: any, dec?: number): number;
-/**
- * Restituisce il timestamp corrente in millisecondi
- * @returns {number} Timestamp corrente
- */ export function xdt(): number;
+export function tonum(t: any, e?: number): number;
+export function xdt(): number;
 declare class Pickers {
     clear(): void;
     d: {};
@@ -581,7 +387,7 @@ declare class Pickers {
     key: any;
     reset(): void;
     pack(): void;
-    setkey(k: any): void;
-    add(data: any): string;
+    setkey(t: any): void;
+    add(t: any): string;
 }
-export { muInit as jsTest };
+export { n as errori, muInit as jsTest, x as mustr, k as tipicolonna, w as tipifree, y as tipiheader };