/** @public */
export declare class AgentConnectix {
    private impl;
    constructor(agentTexteur: AgentTexteur, recuperePortWebSocket: () => Promise<number>);
    connecteAvecAntidote(): Promise<void>;
    lanceCorrecteur(): void;
    lanceDictionnaires(): void;
    lanceGuides(): void;
    lanceAntiOups(sujet: string, corps: string, destinataires: [string] | undefined, id: string): void;
    ferme(): void;
}

/** @public */
export declare abstract class AgentTexteur {
    /**
     * Méthode appelée lorsque la communication entre l’AgentTexteur et Antidote est établie.
     * À surcharger pour faire les initialisations nécessaires.
     */
    sessionDemarree(): void;
    /**
     * Méthode appelée lorsque la communication est rompue.
     */
    sessionTerminee(): void;
    /**
     * Méthode obligatoire : applique une correction dans le texteur.
     */
    abstract corrigeDansTexteur(params: ParamsRemplace): boolean;
    /**
     * Indique si les zones de texte sont encore accessibles et corrigibles.
     */
    zonesDeTexteDisponibles(): boolean;
    /**
     * Méthode obligatoire : retourne la configuration du texteur.
     */
    abstract configuration(): ConfigurationTexteur;
    /**
     * Retourne le chemin du document en correction (vide possible).
     */
    cheminDocument(): string;
    /**
     * Méthode obligatoire : indique s’il est possible de corriger
     * à l’endroit demandé.
     */
    abstract peutCorriger(params: ParamsEditionPossible): boolean;
    /**
     * Demande de changer la sélection dans le texteur.
     */
    selectionneIntervalle(_params: ParamsSelectionne): void;
    /**
     * Appelé lorsqu’un nouvel état de correction est disponible.
     */
    nouvelleMemoireCorrection(_params: ParamsNouvelleMemoireCorrection): void;
    /**
     * Appelé lorsqu’Antidote demande à mettre le focus sur la zone en édition.
     */
    metsFocusSurLeDocument(): void;
    /**
     * Appelé lorsqu’Antidote demande à remettre le texteur en avant-plan.
     */
    retourneAuTexteur(): void;
    /**
     * Méthode appelée lorsque qu'Antidote répond à une requête d'Anti-Oups!.
     */
    reponseAntiOups(_params: ParamsReponseAntiOups): void;
    /**
     * Appelé lorsqu’Antidote demande à envoyer le document.
     */
    envoi(): void;
    /**
     * Méthode obligatoire : retourne les zones de texte à corriger.
     */
    abstract zonesACorriger(params: ParamsDonneZonesACorriger): ZoneDeTexteConnectix[];
}

/** @public */
export declare class AgentTexteurTextArea extends AgentTexteur {
    private champsACorriger;
    constructor(champsACorriger: HTMLElement[]);
    corrigeDansTexteur(params: ParamsRemplace): boolean;
    configuration(): ConfigurationTexteur;
    peutCorriger(params: ParamsEditionPossible): boolean;
    selectionneIntervalle(params: ParamsSelectionne): void;
    zonesACorriger(_params: ParamsDonneZonesACorriger): ZoneDeTexteConnectix[];
}

/** @public */
export declare const Antidote: {
    lanceCorrecteurAntidoteWeb: (noeud: NoeudOuListeNoeuds, creeFenetre?: FonctionCreeFenetreAntidoteWeb, fonctionCorrectionAppliquee?: FonctionCorrectionAppliquee) => void;
    lanceCorrecteurAntidote: (noeud: NoeudOuListeNoeuds, creeFenetre?: FonctionCreeFenetreAntidoteWeb, fonctionCorrectionAppliquee?: FonctionCorrectionAppliquee) => void;
    AppUrl: string;
    AppOrigine: string;
};

/** @public */
export declare function appliqueCorrection(noeud: HTMLElement, plageACorriger: PlageChaine, plageAVerifier?: PlageChaine): boolean;

/** @public */
export declare interface ConfigurationTexteur {
    /**
     * Titre du document. Sera affiché dans la barre-titre du correcteur d’Antidote.
     */
    titreDocument?: string;
    /**
     * Le type de retour de charriot (ex. : `\n`, `\r`, `\r\n`).
     */
    retourCharriot?: string;
    /**
     * Type indiquant comment gérer la cache de l’état de correction.
     */
    typeIdentifiantCache?: TypeIdentifiantCache;
    /**
     * Indique si on permet l’insertion de retour de charriot à partir du correcteur.
     */
    permetRetourCharriot?: boolean;
    /**
     * Indique si le texteur permet l’usage de l’espace insécable.
     */
    permetEspaceInsecable?: boolean;
    /**
     * Indique si le texteur permet l’usage de l’espace fine.
     */
    permetEspaceFine?: boolean;
    /**
     * Indique si le contexte permet l'envoi d'un courriel à partir d’Antidote (Anti-Oups!)
     */
    permetEnvoiCourriel?: boolean;
    /**
     * Indique s’il est possible de remplacer le texte sans nécessairement faire une sélection.
     */
    remplaceSansSelection?: boolean;
    /**
     * Données représentant l’état de la dernière correction.
     */
    memoireCorrection?: Uint8Array | string;
    /**
     * Indique le type de document qui sera corrigé.
     */
    filtreActif?: TypeDocument;
    /**
     * Données JSON correspondant aux réglages à utiliser lors de la correction.
     * Si absent, les réglages de l’utilisateur seront utilisés.
     */
    reglagesAntidote?: Reglages;
}

/** @public */
export declare const ConnecteurAntidote: {
    estDetectay: () => boolean;
    annoncePresence: () => void;
    lanceCorrecteur: (listeNoeuds: HTMLElement[]) => void;
    recuperePortWebSocket: () => Promise<number>;
};

/** @public */
export declare function creeFenetreCordova(): FenetreAntidoteWeb;

/** @public */
export declare function creeFenetreWindowPostMessage(): FenetreAntidoteWeb | null;

/** @public */
export declare interface FenetreAntidoteWeb {
    envoieMessageVersAWeb(leMessageJSON: MessageAntidote): void;
    initialiseCommunicationAntidoteWeb(): void;
    affiche(): void;
    retourneAuTexteur(): void;
}

/** @public */
export declare type FonctionCorrectionAppliquee = () => void;

/** @public */
export declare type FonctionCreeFenetreAntidoteWeb = () => FenetreAntidoteWeb | null;

/** @public */
export declare function gestionnaireMessageDepuisAWeb(event: MessageEvent<MessageAntidote>): void;

/**
 * Classe représentant une zone de texte à corriger.
 */
/** @public */
export declare interface InfoStyle {
    /**
     * Position de début du style.
     */
    positionDebut: number;
    /**
     * Position de fin du style.
     */
    positionFin: number;
    /**
     * Sorte du style de texte.
     */
    style: StyleTexte;
}

/**
 * Copyright (c) 2025 Druide informatique
 * This software is licensed under the MIT License.
 * Ce logiciel est autorisé sous licence MIT.
 */
/** @public */
export declare interface Message {
    /** Sérialisation en JSON */
    toJSON(): string;
}

/** @public */
export declare interface MessageAntidote {
    cdaw_version?: string;
    type?: string;
    message?: string;
    _dib105?: string;
    _dib100?: {
        _dib30: string;
        _dib31: number;
        _dib32: number;
        _dib99: string;
    }[];
    _dib106?: boolean;
    _dib29?: boolean;
    _dib99?: string;
    _dib49?: number;
    _dib50?: number;
    _dib37?: string;
    _dib81?: string;
    _dib92?: string;
    _pb12d?: string;
    debutContexte?: number;
    finContexte?: number;
}

/** @public */
export declare type NoeudOuListeNoeuds = HTMLElement | HTMLElement[];

/**
 * Paramètres lorsqu’une demande de zones de texte est demandée à l’AgentTexteur.
 */
/** @public */
export declare interface ParamsDonneZonesACorriger {
    /**
     * Indique si on doit retourner les zones de texte seulement pour la sélection ou tout le document.
     */
    pourSelectionActive?: boolean;
}

/**
 * Paramètres lorsqu’on reçoit le message pour signifier si c’est toujours possible de faire un remplacement.
 */
/** @public */
export declare interface ParamsEditionPossible {
    /**
     * Identifiant de la zone de texte où faire la vérification.
     */
    idZone: string;
    /**
     * Chaine attendue à l’emplacement spécifié par les positions `positionDebut` et `positionFin`.
     */
    contexte: string;
    /**
     * Début de la position de `contexte`.
     */
    positionDebut: number;
    /**
     * Fin de la position de `contexte`.
     */
    positionFin: number;
}

/**
 * Paramètres lorsqu’on reçoit un nouvel état de correction.
 */
/** @public */
export declare interface ParamsNouvelleMemoireCorrection {
    /**
     * Les données binaires de l’état de correction.
     * À sauvegarder à un endroit qui sera disponible lors d’une prochaine session de correction
     * avec le (ou les) même document.
     */
    donnees: Uint8Array | string;
}

/**
 * Paramètres lorsqu’on reçoit le message pour faire un remplacement dans le texte original.
 */
/** @public */
export declare interface ParamsRemplace {
    /**
     * Identifiant de la zone de texte où faire le remplacement.
     */
    idZone: string;
    /**
     * Chaine à remplacer dans le texte.
     */
    nouvelleChaine: string;
    /**
     * Début de la position du remplacement.
     */
    positionRemplacementDebut: number;
    /**
     * Fin de la position du remplacement.
     */
    positionRemplacementFin: number;
}

/**
 * Paramètres lorsqu’on reçoit une réponse d'Anti-Oups!.
 */
/** @public */
export declare interface ParamsReponseAntiOups {
    /**
     * Chaine de l'identifiant donnée lors de la demande Anti-Oups! (voir `RequeteSortanteAntiOups`)
     */
    id: string;
    /**
     * Chaine d'erreur s'il y a eu une erreur de communication ou de protocole (Optionel)
     */
    codeErreur: string | undefined;
    /**
     * Liste de détections identifiées par Antidote dans la demande Anti-Oups!
     */
    detections: [TypeDetectionAntiOups] | undefined;
}

/**
 * Paramètres lorsqu’on reçoit le message de changement de sélection.
 */
/** @public */
export declare interface ParamsSelectionne {
    /**
     * Identifiant de la zone de texte où faire la sélection.
     */
    idZone: string;
    /**
     * Début de la position de la sélection à changer.
     */
    positionDebut: number;
    /**
     * Fin de la position de la sélection à changer.
     */
    positionFin: number;
}

/**
 * Copyright (c) 2025 Druide informatique
 * This software is licensed under the MIT License.
 * Ce logiciel est autorisé sous licence MIT.
 */
/** @public */
export declare interface PlageChaine {
    debut: number;
    fin: number;
    chaine: string;
}

/** @public */
export declare function recupereTexte(noeud: HTMLElement): string;

/**
 * Copyright (c) 2025 Druide informatique
 * This software is licensed under the MIT License.
 * Ce logiciel est autorisé sous licence MIT.
 */
/**
 * Type représentant les réglages pour Antidote.
 */
/** @public */
export declare type Reglages = unknown;

/** @public */
export declare function selectionneIntervalle(element: HTMLElement, debut: number, fin: number): void;

/**
 * Copyright (c) 2025 Druide informatique
 * This software is licensed under the MIT License.
 * Ce logiciel est autorisé sous licence MIT.
 */
/**
 * Énumération des sortes de styles de texte appliqués sur le texte.
 */
/** @public */
export declare enum StyleTexte {
    gras = "gras",
    italique = "italique",
    exposant = "exposant",
    indice = "indice",
    barre = "barre"
}

/**
 * Copyright (c) 2025 Druide informatique
 * This software is licensed under the MIT License.
 * Ce logiciel est autorisé sous licence MIT.
 */
/**
 * Liste des différents types de détection retournés par l’Anti-Oups!.
 */
/** @public */
export declare enum TypeDetectionAntiOups {
    erreurs = "erreurs",
    typographie = "typographie",
    piecesJointes = "piecesJointes",
    langueInactive = "langueInactive",
    tonVexant = "tonVexant"
}

/**
 * Copyright (c) 2025 Druide informatique
 * This software is licensed under the MIT License.
 * Ce logiciel est autorisé sous licence MIT.
 */
/**
 * Énumération des types de documents pris en charge par Antidote.
 * Cela correspond aux sortes de balisages supportés par Antidote.
 */
/** @public */
export declare enum TypeDocument {
    texte = "texte",
    markdown = "markdown",
    latex = "latex",
    subrip = "subrip",
    html = "html"
}

/**
 * Copyright (c) 2025 Druide informatique
 * This software is licensed under the MIT License.
 * Ce logiciel est autorisé sous licence MIT.
 */
/**
 * Énumération indiquant le type d’identifiant de cache de correction à utiliser.
 */
/** @public */
export declare enum TypeIdentifiantCache {
    forceEmplacementFichier = "forceEmplacementFichier"
}

/**
 * Représente une zone de texte à corriger.
 */
/** @public */
export declare interface ZoneDeTexteConnectix {
    /** Chaine correspondant au texte à corriger */
    texte: string;
    /** Identifiant unique de la zone de texte */
    idZone: string;
    /** Position de début de la sélection dans le texteur, ou undefined si aucune sélection */
    positionSelectionDebut?: number;
    /** Position de fin de la sélection dans le texteur, ou undefined si aucune sélection */
    positionSelectionFin?: number;
    /** Indique si cette zone a le focus (reçoit les événements de clavier) */
    zoneEstEnFocus: boolean;
    /** Liste des styles présents dans `texte` */
    infoStyle?: InfoStyle[];
}

export { }