@tricoteuses/senat 2.22.11 → 2.22.13

package/lib/model/commission.js

@@ -0,0 +1,269 @@
+import * as cheerio from "cheerio";
+import path from "path";
+import { makeReunionUid } from "../utils/reunion_parsing";
+import { norm } from "../utils/string_cleaning";
+import { frDateToISO, hourShortToStartTime } from "../utils/date";
+import { toCRDate } from "./util";
+const PARA_h3_SEL = "p.sh_justify, p.sh_center, p.sh_marge, p[align], li, h3";
+function findDayRoot($, targetISO) {
+    let $root = $();
+    $("h2").each((_, el) => {
+        const txt = norm($(el).text());
+        const m = txt.match(/(?:Lundi|Mardi|Mercredi|Jeudi|Vendredi|Samedi|Dimanche)\s+(.+)$/i);
+        const iso = m ? frDateToISO(m[1]) : undefined;
+        if (iso === targetISO && $root.length === 0)
+            $root = $(el);
+    });
+    return $root;
+}
+function normalizeSpaces(s) {
+    return s.replace(/[\u00A0\u202F\u2009]/g, " ");
+}
+function stripIntroPunct(s) {
+    return s.replace(/^[\s]*[.:;]?\s*(?:[–—-]\s*)+/u, "");
+}
+function collectLeadingHeaderStrongEls($, $clone) {
+    const els = [];
+    const nodes = $clone.contents().toArray();
+    for (const node of nodes) {
+        if (node.type === "text") {
+            if (norm(node.data || ""))
+                break;
+            continue;
+        }
+        if (node.type === "tag") {
+            const $n = $(node);
+            if ($n.is("strong, b")) {
+                els.push(node);
+                continue;
+            }
+            if ($n.is("a") && $n.children("strong, b").length) {
+                $n.children("strong, b").each((_, el) => {
+                    els.push($(el));
+                });
+                continue;
+            }
+            break;
+        }
+    }
+    return els;
+}
+// Remove orateur's name from text and clean intro punct
+export function getRemainingTextAfterSpeakerHeader($, $p) {
+    const $clone = $p.clone();
+    // 1) Remove <strong> at start
+    const headerStrongEls = collectLeadingHeaderStrongEls($, $clone);
+    for (const el of headerStrongEls)
+        $(el).remove();
+    // 2) normalize + clean intro punct
+    let remainingHtml = $clone.html() || "";
+    remainingHtml = normalizeSpaces(cheerio.load(remainingHtml).text());
+    remainingHtml = stripIntroPunct(remainingHtml);
+    const remainingText = norm(remainingHtml || "");
+    return remainingText;
+}
+function buildPointsFromParagraphs($, paras) {
+    const points = [];
+    let ordreAbsoluSeance = 0;
+    const normSpeaker = (s) => s
+        .normalize("NFKC")
+        .replace(/\s+/g, " ")
+        .replace(/[:\.]\s*$/, "")
+        .trim();
+    const normQual = (s) => s
+        .normalize("NFKC")
+        .replace(/\s+/g, " ")
+        .replace(/^\s*,\s*|\s+$/g, "")
+        .replace(/[\s\u00A0]*[.,;:–—-]+$/u, "")
+        .trim();
+    let currentOrateur = null;
+    let currentQualite = "";
+    let currentTexte = "";
+    function isPresidentQual(qual) {
+        return /\bprésident(e)?\b/i.test(qual);
+    }
+    // Flush the buffered speaker’s text into points[] if any.
+    function flush() {
+        if (!currentOrateur || !currentTexte.trim())
+            return;
+        ordreAbsoluSeance++;
+        points.push({
+            code_grammaire: "PAROLE_GENERIQUE",
+            roledebat: isPresidentQual(currentQualite) ? "président" : "",
+            ordre_absolu_seance: String(ordreAbsoluSeance),
+            orateurs: { orateur: { nom: currentOrateur, id: "", qualite: currentQualite || "" } },
+            texte: { _: currentTexte.trim() },
+        });
+        currentOrateur = null;
+        currentQualite = "";
+        currentTexte = "";
+    }
+    function addPoint(payload) {
+        ordreAbsoluSeance++;
+        points.push({ ...payload, ordre_absolu_seance: String(ordreAbsoluSeance) });
+    }
+    for (const $p of paras) {
+        if ($p.closest("table").length)
+            continue;
+        const tagName = ($p.prop("tagName") || "").toString().toLowerCase();
+        const rawText = ($p.text() || "").replace(/\u00a0/g, " ").trim();
+        const text = norm(rawText);
+        if (!text || text.length <= 3)
+            continue;
+        const html = ($p.html() || "").trim();
+        const italicSpans = $p.find("i, em, span[style*='italic']");
+        const firstItalicOuter = italicSpans.length ? $(italicSpans[0]).prop("outerHTML") || "" : "";
+        const htmlBeforeFirstItalic = firstItalicOuter ? html.split(firstItalicOuter)[0].trim() : "";
+        const isPureItalic = italicSpans.length > 0 && italicSpans.length === $p.find("span,i,em").length && htmlBeforeFirstItalic === "";
+        if (tagName === "h3") {
+            flush();
+            addPoint({
+                code_style: "Titre",
+                code_grammaire: "TITRE_TEXTE_DISCUSSION",
+                texte: { _: text },
+            });
+            continue;
+        }
+        const boldSpans = $p.find("strong, b");
+        const joinedBold = norm(boldSpans
+            .map((_, el) => $(el).text() || "")
+            .get()
+            .join(""));
+        const [namePartRaw, qualPartRaw] = joinedBold.split(/\s*,\s+/, 2);
+        const namePart = namePartRaw ? normSpeaker(namePartRaw) : "";
+        const qualPart = qualPartRaw ? normQual(qualPartRaw) : "";
+        const looksLikeName = namePart.length > 3 && /^(M\.|Mme)[\s\u00A0\u202F]+/i.test(namePart);
+        const startsWithName = namePart && text.startsWith(namePart);
+        const isNewSpeaker = looksLikeName && startsWithName && namePart !== currentOrateur;
+        if (isNewSpeaker) {
+            flush();
+            currentOrateur = namePart;
+            currentQualite = qualPart;
+            const remainingText = getRemainingTextAfterSpeakerHeader($, $p);
+            currentTexte = remainingText;
+            continue;
+        }
+        if (isPureItalic || (!joinedBold && !currentOrateur && text)) {
+            flush();
+            addPoint({
+                code_style: "Info Italiques",
+                code_grammaire: "PAROLE_GENERIQUE",
+                texte: { _: "<i>" + text + "</i>" },
+            });
+            continue;
+        }
+        // concat text because same orateur
+        if (currentOrateur) {
+            const removeOrateurFromText = getRemainingTextAfterSpeakerHeader($, $p);
+            currentTexte += (currentTexte ? "<br/><br/>" : "") + removeOrateurFromText;
+            continue;
+        }
+    }
+    flush();
+    return points;
+}
+const TIME_RE = /(?:\b[àa]\s*)?(\d{1,2})\s*(?:h|heures?)\s*(?:([0-5]\d))?/i;
+export function cleanTitle(t) {
+    return (t || "").replace(/\s+/g, " ").trim();
+}
+function parseTimeToHHmm(text) {
+    const m = normalizeSpaces(text).match(TIME_RE);
+    if (!m)
+        return undefined;
+    const hh = m[1]?.padStart(2, "0");
+    const mm = (m[2] ?? "00").padStart(2, "0");
+    const h = Number(hh);
+    if (h >= 0 && h <= 23)
+        return `${hh}:${mm}`;
+    return undefined;
+}
+function findNearbyTime($, $h3) {
+    let cur = $h3.prev();
+    for (let i = 0; i < 3 && cur.length; i++, cur = cur.prev()) {
+        const direct = parseTimeToHHmm(cur.text());
+        if (direct)
+            return direct;
+        const italic = parseTimeToHHmm(cur.find("i, em").first().text());
+        if (italic)
+            return italic;
+    }
+    return undefined;
+}
+export function extractDayH3Sections($, dateISO) {
+    const sections = [];
+    const $dayRoot = findDayRoot($, dateISO);
+    if ($dayRoot.length === 0)
+        return sections;
+    const $range = $dayRoot.nextUntil("h2");
+    const $h3s = $range.filter("h3").add($range.find("h3"));
+    $h3s.each((_, el) => {
+        const $h3 = $(el);
+        const title = cleanTitle($h3.text());
+        if (!title)
+            return;
+        const time = findNearbyTime($, $h3);
+        sections.push({ title, $start: $h3, time });
+    });
+    return sections;
+}
+export function parseCommissionCRSectionFromDom($, htmlFilePath, opts) {
+    try {
+        const { dateISO, hourShort, organe, section, matched } = opts;
+        const seanceRef = matched?.uid ?? makeReunionUid(dateISO, "COM", matched?.events[0].id ?? hourShort ?? "", organe ?? undefined);
+        const uid = seanceRef.replace(/^RU/, "CRC");
+        const dateSeance = toCRDate(dateISO, matched?.startTime ?? hourShortToStartTime(hourShort));
+        const $dayRoot = findDayRoot($, dateISO);
+        if ($dayRoot.length === 0) {
+            console.warn(`[COM-CR][parse] day root not found for ${dateISO} in ${path.basename(htmlFilePath)}`);
+            return null;
+        }
+        const paras = [];
+        let $cursor = section.$start;
+        // Jump title if we do not want to add it to paragraphes
+        $cursor = $cursor.next();
+        while ($cursor.length && !$cursor.is("h2") && !$cursor.is("h3")) {
+            if ($cursor.is(PARA_h3_SEL)) {
+                paras.push($cursor);
+            }
+            else {
+                const $ps = $cursor.find(PARA_h3_SEL);
+                if ($ps.length)
+                    $ps.each((_, p) => {
+                        paras.push($(p));
+                    });
+            }
+            $cursor = $cursor.next();
+        }
+        const points = buildPointsFromParagraphs($, paras);
+        if (points.length < 4 || !points.some((pt) => pt.code_grammaire === "PAROLE_GENERIQUE" && pt.orateurs)) {
+            console.warn(`[COM-CR][parse] Insufficient points or no interventions found for a section in ${path.basename(htmlFilePath)}`);
+            return null;
+        }
+        const session = dateISO.slice(5, 7) >= "10" ? `${dateISO.slice(0, 4)}` : `${Number(dateISO.slice(0, 4)) - 1}`;
+        const contenu = {
+            quantiemes: { journee: dateISO, session },
+            point: points,
+        };
+        const metadonnees = {
+            dateSeance,
+            dateSeanceJour: dateISO,
+            numSeanceJour: "",
+            numSeance: "",
+            typeAssemblee: "SN",
+            legislature: "",
+            session,
+            nomFichierJo: path.basename(htmlFilePath),
+            validite: "non-certifie",
+            etat: "definitif",
+            diffusion: "publique",
+            version: "1",
+            environnement: "prod",
+            heureGeneration: new Date(),
+        };
+        return { uid, seanceRef, sessionRef: session, metadonnees, contenu };
+    }
+    catch (e) {
+        console.error(`[COM-CR][parse] error section file=${path.basename(htmlFilePath)}:`, e);
+        return null;
+    }
+}

package/lib/model/debats.d.ts

@@ -0,0 +1,67 @@
+import { InferResult } from "kysely";
+export type DebatResult = InferResult<typeof findAllQuery>[0];
+declare const findAllQuery: import("kysely").SelectQueryBuilder<any, "debats.debats", {
+    [x: string]: any;
+    id: string;
+    date_seance: string;
+    sections: {
+        [x: string]: any;
+        interventions: {
+            [x: string]: any;
+            auteur: {
+                code: any;
+                nom: any;
+                prenom: any;
+                matricule: any;
+            };
+        }[];
+    }[];
+    sections_divers: {
+        [x: string]: any;
+        interventions: {
+            [x: string]: any;
+            auteur: {
+                code: any;
+                nom: any;
+                prenom: any;
+                matricule: any;
+            };
+        }[];
+    }[];
+    lectures: {
+        id: any;
+    }[];
+}>;
+export declare function findAll(fromSession?: number): AsyncIterableIterator<{
+    [x: string]: any;
+    id: string;
+    date_seance: string;
+    sections: {
+        [x: string]: any;
+        interventions: {
+            [x: string]: any;
+            auteur: {
+                code: any;
+                nom: any;
+                prenom: any;
+                matricule: any;
+            };
+        }[];
+    }[];
+    sections_divers: {
+        [x: string]: any;
+        interventions: {
+            [x: string]: any;
+            auteur: {
+                code: any;
+                nom: any;
+                prenom: any;
+                matricule: any;
+            };
+        }[];
+    }[];
+    lectures: {
+        id: any;
+    }[];
+}>;
+export {};

package/lib/model/debats.js

@@ -0,0 +1,95 @@
+import { jsonArrayFrom, jsonBuildObject } from "kysely/helpers/postgres";
+import { dbSenat } from "../databases";
+import { ID_DATE_FORMAT } from "../scripts/datautil";
+import { toDateString } from "./util";
+function sectionsLegislatives(dateSeance) {
+    return jsonArrayFrom(dbSenat
+        .selectFrom("debats.secdis")
+        .leftJoin("debats.typsec", "debats.secdis.typseccod", "debats.typsec.typseccod")
+        .where("debats.secdis.datsea", "=", dateSeance)
+        .select(({ ref }) => [
+        "debats.secdis.secdisordid as id",
+        "debats.secdis.secdisnum as numero",
+        "debats.secdis.secdisobj as objet",
+        "debats.secdis.secdisurl as url",
+        "debats.typsec.typseclib as type",
+        "debats.typsec.typseccat as categorie",
+        interventionsLegislatives(ref("debats.secdis.secdiscle")).as("interventions"),
+        "debats.secdis.lecassidt as lecture_id",
+    ])
+        .orderBy("debats.secdis.secdisordid", "asc"));
+}
+function interventionsLegislatives(sectionId) {
+    return jsonArrayFrom(dbSenat
+        .selectFrom("debats.intpjl")
+        .leftJoin("dosleg.auteur", "debats.intpjl.autcod", "dosleg.auteur.autcod")
+        .where("debats.intpjl.secdiscle", "=", sectionId)
+        .select(({ ref, val, fn }) => [
+        "debats.intpjl.intordid as id",
+        "debats.intpjl.autcod as auteur_code",
+        "debats.intpjl.intfon as fonction_intervenant",
+        "debats.intpjl.inturl as url",
+        "debats.intpjl.intana as analyse",
+        jsonBuildObject({
+            code: ref("dosleg.auteur.autcod"),
+            nom: ref("dosleg.auteur.nomuse"),
+            prenom: ref("dosleg.auteur.prenom"),
+            matricule: ref("dosleg.auteur.autmat"),
+        }).as("auteur"),
+    ])
+        .orderBy("debats.intpjl.intordid", "asc"));
+}
+function sectionsNonLegislatives(dateSeance) {
+    return jsonArrayFrom(dbSenat
+        .selectFrom("debats.secdivers")
+        .leftJoin("debats.typsec", "debats.secdivers.typseccod", "debats.typsec.typseccod")
+        .where("debats.secdivers.datsea", "=", dateSeance)
+        .select(({ ref }) => [
+        "debats.secdivers.secdiverslibelle as libelle",
+        "debats.secdivers.secdiversobj as objet",
+        "debats.typsec.typseclib as type",
+        "debats.typsec.typseccat as categorie",
+        interventionsNonLegislatives(ref("debats.secdivers.secdiverscle")).as("interventions"),
+    ]));
+}
+function interventionsNonLegislatives(sectionId) {
+    return jsonArrayFrom(dbSenat
+        .selectFrom("debats.intdivers")
+        .leftJoin("dosleg.auteur", "debats.intdivers.autcod", "dosleg.auteur.autcod")
+        .where("debats.intdivers.intdiverscle", "=", sectionId)
+        .select(({ ref, val }) => [
+        "debats.intdivers.intdiversordid as id",
+        "debats.intdivers.autcod as auteur_code",
+        "debats.intdivers.intfon as fonction_intervenant",
+        "debats.intdivers.inturl as url",
+        "debats.intdivers.intana as analyse",
+        jsonBuildObject({
+            code: ref("dosleg.auteur.autcod"),
+            nom: ref("dosleg.auteur.nomuse"),
+            prenom: ref("dosleg.auteur.prenom"),
+            matricule: ref("dosleg.auteur.autmat"),
+        }).as("auteur"),
+    ])
+        .orderBy("debats.intdivers.intdiversordid", "asc"));
+}
+function lecturesAssemblee(dateSeance) {
+    return jsonArrayFrom(dbSenat
+        .selectFrom("debats.lecassdeb")
+        .where("debats.lecassdeb.datsea", "=", dateSeance)
+        .select("debats.lecassdeb.lecassidt as id"));
+}
+const findAllQuery = dbSenat
+    .selectFrom("debats.debats")
+    .select(({ ref, val }) => [
+    toDateString(ref("debats.debats.datsea"), val(ID_DATE_FORMAT)).as("id"),
+    toDateString(ref("debats.debats.datsea")).as("date_seance"),
+    "debats.debats.numero as numero",
+    "debats.debats.deburl as url",
+    "debats.debats.debsyn as etat_synchronisation",
+    sectionsLegislatives(ref("debats.debats.datsea")).as("sections"),
+    sectionsNonLegislatives(ref("debats.debats.datsea")).as("sections_divers"),
+    lecturesAssemblee(ref("debats.debats.datsea")).as("lectures"),
+]);
+export function findAll(fromSession) {
+    return findAllQuery.stream();
+}

package/lib/model/documents.d.ts

@@ -0,0 +1,12 @@
+import { Expression, InferResult, SelectQueryBuilder } from "kysely";
+export declare function rapports(lectureAssembleeId: Expression<string>): import("kysely").RawBuilder<{
+    [x: string]: any;
+}[]>;
+declare const queryTextes: SelectQueryBuilder<any, any, any>;
+export declare function textes(lectureAssembleeId: Expression<string>): import("kysely").RawBuilder<{
+    [x: string]: any;
+}[]>;
+export declare function findAllTextes(): AsyncIterableIterator<DocumentResult>;
+export declare function findAllRapports(): AsyncIterableIterator<DocumentResult>;
+export type DocumentResult = InferResult<typeof queryTextes>[0];
+export {};

package/lib/model/documents.js

@@ -0,0 +1,138 @@
+import { sql } from "kysely";
+import { dbSenat } from "../databases";
+import { concat, rtrim, toDateString } from "./util";
+import { jsonArrayFrom } from "kysely/helpers/postgres";
+function orderOrdreOrigineTexte(expr) {
+    return sql `array_position(array['0','2','1'], ${expr})`;
+}
+function auteursRapport(rapportId) {
+    return jsonArrayFrom(dbSenat
+        .withSchema("dosleg")
+        .selectFrom("dosleg.auteur")
+        .leftJoin("dosleg.ecr", "dosleg.ecr.autcod", "dosleg.auteur.autcod")
+        .leftJoin("dosleg.rolsig", "dosleg.rolsig.signataire", "dosleg.ecr.signataire")
+        .where("dosleg.ecr.rapcod", "=", rapportId)
+        .select([
+        "dosleg.auteur.prenom as prenom",
+        "dosleg.auteur.nomuse as nom_usuel",
+        "dosleg.auteur.autmat as matricule",
+        "dosleg.ecr.ecrnumtri as ordre",
+        "dosleg.rolsig.rolsiglib as role",
+        "dosleg.ecr.ecrqua as qualite",
+    ])
+        .orderBy("dosleg.ecr.ecrnumtri", "asc"));
+}
+function documentsAttaches(rapportId) {
+    return jsonArrayFrom(dbSenat
+        .withSchema("dosleg")
+        .selectFrom("docatt")
+        .leftJoin("typatt", "docatt.typattcod", "typatt.typattcod")
+        .where("docatt.rapcod", "=", rapportId)
+        .select(["docatt.docatturl as url", "typatt.typattlib as type_document"]));
+}
+function selectRapportAttributes({ eb, ref, val }) {
+    return [
+        "rap.rapnum as numero",
+        "raporg.orgcod as code_organisme",
+        eb
+            .case()
+            .when("rap.rapurl", "is not", null)
+            .then(sql `regexp_replace(trim(${ref("rap.rapurl")}), '^(.*/)?(.*?)(\\.html)?$', '\\2')`)
+            .else(null)
+            .end()
+            .as("id"),
+        eb
+            .case()
+            .when("rap.typurl", "=", "I")
+            .then(concat(val("https://www.senat.fr/rap/"), rtrim(ref("rap.rapurl"))))
+            .else(rtrim(ref("rap.rapurl")))
+            .end()
+            .as("url"),
+        rtrim(ref("denrap.libdenrap")).as("type"),
+        rtrim(rtrim(ref("rap.raptil"))).as("titre"),
+        rtrim(rtrim(ref("rap.rapsoustit"))).as("sous_titre"),
+        toDateString(ref("rap.date_depot")).as("date"),
+        "rap.sesann as session",
+        auteursRapport(ref("rap.rapcod")).as("auteurs"),
+        documentsAttaches(ref("rap.rapcod")).as("documents_annexes"),
+    ];
+}
+const baseQueryRapports = dbSenat
+    .withSchema("dosleg")
+    .selectFrom("rap")
+    .leftJoin("raporg", "raporg.rapcod", "rap.rapcod")
+    .leftJoin("denrap", "denrap.coddenrap", "rap.coddenrap")
+    .leftJoin("lecassrap", "lecassrap.rapcod", "rap.rapcod");
+const queryRapports = baseQueryRapports
+    .leftJoin("lecass", "lecass.lecassidt", "lecassrap.lecassidt")
+    .leftJoin("lecture", "lecture.lecidt", "lecass.lecidt")
+    .leftJoin("loi", "loi.loicod", "lecture.loicod")
+    .select((args) => ["loi.signet as signet_dossier", ...selectRapportAttributes(args)]);
+export function rapports(lectureAssembleeId) {
+    return jsonArrayFrom(baseQueryRapports.select(selectRapportAttributes).where("lecassrap.lecassidt", "=", lectureAssembleeId));
+}
+function auteursTexte(texteId) {
+    return jsonArrayFrom(dbSenat
+        .withSchema("dosleg")
+        .selectFrom("auteur")
+        .leftJoin("ecr", "ecr.autcod", "auteur.autcod")
+        .leftJoin("rolsig", "rolsig.signataire", "ecr.signataire")
+        .where("ecr.texcod", "=", texteId)
+        .select([
+        "auteur.prenom as prenom",
+        "auteur.nomuse as nom_usuel",
+        "auteur.autmat as matricule",
+        "ecr.ecrnumtri as ordre",
+        "rolsig.rolsiglib as role",
+        "ecr.ecrqua as qualite",
+    ])
+        .orderBy("ecr.ecrnumtri", "asc"));
+}
+function selectTexteAttributes({ eb, ref, val }) {
+    return [
+        "texte.texnum as numero",
+        "texte.orgcod as code_organisme",
+        eb
+            .case()
+            .when("texte.texurl", "is not", null)
+            .then(sql `regexp_replace(trim(${ref("texte.texurl")}), '^(.*/)?(.*?)(\\.html)?$', '\\2')`)
+            .else(null)
+            .end()
+            .as("id"),
+        eb
+            .case()
+            .when("texte.typurl", "=", "I")
+            .then(concat(val("https://www.senat.fr/leg/"), rtrim(ref("texte.texurl"))))
+            .else(rtrim(ref("texte.texurl")))
+            .end()
+            .as("url"),
+        rtrim(ref("oritxt.oritxtlib")).as("origine"),
+        "oritxt.oriordre as ordre_origine",
+        "oritxt.oritxtado as code_adoption",
+        "oritxt.oritxtmod as modification",
+        rtrim(ref("typtxt.typtxtlib")).as("type"),
+        toDateString(ref("texte.txtoritxtdat")).as("date"),
+        "texte.sesann as session",
+        auteursTexte(ref("texte.texcod")).as("auteurs"),
+    ];
+}
+const baseQueryTextes = dbSenat
+    .withSchema("dosleg")
+    .selectFrom("texte")
+    .leftJoin("oritxt", "oritxt.oritxtcod", "texte.oritxtcod")
+    .leftJoin("typtxt", "typtxt.typtxtcod", "texte.typtxtcod")
+    .orderBy(({ ref }) => orderOrdreOrigineTexte(ref("oritxt.oriordre")));
+const queryTextes = baseQueryTextes
+    .leftJoin("lecass", "lecass.lecassidt", "texte.lecassidt")
+    .leftJoin("lecture", "lecture.lecidt", "lecass.lecidt")
+    .leftJoin("loi", "loi.loicod", "lecture.loicod")
+    .select((args) => ["loi.signet as signet_dossier", ...selectTexteAttributes(args)]);
+export function textes(lectureAssembleeId) {
+    return jsonArrayFrom(baseQueryTextes.select(selectTexteAttributes).where("texte.lecassidt", "=", lectureAssembleeId));
+}
+export function findAllTextes() {
+    return queryTextes.stream();
+}
+export function findAllRapports() {
+    return queryRapports.stream();
+}

package/lib/model/dosleg.d.ts

@@ -0,0 +1,7 @@
+import { InferResult, SelectQueryBuilder } from "kysely";
+declare const findAllDossiersQuery: SelectQueryBuilder<any, any, any>;
+export declare function findAllDossiers(): AsyncIterableIterator<DossierLegislatifResult>;
+export declare function getCodeActeLecture(codeNatureDossier: string, typeLecture: string, assemblee: string): string | null;
+export type DossierLegislatifResult = InferResult<typeof findAllDossiersQuery>[0];
+export declare function buildActesLegislatifs(dossier: any): any[];
+export {};