import { WorkBook, BookType } from "xlsx";
import { JSONSchemaType } from "ajv";
import { Constellation } from "./client.js";
import { schémaFonctionOublier, schémaFonctionSuivi, élémentsBd } from "./types.js";
import { type donnéesBdExportées } from "./bds.js";
import { erreurRègle, erreurValidation, règleColonne, règleVariable } from "./valid.js";
import type { catégorieVariables } from "./variables.js";
export interface élémentDonnées<T extends élémentBdListeDonnées = élémentBdListeDonnées> {
    données: T;
    id: string;
}
export type élémentBdListeDonnées = {
    [key: string]: élémentsBd;
};
export type donnéesTableauExportation = {
    nomTableau: string;
    données: élémentBdListeDonnées[];
    fichiersSFIP: Set<string>;
};
export type InfoCol = {
    id: string;
    variable?: string;
    index?: boolean;
};
export type InfoColAvecVariable = InfoCol & {
    variable: string;
};
export type InfoColAvecCatégorie = InfoColAvecVariable & {
    catégorie?: catégorieVariables;
};
export type conversionDonnées = conversionDonnéesNumérique | conversionDonnéesDate | conversionDonnéesChaîne;
export type conversionDonnéesNumérique = {
    type: "numérique";
    opération?: opérationConversionNumérique | opérationConversionNumérique[];
    systèmeNumération?: string;
};
export type opérationConversionNumérique = {
    op: "+" | "-" | "/" | "*" | "^";
    val: number;
};
export type conversionDonnéesDate = {
    type: "horoDatage";
    système: string;
    format: string;
};
export type conversionDonnéesChaîne = {
    type: "chaîne";
    langue: string;
};
export declare const schémaBdRègles: JSONSchemaType<{
    [idRègle: string]: règleColonne;
}>;
export declare function élémentsÉgaux(élément1: {
    [key: string]: élémentsBd;
}, élément2: {
    [key: string]: élémentsBd;
}): boolean;
export declare function indexÉlémentsÉgaux(élément1: {
    [key: string]: élémentsBd;
}, élément2: {
    [key: string]: élémentsBd;
}, index: string[]): boolean;
export type différenceTableaux = différenceVariableColonne | différenceIndexColonne | différenceColonneManquante | différenceColonneSupplémentaire;
export type différenceVariableColonne = {
    type: "variableColonne";
    sévère: true;
    idCol: string;
    varColTableau?: string;
    varColTableauLiée?: string;
};
export type différenceIndexColonne = {
    type: "indexColonne";
    sévère: true;
    idCol: string;
    colTableauIndexée: boolean;
};
export type différenceColonneManquante = {
    type: "colonneManquante";
    sévère: true;
    idManquante: string;
};
export type différenceColonneSupplémentaire = {
    type: "colonneSupplémentaire";
    sévère: false;
    idExtra: string;
};
export type structureBdTableau = {
    type: "tableau";
    noms: string;
    données: string;
    colonnes: string;
    règles: string;
};
export declare class Tableaux {
    client: Constellation;
    constructor({ client }: {
        client: Constellation;
    });
    créerTableau({ idBd }: {
        idBd: string;
    }): Promise<string>;
    copierTableau({ id, idBd, copierDonnées, }: {
        id: string;
        idBd: string;
        copierDonnées?: boolean;
    }): Promise<string>;
    _confirmerPermission({ idTableau, }: {
        idTableau: string;
    }): Promise<void>;
    suivreDifférencesAvecTableau({ idTableau, idTableauRéf, f, }: {
        idTableau: string;
        idTableauRéf: string;
        f: schémaFonctionSuivi<différenceTableaux[]>;
    }): Promise<schémaFonctionOublier>;
    changerColIndex({ idTableau, idColonne, val, }: {
        idTableau: string;
        idColonne: string;
        val: boolean;
    }): Promise<void>;
    changerIdColonne({ idTableau, idColonne, nouvelleIdColonne, }: {
        idTableau: string;
        idColonne: string;
        nouvelleIdColonne: string;
    }): Promise<void>;
    réordonnerColonneTableau({ idTableau, idColonne, position, }: {
        idTableau: string;
        idColonne: string;
        position: number;
    }): Promise<void>;
    suivreIndex({ idTableau, f, }: {
        idTableau: string;
        f: schémaFonctionSuivi<string[]>;
    }): Promise<schémaFonctionOublier>;
    suivreDonnées<T extends élémentBdListeDonnées>({ idTableau, f, clefsSelonVariables, }: {
        idTableau: string;
        f: schémaFonctionSuivi<élémentDonnées<T>[]>;
        clefsSelonVariables?: boolean;
    }): Promise<schémaFonctionOublier>;
    formaterÉlément({ é, colonnes, fichiersSFIP, langues, }: {
        é: élémentBdListeDonnées;
        colonnes: InfoColAvecCatégorie[];
        fichiersSFIP: Set<string>;
        langues?: string[];
    }): Promise<élémentBdListeDonnées>;
    suivreDonnéesExportation({ idTableau, langues, f, }: {
        idTableau: string;
        langues?: string[];
        f: schémaFonctionSuivi<donnéesTableauExportation>;
    }): Promise<schémaFonctionOublier>;
    exporterDonnées({ idTableau, langues, doc, nomFichier, patience, }: {
        idTableau: string;
        langues?: string[];
        doc?: WorkBook;
        nomFichier?: string;
        patience?: number;
    }): Promise<donnéesBdExportées>;
    exporterTableauÀFichier({ idTableau, langues, doc, nomFichier, patience, formatDoc, dossier, inclureDocuments, }: {
        idTableau: string;
        langues?: string[];
        doc?: WorkBook;
        nomFichier?: string;
        patience?: number;
        formatDoc: BookType | "xls";
        dossier?: string;
        inclureDocuments?: boolean;
    }): Promise<string>;
    ajouterÉlément<T extends élémentBdListeDonnées>({ idTableau, vals, }: {
        idTableau: string;
        vals: T | T[];
    }): Promise<string[]>;
    modifierÉlément({ idTableau, vals, idÉlément, }: {
        idTableau: string;
        vals: {
            [key: string]: élémentsBd | undefined;
        };
        idÉlément: string;
    }): Promise<void>;
    vérifierClefsÉlément<T extends élémentBdListeDonnées>({ idTableau, élément, }: {
        idTableau: string;
        élément: élémentBdListeDonnées;
    }): Promise<T>;
    effacerÉlément({ idTableau, idÉlément, }: {
        idTableau: string;
        idÉlément: string;
    }): Promise<void>;
    combinerDonnées({ idTableauBase, idTableau2, patience, }: {
        idTableauBase: string;
        idTableau2: string;
        patience?: number;
    }): Promise<void>;
    convertirDonnées<T extends élémentBdListeDonnées[]>({ idTableau, données, conversions, importerFichiers, cheminBaseFichiers, donnéesExistantes, }: {
        idTableau: string;
        données: T;
        conversions?: {
            [col: string]: conversionDonnées;
        };
        importerFichiers: boolean;
        cheminBaseFichiers?: string;
        donnéesExistantes?: élémentBdListeDonnées[];
    }): Promise<T>;
    importerDonnées({ idTableau, données, conversions, cheminBaseFichiers, }: {
        idTableau: string;
        données: élémentBdListeDonnées[];
        conversions?: {
            [col: string]: conversionDonnées;
        };
        cheminBaseFichiers?: string;
    }): Promise<void>;
    sauvegarderNomsTableau({ idTableau, noms, }: {
        idTableau: string;
        noms: {
            [key: string]: string;
        };
    }): Promise<void>;
    sauvegarderNomTableau({ idTableau, langue, nom, }: {
        idTableau: string;
        langue: string;
        nom: string;
    }): Promise<void>;
    effacerNomTableau({ idTableau, langue, }: {
        idTableau: string;
        langue: string;
    }): Promise<void>;
    suivreNomsTableau({ idTableau, f, }: {
        idTableau: string;
        f: schémaFonctionSuivi<{
            [key: string]: string;
        }>;
    }): Promise<schémaFonctionOublier>;
    ajouterColonneTableau({ idTableau, idVariable, idColonne, }: {
        idTableau: string;
        idVariable?: string;
        idColonne?: string;
    }): Promise<string>;
    effacerColonneTableau({ idTableau, idColonne, }: {
        idTableau: string;
        idColonne: string;
    }): Promise<void>;
    suivreColonnesTableau({ idTableau, f, }: {
        idTableau: string;
        f: schémaFonctionSuivi<InfoCol[]>;
    }): Promise<schémaFonctionOublier>;
    suivreColonnesEtCatégoriesTableau({ idTableau, f, }: {
        idTableau: string;
        f: schémaFonctionSuivi<InfoColAvecCatégorie[]>;
    }): Promise<schémaFonctionOublier>;
    suivreVariables({ idTableau, f, }: {
        idTableau: string;
        f: schémaFonctionSuivi<string[]>;
    }): Promise<schémaFonctionOublier>;
    ajouterRègleTableau<R extends règleVariable = règleVariable>({ idTableau, idColonne, règle, }: {
        idTableau: string;
        idColonne: string;
        règle: R;
    }): Promise<string>;
    effacerRègleTableau({ idTableau, idRègle, }: {
        idTableau: string;
        idRègle: string;
    }): Promise<void>;
    suivreRègles({ idTableau, f, }: {
        idTableau: string;
        f: schémaFonctionSuivi<règleColonne[]>;
    }): Promise<schémaFonctionOublier>;
    suivreValidDonnées({ idTableau, f, }: {
        idTableau: string;
        f: schémaFonctionSuivi<erreurValidation[]>;
    }): Promise<schémaFonctionOublier>;
    suivreValidRègles({ idTableau, f, }: {
        idTableau: string;
        f: schémaFonctionSuivi<erreurRègle[]>;
    }): Promise<schémaFonctionOublier>;
    effacerTableau({ idTableau }: {
        idTableau: string;
    }): Promise<void>;
}