import type { Type_JSON } from './Utils';
/** Sens d'un port : ce qui entre dans le procédé, ce qui en sort. */
export type Type_UnitaryProcessPortDirection = 'input' | 'output';
/**
 * Nature de l'échange, au sens de l'ACV : avec une autre activité humaine
 * (technosphère) ou avec l'environnement (biosphère — émissions, prélèvements).
 * C'est la distinction que la passerelle Brightway attend pour ranger un
 * exchange dans la matrice technologique ou dans la matrice d'intervention.
 */
export type Type_UnitaryProcessExchangeKind = 'technosphere' | 'biosphere';
/**
 * Un port de la brique — un nœud d'échange du diagramme, vu comme une interface
 * du procédé, POUR UNE GRANDEUR DONNÉE. C'est par `node_id` que l'assemblage
 * (U2/U3) raccorde une sortie à une entrée.
 */
export type Type_UnitaryProcessPort = {
    node_id: string;
    direction: Type_UnitaryProcessPortDirection;
    quantity_ref?: string;
    port_type?: string;
    coefficient?: number;
    unit_ref?: string;
    exchange_kind?: Type_UnitaryProcessExchangeKind;
};
/**
 * Référence à la nomenclature de ports — l'objet PARTAGÉ entre briques, celui
 * qui rend l'assemblage possible. La brique n'en porte que le nom et,
 * éventuellement, la version : la nomenclature elle-même vit ailleurs.
 */
export type Type_UnitaryProcessNomenclatureRef = {
    name: string;
    version?: string;
};
/**
 * Niveau d'activité de référence : l'échelle à laquelle les coefficients ont
 * été établis. C'est le pivot de la composition — l'assemblage donne à chaque
 * brique SON niveau d'activité, et les coefficients s'y appliquent. Il est
 * UNIQUE pour toutes les grandeurs : c'est ce qui les rapporte les unes aux
 * autres.
 */
export type Type_UnitaryProcessActivityReference = {
    value: number;
    unit_ref?: string;
};
/** La section racine `process` d'un fichier de brique. */
export type Type_UnitaryProcess = {
    central_node_id: string;
    nomenclature_ref?: Type_UnitaryProcessNomenclatureRef;
    activity_reference?: Type_UnitaryProcessActivityReference;
    lifetime_years?: number;
    ports: Type_UnitaryProcessPort[];
};
/**
 * Identité d'un port : `(node_id, direction, quantity_ref ?? '')`. Deux ports de
 * même identité dans un fichier sont une contradiction (deux coefficients pour
 * le même échange), pas une redondance — d'où le rejet à la lecture.
 *
 * Exportée parce que l'assemblage et l'éditeur apparient des ports : que la
 * règle d'identité vive à UN seul endroit est ce qui empêche deux appariements
 * divergents.
 */
export declare const unitaryProcessPortKey: (port: Type_UnitaryProcessPort) => string;
/**
 * Lit la section `process` depuis le JSON, ou null si le fichier n'en porte pas
 * (cas ordinaire : ce n'est pas une brique) ou si elle est inutilisable.
 *
 * TOUT-OU-RIEN, y compris pour les ports pris un à un — le choix demande à être
 * dit : un port mal formé qu'on ignorerait en silence ferait une brique
 * PLAUSIBLE et FAUSSE, dont les coefficients d'entrée ne sommeraient plus à 1
 * sans que rien ne le signale, et la composition (U3) fermerait ses bilans sur
 * un procédé amputé. Mieux vaut « ce fichier n'est pas une brique » : le
 * diagramme, lui, reste entièrement lisible — la section est additive.
 *
 * LECTURE TOLÉRANTE (os#1380) : `ports` est accepté sous les deux formes — la
 * LISTE (forme courante) et le DICTIONNAIRE keyé par nœud de la forme U0
 * initiale, converti en liste sans `quantity_ref` (ces fichiers-là ne
 * mesuraient qu'une grandeur). L'écriture, elle, ne produit que la liste : un
 * fichier U0 relu puis réenregistré passe à la forme courante.
 */
export declare const unitaryProcessFromJSON: (json: unknown) => Type_UnitaryProcess | null;
/**
 * Forme JSON, symétrique de la lecture : membres absents omis, `ports` écrit
 * même vide (c'est la liste d'une brique sans port, pas une absence) et
 * TOUJOURS en liste — l'ancienne forme dictionnaire se lit encore mais ne
 * s'écrit plus.
 */
export declare const unitaryProcessToJSON: (unitary_process: Type_UnitaryProcess) => Type_JSON;
/**
 * Copie profonde de la section — pour `Class_Sankey.copyFrom`, où un partage de
 * référence ferait que retyper un port de la copie retyperait l'original.
 * Écrite à la main plutôt qu'avec `structuredClone` : la structure est petite,
 * connue, et le jsdom des tests ne garantit pas cette fonction.
 */
export declare const unitaryProcessClone: (unitary_process: Type_UnitaryProcess) => Type_UnitaryProcess;