@tricoteuses/senat 3.1.4 → 3.1.5

package/lib/src/model/questions.js

@@ -0,0 +1,91 @@
+import { streamUnsafeQuery } from "../databases_postgres.js";
+function buildFindAllQuestionsQuery() {
+    return {
+        params: [],
+        query: `
+      select
+        tam_questions.repub::text as republique,
+        tam_questions.legislature::text as legislature,
+        tam_questions.natquecod as nature,
+        naturequestion.natquelib as nature_libelle,
+        tam_questions.numero as numero,
+        tam_questions.reference as reference,
+        tam_questions.titre as titre,
+        tam_questions.nom as nom,
+        tam_questions.prenom as prenom,
+        tam_questions.nomtechnique as nom_technique,
+        tam_questions.codequalite as civilite,
+        tam_questions.matricule as matricule,
+        tam_questions.cirnum::text as circonscription_numero,
+        tam_questions.circonscription as circonscription,
+        tam_questions.groupe as groupe,
+        tam_questions.ratgrp as type_appartenance,
+        to_char(tam_questions.datejodepot, 'YYYY-MM-DD') as date_publication_JO,
+        tam_questions.pagejodepot::text as page_JO,
+        rtrim(tam_questions.mindepotlib) as ministere_depot,
+        tam_questions.mindepotid::text as ministere_depot_id,
+        to_char(tam_ministeres.datedebut, 'YYYY-MM-DD') as ministere_depot_date_debut,
+        to_char(tam_questions.datejotran, 'YYYY-MM-DD') as date_transmission,
+        tam_questions.mintranlib as ministere_transmission,
+        to_char(tam_questions.datejorep1, 'YYYY-MM-DD') as date_reponse_JO,
+        to_char(tam_questions.dateerr, 'YYYY-MM-DD') as date_erratum_JO,
+        tam_questions.pageerr::text as page_erratum_JO,
+        tam_questions.minreplib1 as ministere_reponse,
+        to_char(tam_questions.datecloture, 'YYYY-MM-DD') as date_cloture,
+        to_char(tam_questions.datesignal, 'YYYY-MM-DD') as date_signalement,
+        tam_questions.refquerappelee as reference_question_rappelee,
+        tam_questions.txtque as texte,
+        tam_questions.txterrque as texte_erratum,
+        tam_questions.rubrique as rubrique,
+        sortquestion.sorquelib as sort,
+        sortquestion.sorquecod as sort_code,
+        sortquestion.sorquenumtri::text as sort_tri,
+        etatquestion.etaquelib as etat_libelle,
+        etatquestion.etaquecod as etat_code,
+        etatquestion.etaquenumtri::text as etat_tri,
+        (
+          select coalesce(json_agg(theme_rows.libelle order by theme_rows.theme_order nulls last), '[]'::json)
+          from (
+            select
+              the.thelib as libelle,
+              the.thenouidt as theme_order
+            from regexp_matches(coalesce(tam_questions.themes, ''), '#(\\d+)', 'g') as matches(match)
+            join senat.questions_the as the on the.thenouidt::text = matches.match[1]
+            order by the.thenouidt asc
+          ) as theme_rows
+        ) as themes,
+        (
+          select coalesce(json_agg(response_rows order by response_rows.date_reponse_JO nulls last), '[]'::json)
+          from (
+            select
+              to_char(tam_reponses.datejorep, 'YYYY-MM-DD') as date_reponse_JO,
+              tam_reponses.pagejorep::text as page_JO,
+              to_char(tam_reponses.errdate, 'YYYY-MM-DD') as date_erratum_JO,
+              tam_reponses.minreplib as ministere_reponse,
+              tam_reponses.minrepid::text as ministere_reponse_id,
+              tam_reponses.urlrep as url,
+              tam_reponses.txtrep as texte,
+              tam_reponses.txterrrep as texte_erratum
+            from senat.questions_tam_reponses as tam_reponses
+            where tam_reponses.idque = tam_questions.id
+            order by tam_reponses.datejorep asc
+          ) as response_rows
+        ) as reponses
+      from senat.questions_tam_questions as tam_questions
+      left join senat.questions_tam_ministeres as tam_ministeres on tam_questions.mindepotid = tam_ministeres.minid
+      left join senat.questions_sortquestion as sortquestion on tam_questions.sorquecod::text = sortquestion.sorquecod
+      left join senat.questions_naturequestion as naturequestion on tam_questions.natquecod = naturequestion.natquecod
+      left join senat.questions_etatquestion as etatquestion on tam_questions.etaquecod::text = etatquestion.etaquecod
+    `,
+    };
+}
+export async function* findAll() {
+    const { query, params } = buildFindAllQuestionsQuery();
+    for await (const row of streamUnsafeQuery(query, params)) {
+        yield {
+            ...row,
+            reponses: row.reponses ?? [],
+            themes: row.themes ?? [],
+        };
+    }
+}

package/lib/src/model/scrutins.d.ts

@@ -0,0 +1,48 @@
+export interface VoteScrutinRow {
+    groupe_politique_code: string | null;
+    groupe_politique_id: string | null;
+    matricule_delegant: string | null;
+    matricule_votant: string;
+    position: string | null;
+    statut_votant: string | null;
+    titre_votant: string | null;
+}
+export interface GroupeVotantRow {
+    groupe_politique_code: string | null;
+    nombre_abstentions: string;
+    nombre_contre: string;
+    nombre_non_votants: string;
+    nombre_pour: string;
+    nombre_votants: string;
+}
+export interface MiseAuPointRow {
+    ordre: string | null;
+    texte: string;
+    url: string | null;
+}
+export interface ScrutinResult {
+    date_scrutin: string | null;
+    date_scrutin_effective: string | null;
+    groupes_votants: GroupeVotantRow[];
+    intitule: string | null;
+    lecture_id: string | null;
+    lecture_libelle: string | null;
+    mises_au_point: MiseAuPointRow[];
+    nombre_contre: string | null;
+    nombre_contre_seance: string | null;
+    nombre_majorite: string | null;
+    nombre_majorite_seance: string | null;
+    nombre_pour: string | null;
+    nombre_pour_seance: string | null;
+    nombre_suffrages: string | null;
+    nombre_suffrages_seance: string | null;
+    nombre_votants: string | null;
+    nombre_votants_seance: string | null;
+    note: string | null;
+    numero: string;
+    session: string;
+    signet_dossier: string | null;
+    type_lecture: string | null;
+    votes: VoteScrutinRow[];
+}
+export declare function findAllScrutins(fromSession?: number): AsyncGenerator<ScrutinResult, void, unknown>;

package/lib/src/model/scrutins.js

@@ -0,0 +1,121 @@
+import { streamUnsafeQuery } from "../databases_postgres.js";
+function buildFindAllScrutinsQuery(fromSession) {
+    const params = [];
+    const whereSession = fromSession === undefined ? "" : "where scr.sesann >= $1";
+    if (fromSession !== undefined) {
+        params.push(String(fromSession));
+    }
+    return {
+        params,
+        query: `
+      select
+        scr.sesann::text as session,
+        scr.scrnum::text as numero,
+        rtrim(date_seance.lecidt) as lecture_id,
+        rtrim(lecture.leccom) as lecture_libelle,
+        loi.signet as signet_dossier,
+        rtrim(typlec.typleclib) as type_lecture,
+        to_char(scr.scrdat, 'YYYY-MM-DD') as date_scrutin,
+        to_char(scr.scrdateff, 'YYYY-MM-DD') as date_scrutin_effective,
+        replace(scr.scrint, E'\\u0092', '''') as intitule,
+        scr.scrbaspag as note,
+        scr.scrmaj::text as nombre_majorite,
+        scr.scrmajsea::text as nombre_majorite_seance,
+        scr.scrvot::text as nombre_votants,
+        scr.scrvotsea::text as nombre_votants_seance,
+        scr.scrsuf::text as nombre_suffrages,
+        scr.scrsufsea::text as nombre_suffrages_seance,
+        scr.scrcon::text as nombre_contre,
+        scr.scrconsea::text as nombre_contre_seance,
+        scr.scrpou::text as nombre_pour,
+        scr.scrpousea::text as nombre_pour_seance,
+        (
+          select coalesce(json_agg(vote_rows order by vote_rows.membership_start desc nulls last), '[]'::json)
+          from (
+            select
+              votsen.senmat as matricule_votant,
+              votsen.senmatdel as matricule_delegant,
+              posvot.posvotlib as position,
+              stavot.stavotlib as statut_votant,
+              titsen.titsenlib as titre_votant,
+              memgrppol.memgrppolid::text as groupe_politique_id,
+              memgrppol.grppolcod as groupe_politique_code,
+              memgrppol.memgrppoldatdeb as membership_start
+            from senat.dosleg_votsen as votsen
+            left join senat.dosleg_titsen as titsen on titsen.titsencod = votsen.titsencod
+            left join senat.dosleg_stavot as stavot on stavot.stavotidt = votsen.stavotidt
+            left join senat.dosleg_posvot as posvot on posvot.posvotcod = votsen.posvotcod
+            left join senat.sens_memgrppol as memgrppol
+              on memgrppol.senmat = votsen.senmat
+             and memgrppol.memgrppoldatdeb <= scr.scrdat
+             and (memgrppol.memgrppoldatfin >= scr.scrdat or memgrppol.memgrppoldatfin is null)
+            where votsen.scrnum = scr.scrnum
+              and votsen.sesann = scr.sesann
+          ) as vote_rows
+        ) as votes,
+        (
+          select coalesce(json_agg(group_rows order by group_rows.groupe_politique_code nulls last), '[]'::json)
+          from (
+            select
+              unique_votes.grppolcod as groupe_politique_code,
+              sum(case when unique_votes.posvotlib = 'pour' then 1 else 0 end)::text as nombre_pour,
+              sum(case when unique_votes.posvotlib = 'contre' then 1 else 0 end)::text as nombre_contre,
+              sum(case when unique_votes.posvotlib = 'abstention' then 1 else 0 end)::text as nombre_abstentions,
+              sum(case when unique_votes.posvotlib = 'non-votant' then 1 else 0 end)::text as nombre_non_votants,
+              count(unique_votes.senmat)::text as nombre_votants
+            from (
+              select
+                votsen.senmat,
+                posvot.posvotlib,
+                stavot.stavotlib,
+                memgrppol.grppolcod,
+                row_number() over (
+                  partition by votsen.senmat, votsen.scrnum, votsen.sesann
+                  order by memgrppol.memgrppoldatdeb desc nulls last
+                ) as vote_rank
+              from senat.dosleg_votsen as votsen
+              left join senat.dosleg_posvot as posvot on posvot.posvotcod = votsen.posvotcod
+              left join senat.dosleg_stavot as stavot on stavot.stavotidt = votsen.stavotidt
+              left join senat.sens_memgrppol as memgrppol
+                on memgrppol.senmat = votsen.senmat
+               and memgrppol.memgrppoldatdeb <= scr.scrdat
+               and (memgrppol.memgrppoldatfin >= scr.scrdat or memgrppol.memgrppoldatfin is null)
+              where votsen.scrnum = scr.scrnum
+                and votsen.sesann = scr.sesann
+            ) as unique_votes
+            where unique_votes.vote_rank = 1
+            group by unique_votes.grppolcod
+          ) as group_rows
+        ) as groupes_votants,
+        (
+          select coalesce(json_agg(correction_rows order by correction_rows.ordre nulls last), '[]'::json)
+          from (
+            select
+              corscr.corscrtxt as texte,
+              corscr.corscrord::text as ordre,
+              corscr.corscrurl as url
+            from senat.dosleg_corscr as corscr
+            where corscr.scrnum = scr.scrnum
+          ) as correction_rows
+        ) as mises_au_point
+      from senat.dosleg_scr as scr
+      left join senat.dosleg_date_seance as date_seance on scr.code = date_seance.code
+      left join senat.dosleg_lecass as lecass on date_seance.lecidt = lecass.lecassidt
+      left join senat.dosleg_lecture as lecture on lecture.lecidt = lecass.lecidt
+      left join senat.dosleg_loi as loi on loi.loicod = lecture.loicod
+      left join senat.dosleg_typlec as typlec on typlec.typleccod = lecture.typleccod
+      ${whereSession}
+    `,
+    };
+}
+export async function* findAllScrutins(fromSession) {
+    const { query, params } = buildFindAllScrutinsQuery(fromSession);
+    for await (const row of streamUnsafeQuery(query, params)) {
+        yield {
+            ...row,
+            groupes_votants: row.groupes_votants ?? [],
+            mises_au_point: row.mises_au_point ?? [],
+            votes: row.votes ?? [],
+        };
+    }
+}

package/lib/src/model/seance.d.ts

@@ -0,0 +1,3 @@
+import { CompteRendu } from "../types/compte_rendu.js";
+export declare function parseCompteRenduIntervalFromFile(xmlFilePath: string, startIndex: number, endIndex: number, agendaEventId: string): Promise<CompteRendu | null>;
+export declare function sessionStartYearFromDate(d: Date): number;

package/lib/src/model/seance.js

@@ -0,0 +1,267 @@
+import fs from "fs";
+import * as cheerio from "cheerio";
+import { toCRDate } from "./util.js";
+import { makeReunionUid } from "../utils/reunion_parsing.js";
+import { yyyymmddFromPath } from "../utils/date.js";
+import { decodeHtmlEntities, dedupeSpeaker, fixApostrophes, norm } from "../utils/string_cleaning.js";
+export async function parseCompteRenduIntervalFromFile(xmlFilePath, startIndex, endIndex, agendaEventId) {
+    try {
+        const raw = fs.readFileSync(xmlFilePath, "utf8");
+        const $ = cheerio.load(raw, { xml: false });
+        const metadonnees = extractMetadonnees($, xmlFilePath);
+        const order = $("body *").toArray();
+        const idx = new Map(order.map((el, i) => [el, i]));
+        const totalNodes = order.length;
+        const clampedStart = Math.max(0, Math.min(startIndex, totalNodes - 1));
+        const clampedEnd = Math.max(0, Math.min(endIndex, totalNodes - 1));
+        const intervals = [
+            {
+                start: clampedStart,
+                end: clampedEnd,
+            },
+        ];
+        metadonnees.sommaire = extractSommaireForIntervals($, idx, intervals);
+        const points = [];
+        let ordre = 0;
+        const addPoint = (p) => points.push({ ...p, ordre_absolu_seance: String(++ordre) });
+        // Interventions
+        $("div.intervenant").each((_, block) => {
+            if (!elementInAnyInterval(block, idx, intervals))
+                return;
+            const $block = $(block);
+            $block
+                .find([
+                "p[class^='titre_S']",
+                "p.mention_titre",
+                "p.intitule_titre",
+                "p.mention_chapitre",
+                "p.intitule_chapitre",
+                "p.mention_article",
+                "p.intitule_article",
+                "p.mention_section",
+                "p.intitule_section",
+            ].join(","))
+                .remove();
+            const firstP = $block.find("p").first();
+            if (!firstP || firstP.length === 0)
+                return;
+            const speakerLabelRaw = firstP.find(".orateur_nom").text() || firstP.find("a.lien_senfic").text() || "";
+            const speakerLabel = dedupeSpeaker(speakerLabelRaw);
+            const { mat, nom: nomCRI, qua: quaCRI } = readIntervenantMeta($block);
+            const qualFromSpans = extractAndRemoveLeadingQualite($, $block);
+            const qualite = norm(decodeHtmlEntities(quaCRI || "")) || qualFromSpans;
+            const canonicalName = dedupeSpeaker(nomCRI || speakerLabel);
+            const role = roleForSpeaker(speakerLabel) || roleForSpeaker(qualite) || roleForSpeaker(quaCRI || "");
+            const speechHtml = sanitizeInterventionHtml($, $block);
+            const speechText = norm(cheerio.load(speechHtml).text() || "");
+            if (!speechText)
+                return;
+            addPoint({
+                code_grammaire: "PAROLE_GENERIQUE",
+                roledebat: role,
+                orateurs: { orateur: { nom: canonicalName, id: mat || "", qualite } },
+                texte: { _: speechHtml },
+            });
+        });
+        const contenu = {
+            quantiemes: {
+                journee: metadonnees.dateSeance,
+                session: metadonnees.session,
+            },
+            point: points,
+        };
+        const yyyymmdd = yyyymmddFromPath(xmlFilePath);
+        const dateISO = `${yyyymmdd.slice(0, 4)}-${yyyymmdd.slice(4, 6)}-${yyyymmdd.slice(6, 8)}`;
+        const seanceRef = makeReunionUid(dateISO, "SP", agendaEventId, null);
+        return {
+            uid: `CRSSN${yyyymmdd}E${agendaEventId}`,
+            seanceRef,
+            sessionRef: metadonnees.session,
+            metadonnees,
+            contenu,
+        };
+    }
+    catch (e) {
+        console.error(`[CRI] parseInterval error file=${xmlFilePath} interval=[${startIndex}..${endIndex}] event=${agendaEventId}:`, e);
+        return null;
+    }
+}
+export function sessionStartYearFromDate(d) {
+    // Session (1th oct N → 30 sept N+1)
+    const m = d.getMonth();
+    const y = d.getFullYear();
+    return m >= 9 ? y : y - 1;
+}
+function roleForSpeaker(labelOrQualite) {
+    const s = (labelOrQualite || "").toLowerCase();
+    if (/^(m\.|mme)?\s*(le|la)\s+pr[ée]sident(e)?\b/.test(s) || /\bpr[ée]sident[e]?\s+de\s+séance\b/.test(s))
+        return "président";
+    return "";
+}
+function readIntervenantMeta($block) {
+    const int = $block.find("cri\\:intervenant").first();
+    if (int.length)
+        return { mat: int.attr("mat") || undefined, nom: int.attr("nom") || undefined, qua: int.attr("qua") || undefined };
+    const html = $block.html() || "";
+    const m = html.match(/<!--\s*cri:intervenant\b([^>]+)-->/i);
+    if (!m)
+        return {};
+    const out = {};
+    const re = /(\w+)="([^"]*)"/g;
+    let a;
+    while ((a = re.exec(m[1])))
+        out[a[1]] = decodeHtmlEntities(a[2]);
+    return { mat: out["mat"], nom: out["nom"], qua: out["qua"] };
+}
+function extractAndRemoveLeadingQualite($, $block) {
+    const firstP = $block.find("p").first();
+    if (firstP.length === 0)
+        return "";
+    const parts = [];
+    let stop = false;
+    firstP.contents().each((_, node) => {
+        if (stop)
+            return;
+        if (node.type === "tag") {
+            const $node = $(node);
+            if ($node.hasClass("orateur_nom")) {
+                $node.remove();
+                return;
+            }
+            if ($node.hasClass("orateur_qualite")) {
+                parts.push($node.text() || "");
+                $node.remove();
+                return;
+            }
+            const t = norm($node.text() || "");
+            if (t)
+                stop = true;
+            else
+                $node.remove();
+        }
+        else if (node.type === "text") {
+            const textNode = node;
+            const t = norm(textNode.data || "");
+            if (!t || /^[:.,;–—-]+$/.test(t)) {
+                textNode.data = "";
+                return;
+            }
+            stop = true;
+        }
+    });
+    return fixApostrophes(norm(parts.join(" ")));
+}
+function sanitizeInterventionHtml($, $block) {
+    const ps = $block.find("p").toArray();
+    const cleaned = ps
+        .map((p) => {
+        const $p = $(p).clone();
+        $p.find(".orateur_nom, .orateur_qualite").remove();
+        $p.find("a").each((_, a) => {
+            const $a = $(a);
+            $a.replaceWith($a.text());
+        });
+        $p.find(".info_entre_parentheses").each((_, el) => {
+            const txt = $(el).text();
+            $(el).replaceWith($("<em/>").text(txt));
+        });
+        $p.find("span").each((_, span) => {
+            const $s = $(span);
+            if (!$s.text().trim())
+                $s.remove();
+        });
+        const inner = ($p.html() || "").trim();
+        if (!inner)
+            return null;
+        return `<p>${inner}</p>`;
+    })
+        .filter(Boolean);
+    return cleaned.join("<br/>");
+}
+function extractSommaireForIntervals($, idx, intervals) {
+    const inIv = (el) => elementInAnyInterval(el, idx, intervals);
+    const root = $("body");
+    const sommaire = { presidentSeance: { _: "" }, sommaire1: [] };
+    // (1) Présidence (tm2) — première ligne dans l’intervalle
+    const pres = root
+        .find("p.tm2")
+        .filter((_, el) => inIv(el))
+        .first();
+    if (pres.length)
+        sommaire.presidentSeance = { _: norm(pres.text()) };
+    // (2) Paras tm5 présents dans l’intervalle
+    const paras = [];
+    root.find("p.tm5").each((_, el) => {
+        if (!inIv(el))
+            return;
+        const t = norm($(el).text());
+        if (t)
+            paras.push({ _: t });
+    });
+    if (paras.length)
+        sommaire.para = paras.length === 1 ? paras[0] : paras;
+    // (3) Items de 1er niveau (tm3) présents dans l’intervalle
+    const items = [];
+    root.find("p.tm3").each((_, el) => {
+        if (!inIv(el))
+            return;
+        const $p = $(el);
+        const full = norm($p.text() || "");
+        if (!full)
+            return;
+        const numMatch = full.match(/^(\d+)\s*[.\-–—]\s*/);
+        const valeur = numMatch ? numMatch[1] : undefined;
+        // prefere intitule in ancre <a> if present
+        const a = $p.find("a").first();
+        const intituleRaw = a.length ? a.text() : full.replace(/^(\d+)\s*[.\-–—]\s*/, "");
+        const intitule = norm(intituleRaw);
+        // id_syceron from href="#Niv1_SOMx"
+        const href = (a.attr("href") || "").trim();
+        const idSyceron = href.startsWith("#") ? href.slice(1) : href;
+        const titreStruct = { id_syceron: idSyceron || "", intitule };
+        items.push({ valeur_pts_odj: valeur, titreStruct });
+    });
+    if (items.length)
+        sommaire.sommaire1 = items;
+    return sommaire;
+}
+function extractMetadonnees($, filePath) {
+    let dateText = norm($("h1, h2, .page-title").first().text() || "");
+    if (!dateText)
+        dateText = norm($("p").first().text() || "");
+    const dateMatch = dateText.match(/\b(\d{1,2}\s+\w+\s+\d{4})\b/i);
+    const allText = norm($("body").text() || "");
+    const sessionMatch = allText.match(/\bsession\s+(\d{4}-\d{4})\b/i);
+    let dateSeance = dateMatch?.[1] || "";
+    if (!dateSeance) {
+        const m = filePath.match(/d(\d{4})(\d{2})(\d{2})\.xml$/i);
+        if (m)
+            dateSeance = `${m[1]}-${m[2]}-${m[3]}`;
+    }
+    dateSeance = toCRDate(dateSeance, null);
+    return {
+        dateSeance,
+        dateSeanceJour: dateSeance,
+        numSeanceJour: "",
+        numSeance: "",
+        typeAssemblee: "SN",
+        legislature: "",
+        session: sessionMatch?.[1] || "",
+        nomFichierJo: "",
+        validite: "",
+        etat: "",
+        diffusion: "",
+        version: "1.0",
+        environnement: "",
+        heureGeneration: new Date(),
+    };
+}
+function elementInAnyInterval(el, idx, intervals) {
+    const p = idx.get(el);
+    if (p == null)
+        return false;
+    for (const iv of intervals)
+        if (p >= iv.start && p < iv.end)
+            return true;
+    return false;
+}

package/lib/src/model/sens.d.ts

@@ -0,0 +1,112 @@
+export interface FonctionRow {
+    date_debut: string | null;
+    date_fin: string | null;
+    libelle: string | null;
+}
+export interface MandatSenateurRow {
+    code_circonscription: string | null;
+    date_debut: string | null;
+    date_fin: string | null;
+    etat: string | null;
+    etat_debut: string | null;
+    etat_fin: string | null;
+}
+export interface MandatOrganismeRow {
+    code_organisme: string;
+    date_debut: string | null;
+    date_fin: string | null;
+    etat: string | null;
+    fonctions: FonctionRow[];
+    libelle: string | null;
+    type_code_organisme: string | null;
+    type_organisme: string | null;
+}
+export interface AdressePointContactRow {
+    bureau_distributeur: string | null;
+    code_cedex: string | null;
+    code_postal: string | null;
+    commune: string | null;
+    complement: string | null;
+    complement2: string | null;
+    libelle_cedex: string | null;
+    nom_voie: string | null;
+    numero_voie: string | null;
+}
+export interface TelephonePointContactRow {
+    numero: string | null;
+    type: string;
+}
+export interface PointContactRow {
+    adresses: AdressePointContactRow[];
+    id: string;
+    libelle: string | null;
+    telephones: TelephonePointContactRow[];
+    type: string;
+}
+export interface UrlRow {
+    code_url: string;
+    url: string;
+}
+export interface SenateurResult {
+    PCS_INSEE: string | null;
+    PCS_INSEE_24: string | null;
+    PCS_INSEE_42: string | null;
+    PCS_INSEE_8: string | null;
+    circonscription: string | null;
+    code_circonscription: string | null;
+    code_commission_permanente: string | null;
+    code_groupe_politique: string | null;
+    commission_permanente: string | null;
+    commissions: MandatOrganismeRow[];
+    courrier_electronique: string | null;
+    date_deces: string | null;
+    date_naissance: string | null;
+    delegations: MandatOrganismeRow[];
+    description_profession: string | null;
+    etat: string;
+    fonction_bureau_senat: string | null;
+    fonctions_bureau: FonctionRow[];
+    groupe_politique: string | null;
+    groupes: MandatOrganismeRow[];
+    mandats_senateur: MandatSenateurRow[];
+    matricule: string;
+    nom_usuel: string | null;
+    points_contact: PointContactRow[];
+    prenom_usuel: string;
+    qualite: string;
+    siege: string | null;
+    url_hatvp: string | null;
+    urls: UrlRow[];
+}
+export interface CirconscriptionResult {
+    article: string | null;
+    code: string;
+    date_debut: string | null;
+    date_fin: string | null;
+    etat: string | null;
+    identifiant: string;
+    libelle_departement: string;
+    libelle_region: string;
+    nombre_senateurs: string | null;
+    url: string | null;
+}
+export interface OrganismeResult {
+    code: string;
+    date_debut: string | null;
+    date_fin: string | null;
+    etat: string | null;
+    libelle: string | null;
+    libelle_court: string | null;
+    libelle_long: string | null;
+    type_code: string;
+    type_libelle: string | null;
+    url: string | null;
+}
+export declare function findAll(): AsyncGenerator<SenateurResult, void, unknown>;
+export declare function findAllCirconscriptions(): AsyncGenerator<CirconscriptionResult, void, unknown>;
+export declare function findAllOrganismes(): AsyncGenerator<OrganismeResult, void, unknown>;
+export declare function findActif(): AsyncGenerator<{
+    senmat: string;
+    sennomuse: string | null;
+    senprenomuse: string;
+}, void, unknown>;