import type { schémaFonctionSuivi, schémaFonctionOublier, PasNondéfini, élémentsBd } from "./types.js";
import type { Journal } from "./types.js";
export declare const obtenir: <T>(f: (args: {
    si: (f: (x: T) => boolean) => (x: T) => void;
    siDéfini: () => (x: T | undefined) => void;
    siVide: () => (x: T) => void;
    siNul: () => (x: T) => void;
    siPasVide: () => (x: T) => void;
    siPasNul: () => (x: T) => void;
    tous: () => (x: T) => void;
}) => Promise<schémaFonctionOublier>) => Promise<T>;
export declare const suivreFonctionImbriquée: <T>({ fRacine, f, fSuivre, journal, }: {
    fRacine: (args: {
        fSuivreRacine: (nouvelIdImbriqué?: string) => Promise<void>;
    }) => Promise<schémaFonctionOublier>;
    f: schémaFonctionSuivi<T | undefined>;
    fSuivre: (args: {
        id: string;
        fSuivre: schémaFonctionSuivi<T | undefined>;
    }) => Promise<schémaFonctionOublier>;
    journal?: Journal;
}) => Promise<schémaFonctionOublier>;
export declare const uneFois: <T>(f: (fSuivi: schémaFonctionSuivi<T>) => Promise<schémaFonctionOublier>, condition?: (x?: T) => boolean | Promise<boolean>) => Promise<T>;
export declare const faisRien: () => Promise<void>;
export declare const ignorerNonDéfinis: <T>(f: schémaFonctionSuivi<T>) => schémaFonctionSuivi<T | undefined>;
export declare const attendreStabilité: <T>(n: number) => ((v: T) => Promise<boolean>);
export declare const suivreDeFonctionListe: <T, U extends PasNondéfini, V, W extends schémaFonctionOublier | ({
    fOublier: schémaFonctionOublier;
} & {
    [key: string]: unknown;
})>({ fListe, f, fBranche, fIdDeBranche, fRéduction, journal, }: {
    fListe: (args: {
        fSuivreRacine: (éléments: T[]) => Promise<void>;
    }) => Promise<W>;
    f: schémaFonctionSuivi<V[]>;
    fBranche: (args: {
        id: string;
        fSuivreBranche: schémaFonctionSuivi<U>;
        branche: T;
    }) => Promise<schémaFonctionOublier | undefined>;
    fIdDeBranche?: (b: T) => string;
    fRéduction?: (branches: U[]) => V[];
    journal?: Journal;
}) => Promise<W>;
type NoUndefinedField<T> = {
    [P in keyof T]-?: NoUndefinedField<NonNullable<T[P]>>;
};
type élémentsBdOuNonDéfini = number | boolean | string | {
    [clef: string]: élémentsBdOuNonDéfini;
} | Array<élémentsBd> | undefined;
export declare const effacerPropriétésNonDéfinies: <T extends {
    [clef: string]: élémentsBdOuNonDéfini | undefined;
}>(objet: T) => NoUndefinedField<T>;
export {};