import type { Class_DataTag, Class_Tag } from '../types/Tag';
import type { Class_DataTagGroup, Class_TagGroup } from '../types/TagGroup';
import { Type_JSON } from '../types/Utils';
import type { Class_LinkElement } from './Link';
import type { Class_NodeElement } from './Node';
export type ValueParentElement = Class_LinkElement | Class_NodeElement;
export declare const value_option_percent_constants_source: string[];
export declare const value_option_percent_constants_target: string[];
export declare const value_option_percent_constants: string[];
export declare const value_option_constants: readonly ["value", ...string[], "unit_ratio", "intervals"];
export type ValueOptionType = typeof value_option_constants[number];
export declare const unit_stock_percent_constants: readonly ["%SS", "%SD"];
export declare const unit_constants: readonly ["unit_name", "unit_model", "unit_tag", "other_unit_tag", ...string[], "%SS", "%SD", "unit_ratio", "normalized"];
export type UnitType = typeof unit_constants[number];
/**
 * Generic tree node for organizing values by data tags.
 * Children are either all trees (inner nodes) or all values (leaves).
 * @export
 * @class Class_ElementValueTree
 */
export declare class Class_ElementValueTree {
    parent: Class_ElementValueTree | ValueParentElement;
    children: {
        [tag_id: string]: Class_ElementValue;
    } | {
        [tag_id: string]: Class_ElementValueTree;
    };
    data_tag_group: Class_DataTagGroup;
    unit_data_tag(child: Class_ElementValueTree | Class_ElementValue): Class_DataTag | undefined;
    private _is_currently_deleted;
    constructor(parent: Class_ElementValueTree | ValueParentElement, data_tag_group: Class_DataTagGroup);
    protected createValue(_: Class_ElementValueTree | ValueParentElement): Class_ElementValue;
    delete(): void;
    copyFrom(element: Class_ElementValueTree): void;
    get has_result(): boolean;
    get has_intervals(): boolean;
    get has_data(): boolean;
    get has_collected_data(): boolean;
    set_only_data(): void;
    addFrom(element: Class_ElementValueTree): void;
    toJSON(kwargs?: Type_JSON): Type_JSON;
    /**
     * @param mark_missing_as_absent FICHIERS LEGACY (cf. `SankeyPersistence.fromJSON`) : une
     * étiquette de dataTag que le fichier ne mentionne PAS pour ce flux vaut « le flux n'existe
     * pas là », et non « valeur pas encore saisie ». Les feuilles correspondantes sont donc
     * marquées `structurally_absent` (#188), ce qui les masque au lieu de les tracer en fantôme
     * pointillé. Sans ce marquage, un diagramme legacy à granularités alternatives (un flux par
     * niveau, cf. « Filière végétale » : 18 flux au niveau 1, 50 au 2, 124 au 3) affichait à
     * chaque niveau les flux des DEUX autres en pointillé. Les fichiers modernes portent le
     * marqueur eux-mêmes (SEP l'écrit à la réconciliation) : pour eux une feuille absente garde
     * son sens de valeur manquante, d'où la garde de version.
     */
    fromJSON(json_object: Type_JSON, matching_taggs_id?: {
        [_: string]: string;
    }, matching_tags_id?: {
        [_: string]: {
            [_: string]: string;
        };
    }, mark_missing_as_absent?: boolean): void;
    /** Cf. `fromJSON` : propage le marqueur #188 à toutes les feuilles de la branche. */
    markStructurallyAbsent(): void;
    expand(data_tag_group: Class_DataTagGroup): this;
    prune(data_tag_group: Class_DataTagGroup): Class_ElementValue | Class_ElementValueTree;
    extend(data_tag: Class_DataTag): Class_ElementValue | Class_ElementValueTree | undefined;
    reduce(data_tag: Class_DataTag): void;
    removeChild(child: Class_ElementValue | Class_ElementValueTree): void;
    /**
     * #285 — replie le niveau d'arbre du groupe donné SANS PERTE avant un
     * prune(group) : chaque tranche (feuille sous un tag du groupe) est
     * « remontée » en valeurs coordonnées par le tag libre correspondant, puis
     * les valeurs des autres tranches sont transférées dans la tranche
     * SÉLECTIONNÉE, qui est placée en première position (celle que prune()
     * conserve). Les valeurs des flux n'étant pas additives (2026-07-18, ex.
     * unités parallèles), la valeur principale du flux reste celle de la tranche
     * sélectionnée — pas une somme. Les résultats de résolution des autres
     * tranches sont abandonnés.
     */
    collapseGroup(group: Class_DataTagGroup, tag_for: (tag_id: string) => Class_Tag | undefined, selected_tag_id?: string | undefined): void;
    /**
     * Annote une tranche avec son tag libre : les sous-valeurs existantes
     * reçoivent la coordonnée en plus ; une feuille sans sous-valeur mais avec
     * une donnée devient une sous-valeur unique portant cette donnée.
     */
    private _liftSlice;
    /**
     * Fusionne la tranche source dans la cible (feuille à feuille) : transfert
     * des valeurs coordonnées UNIQUEMENT — les scalaires de la cible (tranche
     * sélectionnée) sont conservés tels quels, pas de somme (valeurs non
     * additives).
     */
    private _mergeSliceInto;
    getValueForDataTags(data_tags: Class_DataTag[]): Class_ElementValue | null;
    getStructurallyAbsentForDataTags(data_tags: Class_DataTag[]): boolean;
    setValueForDataTags(data_tags: Class_DataTag[], val: Class_ElementValue): null | undefined;
    getTextValueForDataTags(data_tags: Class_DataTag[]): string | null;
    getDataTagIdFromChild(child: Class_ElementValue | Class_ElementValueTree): string | undefined;
    getDataTagsIdCombination(child: Class_ElementValue | Class_ElementValueTree): string[];
    getMaxValue(): null;
    getAllValues(): {
        [_: string]: [Class_ElementValue, Class_DataTag[] | undefined];
    };
    private kindOfChildren;
    private removeAndReplaceChild;
    private removeChildFromDataTagId;
    get rootElement(): ValueParentElement | null;
    get link(): Class_LinkElement | null;
    get data_tag(): Class_DataTag | null;
}
export { Class_ElementValueTree as Class_LinkValueTree };
/**
 * Abstract base class for element values (link flux, stock, etc.).
 * Provides common infrastructure: parent chain, id, tags, tree operations.
 * Subclasses define their own value fields.
 *
 * @export
 * @class Class_ElementValue
 */
export declare const VALUE_OBJECTIVE_MIN = "min";
export declare const VALUE_OBJECTIVE_MAX = "max";
/**
 * SA#507 — « infini », écrit avec ou sans signe. Rend 0 si ce n'en est pas un,
 * +1 ou -1 sinon : le signe compte dans la case Valeur, où « -infini » dit
 * « le plus petit possible ».
 */
export declare function parseInfinity(text: string | null | undefined): number;
/**
 * SA#507 — l'intention que porte la case Valeur d'un flux DÉJÀ déclaré objectif
 * (incertitude infinie) : « infini » y dit « la plus grande valeur possible »,
 * « -infini » « la plus petite ». Tout le reste rend null — c'est un nombre, et
 * ce nombre est la cible.
 *
 * Le mot ne devient JAMAIS un nombre : la sentinelle passée telle quelle à un
 * solveur ruinait son conditionnement (SA#487).
 */
export declare function parseValueObjective(text: string | null | undefined): string | null;
export declare class Class_ElementValue {
    parent: Class_ElementValueTree | ValueParentElement;
    unit_data_tag(): Class_DataTag | undefined;
    text_value: string | null;
    structurally_absent: boolean;
    value_objective: string | null;
    value_objective_rank: number | null;
    value_objective_target: number | null;
    /** Cf. `Class_ElementValueTree.fromJSON` : feuille qu'un fichier legacy ne mentionne pas. */
    markStructurallyAbsent(): void;
    protected _data_value: (number | null)[];
    protected _data_min: (number | null)[];
    protected _data_max: (number | null)[];
    protected _data_uncertainty: (number | null)[];
    protected _result_value: (number | null)[];
    protected _result_min: (number | null)[];
    protected _result_max: (number | null)[];
    /** Subclasses override to define vector size */
    protected get vectorSize(): number;
    private _id;
    private _flux_tags;
    private _taggs_dict;
    private _tagged_values;
    private _is_currently_deleted;
    constructor(parent: Class_ElementValueTree | ValueParentElement);
    delete(): void;
    copyFrom(element: Class_ElementValue): void;
    addFrom(_element: Class_ElementValue): void;
    toJSON(_kwargs?: Type_JSON): Type_JSON;
    fromJSON(json_object: Type_JSON, matching_taggs_id?: {
        [_: string]: string;
    }, _matching_tags_id?: {
        [_: string]: {
            [_: string]: string;
        };
    }): void;
    draw(): void;
    expand(data_tag_group: Class_DataTagGroup): Class_ElementValueTree;
    hasGivenTag(tag: Class_Tag): boolean;
    addTag(tag: Class_Tag): void;
    removeTag(tag: Class_Tag): void;
    addTaggedValue(id?: string | undefined): Class_ElementTaggedValue;
    removeTaggedValue(sub: Class_ElementTaggedValue): void;
    get tagged_values_list(): Class_ElementTaggedValue[];
    get has_tagged_values(): boolean;
    get has_result(): boolean;
    get has_intervals(): boolean;
    get has_data(): boolean;
    get has_collected_data(): boolean;
    set_only_data(): void;
    getMaxValue(): number;
    getAllValues(): {
        [_: string]: [Class_ElementValue, Class_DataTag[] | undefined];
    };
    private addTagToGroupTagDict;
    private removeTagToGroupTagDict;
    get id(): string;
    get rootElement(): ValueParentElement | null;
    get link(): Class_LinkElement | null;
    get flux_tags_dict(): Class_Tag[];
    get flux_tags_list(): Class_Tag[];
    get flux_taggs_dict(): {
        [_: string]: Class_TagGroup;
    };
    get taggs_dict(): {
        [x: string]: Class_Tag[];
    };
    get flux_taggs_list(): Class_TagGroup[];
    get data_tags_id(): string[];
    get data_tagg(): Class_DataTagGroup | null;
    get data_tag(): Class_DataTag | null;
}
/**
 * #284 — Sous-valeur d'une feuille (NOTE-FUSION-TAGS.md §3.0) : détail facultatif
 * d'une Class_ElementValue portant une quantité et une coordonnée éparse — au
 * plus UN tag par groupe de tags de flux, sur zéro ou plusieurs groupes.
 * Permet plusieurs quantités étiquetées différemment sur un même flux sans
 * dupliquer le lien (ex. A→B = 6 {acier, route} + 4 {cuivre, rail}).
 *
 * @export
 * @class Class_ElementTaggedValue
 */
export declare class Class_ElementTaggedValue {
    parent: Class_ElementValue;
    private _id;
    private _value;
    private _tags;
    private _is_currently_deleted;
    private _label_visible;
    constructor(parent: Class_ElementValue, id?: string | undefined);
    delete(): void;
    copyFrom(sub_to_copy: Class_ElementTaggedValue): void;
    toJSON(): Type_JSON;
    fromJSON(json_object: Type_JSON): void;
    draw(): void;
    hasGivenTag(tag: Class_Tag): boolean;
    /**
     * Ajoute un tag à la coordonnée. Contrainte du modèle : au plus un tag par
     * groupe — un tag existant du même groupe est remplacé.
     */
    addTag(tag: Class_Tag): void;
    removeTag(tag: Class_Tag): void;
    getTagForGroup(tagg: Class_TagGroup): Class_Tag | undefined;
    get id(): string;
    get value(): number | null;
    set value(_: number | null);
    get label_visible(): boolean;
    set label_visible(_: boolean);
    get tags_list(): Class_Tag[];
}
/**
 * Value object for link flux.
 * Holds data/result/target/min/max scalars for a single flux.
 *
 * @export
 * @class Class_LinkValue
 * @extends {Class_ElementValue}
 */
export declare class Class_LinkValue extends Class_ElementValue {
    static readonly SRC = 0;
    static readonly TGT = 1;
    private _ratio_unit_tag;
    private _data_source;
    private _data_url;
    private _data_hypothesis;
    private _determination;
    get ratio_unit_tag(): Class_DataTag | null;
    set ratio_unit_tag(_: Class_DataTag | null);
    get determination(): number | null;
    set determination(_: number | null);
    get data_source(): string | null;
    set data_source(_: string | null);
    get data_url(): string | null;
    set data_url(_: string | null);
    get data_hypothesis(): string | null;
    set data_hypothesis(_: string | null);
    value_option: ValueOptionType;
    protected get vectorSize(): number;
    constructor(parent: Class_ElementValueTree | ValueParentElement);
    get has_result(): boolean;
    get has_intervals(): boolean;
    get has_data(): boolean;
    get has_collected_data(): boolean;
    set_only_data(): void;
    get valueResult(): number | null;
    set valueResult(_: number | null);
    get valueData(): number | null;
    set valueData(_: number | null);
    get valueResultTarget(): number | null;
    set valueResultTarget(_: number | null);
    get valueDataTarget(): number | null;
    set valueDataTarget(_: number | null);
    get data_min(): number | null;
    set data_min(_: number | null);
    get data_max(): number | null;
    set data_max(_: number | null);
    get data_uncertainty(): number | null;
    set data_uncertainty(_: number | null);
    get result_min(): number | null;
    set result_min(_: number | null);
    get result_max(): number | null;
    set result_max(_: number | null);
    copyFrom(element: Class_ElementValue): void;
    addFrom(element: Class_ElementValue): void;
    /**
     * §3.0ter — valeur que doit voir le solveur (champ scalaire historique) :
     * quand le flux est ventilé par des groupes PORTEURS, c'est la valeur du
     * TAG SÉLECTIONNÉ (le scalaire interne n'est qu'un cache) ; null sinon
     * (le scalaire fait foi).
     */
    private solverDataValue;
    toJSON(_kwargs?: Type_JSON): Type_JSON;
    private fromJSONLegacy;
    fromJSON(json_object: Type_JSON, matching_taggs_id?: {
        [_: string]: string;
    }, matching_tags_id?: {
        [_: string]: {
            [_: string]: string;
        };
    }): void;
    getMaxValue(): number;
}
/**
 * Value object for node stocks.
 * Holds initial and variation data/result (vector of size 2).
 *
 * @export
 * @class Class_StockValue
 * @extends {Class_ElementValue}
 */
export declare class Class_StockValue extends Class_ElementValue {
    static readonly INI = 0;
    static readonly VAR = 1;
    protected get vectorSize(): number;
    constructor(parent: Class_ElementValueTree | ValueParentElement);
    get has_result(): boolean;
    get has_intervals(): boolean;
    get has_data(): boolean;
    set_only_data(): void;
    get stockInitialData(): number | null;
    set stockInitialData(_: number | null);
    get stockInitialResult(): number | null;
    set stockInitialResult(_: number | null);
    get stockVariationData(): number | null;
    set stockVariationData(_: number | null);
    get stockVariationResult(): number | null;
    set stockVariationResult(_: number | null);
    get has_stock_data(): boolean;
    copyFrom(element: Class_ElementValue): void;
    addFrom(element: Class_ElementValue): void;
    toJSON(_kwargs?: Type_JSON): Type_JSON;
    fromJSON(json_object: Type_JSON, matching_taggs_id?: {
        [_: string]: string;
    }, matching_tags_id?: {
        [_: string]: {
            [_: string]: string;
        };
    }): void;
    getMaxValue(): number;
}