@tricoteuses/senat 2.22.6 → 2.22.7

package/lib/config.d.ts

@@ -0,0 +1,21 @@
+import "dotenv/config";
+import { z } from "zod";
+export declare const configSchema: z.ZodObject<{
+    db: z.ZodObject<{
+        host: z.ZodString;
+        name: z.ZodString;
+        password: z.ZodString;
+        port: z.ZodCoercedNumber<unknown>;
+        user: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const _default: {
+    db: {
+        host: string;
+        name: string;
+        password: string;
+        port: number;
+        user: string;
+    };
+};
+export default _default;

package/lib/config.js

@@ -0,0 +1,27 @@
+import "dotenv/config";
+import { z } from "zod";
+const dbSchema = z.object({
+    host: z.string().trim().min(1, "Must not be empty"),
+    name: z.string().trim().min(1, "Must not be empty"),
+    password: z.string().trim().min(1, "Must not be empty"),
+    port: z.coerce.number().int().min(0).max(65535),
+    user: z.string().trim().min(1, "Must not be empty"),
+});
+export const configSchema = z.object({
+    db: dbSchema,
+});
+const config = {
+    db: {
+        host: process.env["TRICOTEUSES_SENAT_DB_HOST"] || "localhost",
+        name: process.env["TRICOTEUSES_SENAT_DB_NAME"] || "postgres",
+        password: process.env["TRICOTEUSES_SENAT_DB_PASSWORD"] || "opendata",
+        port: process.env["TRICOTEUSES_SENAT_DB_PORT"] || 5432,
+        user: process.env["TRICOTEUSES_SENAT_DB_USER"] || "opendata",
+    },
+};
+const result = configSchema.safeParse(config);
+if (!result.success) {
+    console.error(`Error in configuration:\n${JSON.stringify(config, null, 2)}\nError:\n${JSON.stringify(result.error.issues, null, 2)}`);
+    process.exit(-1);
+}
+export default result.data;

package/lib/databases.d.ts

@@ -0,0 +1,2 @@
+import { Kysely } from "kysely";
+export declare const dbSenat: Kysely<any>;

package/lib/databases.js

@@ -0,0 +1,26 @@
+import { Kysely, PostgresDialect } from "kysely";
+import * as pg from "pg";
+import { types } from "pg";
+import Cursor from "pg-cursor";
+import config from "./config";
+// Map int8 to number instead of string
+// https://github.com/brianc/node-pg-types#use
+pg.types.setTypeParser(types.builtins.INT8, (val) => {
+    return parseInt(val, 10);
+});
+const senatPool = new pg.Pool({
+    database: "senat",
+    host: config.db.host,
+    user: config.db.user,
+    password: config.db.password,
+    port: config.db.port,
+    max: 10,
+});
+const senatDialect = new PostgresDialect({
+    pool: senatPool,
+    cursor: Cursor,
+});
+export const dbSenat = new Kysely({
+    log: ["error"],
+    dialect: senatDialect,
+});

package/lib/datasets.d.ts

@@ -0,0 +1,34 @@
+export interface Dataset {
+    database: string;
+    repairEncoding: boolean;
+    repairZip?: (dataset: Dataset, dataDir: string) => void;
+    title: string;
+    url: string;
+    indexes?: {
+        [table: string]: Array<{
+            name: string;
+            columns: string[];
+        }>;
+    };
+}
+export interface Datasets {
+    ameli: Dataset;
+    debats: Dataset;
+    dosleg: Dataset;
+    questions: Dataset;
+    sens: Dataset;
+}
+export declare enum EnabledDatasets {
+    None = 0,
+    Ameli = 1,
+    Debats = 2,
+    DosLeg = 4,
+    Questions = 8,
+    Sens = 16,
+    PhotosSenateurs = 32,
+    Agenda = 64,
+    All = 127
+}
+export declare const datasets: Datasets;
+export declare function getEnabledDatasets(categories: string[]): EnabledDatasets;
+export declare function getChosenDatasets(enabledDatasets: EnabledDatasets): Dataset[];

package/lib/datasets.js

@@ -0,0 +1,233 @@
+import fs from "fs-extra";
+import path from "path";
+import assert from "assert";
+export var EnabledDatasets;
+(function (EnabledDatasets) {
+    EnabledDatasets[EnabledDatasets["None"] = 0] = "None";
+    EnabledDatasets[EnabledDatasets["Ameli"] = 1] = "Ameli";
+    EnabledDatasets[EnabledDatasets["Debats"] = 2] = "Debats";
+    EnabledDatasets[EnabledDatasets["DosLeg"] = 4] = "DosLeg";
+    EnabledDatasets[EnabledDatasets["Questions"] = 8] = "Questions";
+    EnabledDatasets[EnabledDatasets["Sens"] = 16] = "Sens";
+    EnabledDatasets[EnabledDatasets["PhotosSenateurs"] = 32] = "PhotosSenateurs";
+    EnabledDatasets[EnabledDatasets["Agenda"] = 64] = "Agenda";
+    EnabledDatasets[EnabledDatasets["All"] = 127] = "All";
+})(EnabledDatasets || (EnabledDatasets = {}));
+export const datasets = {
+    ameli: {
+        database: "ameli",
+        repairEncoding: true,
+        repairZip: (dataset, dataDir) => {
+            const sqlFilename = `${dataset.database}.sql`;
+            const sqlFilePath = path.join(dataDir, sqlFilename);
+            fs.removeSync(sqlFilePath);
+            fs.moveSync(path.join(dataDir, "var", "opt", "opendata", sqlFilename), sqlFilePath);
+        },
+        title: "Amendements",
+        url: "https://data.senat.fr/data/ameli/ameli.zip",
+        indexes: {
+            amdsen: [
+                { name: "idx_amdid", columns: ["amdid"] },
+                { name: "idx_senid", columns: ["senid"] },
+                { name: "idx_grpid", columns: ["grpid"] },
+            ],
+            sen_ameli: [{ name: "idx_entid", columns: ["entid"] }],
+            grppol_ameli: [{ name: "idx_entid", columns: ["entid"] }],
+            sub: [
+                { name: "idx_id", columns: ["id"] },
+                { name: "idx_typid", columns: ["typid"] },
+                { name: "idx_merid", columns: ["merid"] },
+                { name: "idx_comdelid", columns: ["comdelid"] },
+            ],
+            typsub: [{ name: "idx_id", columns: ["id"] }],
+            typrect: [{ name: "idx_id", columns: ["id"] }],
+            txt_ameli: [
+                { name: "idx_id", columns: ["id"] },
+                { name: "idx_txtetaid", columns: ["txtetaid"] },
+                { name: "idx_sesdepid", columns: ["sesdepid"] },
+                { name: "idx_natid", columns: ["natid"] },
+                { name: "idx_lecid", columns: ["lecid"] },
+            ],
+            etatxt: [{ name: "idx_id", columns: ["id"] }],
+            ses: [
+                { name: "idx_id", columns: ["id"] },
+                { name: "idx_typid", columns: ["typid"] },
+                { name: "idx_ann", columns: ["ann"] },
+            ],
+            typses: [{ name: "idx_id", columns: ["id"] }],
+            nat: [{ name: "idx_id", columns: ["id"] }],
+            lec_ameli: [{ name: "idx_id", columns: ["id"] }],
+            mot: [{ name: "idx_id", columns: ["id"] }],
+            avicom: [{ name: "idx_id", columns: ["id"] }],
+            avigvt: [{ name: "idx_id", columns: ["id"] }],
+            sor: [{ name: "idx_id", columns: ["id"] }],
+            irr: [{ name: "idx_id", columns: ["id"] }],
+            com_ameli: [{ name: "idx_entid", columns: ["entid"] }],
+            cab: [{ name: "idx_entid", columns: ["entid"] }],
+            amd: [
+                { name: "idx_subid", columns: ["subid"] },
+                { name: "idx_typrectid", columns: ["typrectid"] },
+                { name: "idx_txtid", columns: ["txtid"] },
+                { name: "idx_motid", columns: ["motid"] },
+                { name: "idx_avcid", columns: ["avcid"] },
+                { name: "idx_avgid", columns: ["avgid"] },
+                { name: "idx_sorid", columns: ["sorid"] },
+                { name: "idx_irrid", columns: ["irrid"] },
+                { name: "idx_nomentid", columns: ["nomentid"] },
+            ],
+        },
+    },
+    debats: {
+        database: "debats",
+        repairEncoding: false,
+        title: "Informations relatives aux comptes rendus intégraux de la séance publique",
+        url: "https://data.senat.fr/data/debats/debats.zip",
+        indexes: {
+            secdis: [
+                { name: "idx_datsea", columns: ["datsea"] },
+                { name: "idx_typseccod", columns: ["typseccod"] },
+            ],
+            intpjl: [{ name: "idx_secdiscle", columns: ["secdiscle"] }],
+            secdivers: [
+                { name: "idx_datsea", columns: ["datsea"] },
+                { name: "idx_typseccod", columns: ["typseccod"] },
+            ],
+            intdivers: [{ name: "idx_intdiverscle", columns: ["intdiverscle"] }],
+            lecassdeb: [{ name: "idx_datsea", columns: ["datsea"] }],
+        },
+    },
+    dosleg: {
+        database: "dosleg",
+        repairEncoding: false,
+        title: "Dossiers législatifs",
+        url: "https://data.senat.fr/data/dosleg/dosleg.zip",
+        indexes: {
+            amescr: [{ name: "idx_scrnum", columns: ["scrnum"] }],
+            auteur: [{ name: "idx_autcod", columns: ["autcod"] }],
+            corscr: [{ name: "idx_scrnum", columns: ["scrnum"] }],
+            date_seance: [
+                { name: "idx_code", columns: ["code"] },
+                { name: "idx_lecidt", columns: ["lecidt"] },
+            ],
+            deccoc: [{ name: "idx_deccoccod", columns: ["deccoccod"] }],
+            etaloi: [{ name: "idx_etaloicod", columns: ["etaloicod"] }],
+            lecass: [
+                { name: "idx_lecidt", columns: ["lecidt"] },
+                { name: "idx_codass", columns: ["codass"] },
+                { name: "idx_orgcod", columns: ["orgcod"] },
+                { name: "idx_orippr", columns: ["orippr"] },
+            ],
+            lecassrap: [
+                { name: "idx_rapcod", columns: ["rapcod"] },
+                { name: "idx_lecassidt", columns: ["lecassidt"] },
+            ],
+            lecture: [
+                { name: "idx_loicod", columns: ["loicod"] },
+                { name: "idx_typleccod", columns: ["typleccod"] },
+                { name: "idx_lecidt", columns: ["lecidt"] },
+            ],
+            loi: [
+                { name: "idx_typloicod", columns: ["typloicod"] },
+                { name: "idx_etaloicod", columns: ["etaloicod"] },
+                { name: "idx_deccoccod", columns: ["deccoccod"] },
+                { name: "idx_loicod", columns: ["loicod"] },
+            ],
+            loithe: [
+                { name: "idx_thecle", columns: ["thecle"] },
+                { name: "idx_loicod", columns: ["loicod"] },
+            ],
+            posvot: [{ name: "idx_posvotcod", columns: ["posvotcod"] }],
+            rap: [
+                { name: "idx_rapcod", columns: ["rapcod"] },
+                { name: "idx_coddenrap", columns: ["coddenrap"] },
+            ],
+            rolsig: [{ name: "idx_signataire", columns: ["signataire"] }],
+            scr: [
+                { name: "idx_code", columns: ["code"] },
+                { name: "idx_scrnum", columns: ["scrnum"] },
+                { name: "idx_sesann", columns: ["sesann"] },
+            ],
+            stavot: [{ name: "idx_stavotidt", columns: ["stavotidt"] }],
+            texte: [
+                { name: "idx_lecassidt", columns: ["lecassidt"] },
+                { name: "idx_oritxtcod", columns: ["oritxtcod"] },
+                { name: "idx_typtxtcod", columns: ["typtxtcod"] },
+                { name: "idx_texcod", columns: ["texcod"] },
+            ],
+            the: [{ name: "idx_thecle", columns: ["thecle"] }],
+            titsen: [{ name: "idx_titsencod", columns: ["titsencod"] }],
+            typloi: [{ name: "idx_typloicod", columns: ["typloicod"] }],
+            typtxt: [{ name: "idx_typtxtcod", columns: ["typtxtcod"] }],
+            votsen: [
+                { name: "idx_scrnum", columns: ["scrnum"] },
+                { name: "idx_sesann", columns: ["sesann"] },
+                { name: "idx_titsencod", columns: ["titsencod"] },
+                { name: "idx_stavotidt", columns: ["stavotidt"] },
+                { name: "idx_posvotcod", columns: ["posvotcod"] },
+                { name: "idx_senmat", columns: ["senmat"] },
+            ],
+        },
+    },
+    questions: {
+        database: "questions",
+        repairEncoding: false,
+        title: "Questions écrites et orales posées par les sénateurs au Gouvernement",
+        url: "https://data.senat.fr/data/questions/questions.zip",
+        indexes: {
+            tam_reponses: [{ name: "idx_idque", columns: ["idque"] }],
+            tam_questions: [
+                { name: "idx_sorquecod", columns: ["sorquecod"] },
+                { name: "idx_etaquecod", columns: ["etaquecod"] },
+            ],
+            the: [{ name: "idx_thenouidt", columns: ["thenouidt"] }],
+            sortquestion: [{ name: "idx_sorquecod", columns: ["sorquecod"] }],
+            etatquestion: [{ name: "idx_etaquecod", columns: ["etaquecod"] }],
+        },
+    },
+    sens: {
+        database: "sens",
+        repairEncoding: false,
+        repairZip: (dataset, dataDir) => {
+            const sqlFilename = `${dataset.database}.sql`;
+            const sqlFilePath = path.join(dataDir, sqlFilename);
+            fs.removeSync(sqlFilePath);
+            fs.moveSync(path.join(dataDir, "export_sens.sql"), sqlFilePath);
+        },
+        title: "Sénateurs (y compris organes et présence)",
+        url: "https://data.senat.fr/data/senateurs/export_sens.zip",
+        indexes: {
+            dpt: [
+                { name: "idx_dptnum", columns: ["dptnum"] },
+                { name: "idx_regcod", columns: ["regcod"] },
+            ],
+            activite_loi: [{ name: "idx_actid", columns: ["actid"] }],
+            activite_delegation: [{ name: "idx_actid", columns: ["actid"] }],
+            activite_participant: [{ name: "idx_senmat", columns: ["senmat"] }],
+            activite_senateur: [{ name: "idx_senmat", columns: ["senmat"] }],
+            senbur: [
+                { name: "idx_senmat", columns: ["senmat"] },
+                { name: "idx_burcod", columns: ["burcod"] },
+            ],
+            elucan: [
+                { name: "idx_senmat", columns: ["senmat"] },
+                { name: "idx_typmancod", columns: ["typmancod"] },
+            ],
+        },
+    },
+};
+export function getEnabledDatasets(categories) {
+    categories.map((datasetName) => assert.notStrictEqual(EnabledDatasets[datasetName], undefined, `Unknown name of dataset: ${datasetName}`));
+    return categories.reduce((enabledDatasets, datasetName) => {
+        const enabledDataset = EnabledDatasets[datasetName];
+        return enabledDatasets | (enabledDataset || EnabledDatasets.None);
+    }, EnabledDatasets.None);
+}
+export function getChosenDatasets(enabledDatasets) {
+    return [
+        enabledDatasets & EnabledDatasets.Ameli ? datasets.ameli : null,
+        enabledDatasets & EnabledDatasets.Debats ? datasets.debats : null,
+        enabledDatasets & EnabledDatasets.DosLeg ? datasets.dosleg : null,
+        enabledDatasets & EnabledDatasets.Questions ? datasets.questions : null,
+        enabledDatasets & EnabledDatasets.Sens ? datasets.sens : null,
+    ].filter((dataset) => dataset !== null);
+}

package/lib/git.d.ts

@@ -0,0 +1,26 @@
+export declare function initRepo(repositoryDir: string): void;
+export declare function commit(repositoryDir: string, message: string): boolean;
+export declare function commitAndPush(repositoryDir: string, message: string, remotes?: string[]): number;
+export declare function resetAndPull(gitDir: string): boolean;
+export declare function clone(gitGroupUrl: string | undefined, gitName: string, workingDir: string): void;
+export declare function run(repositoryDir: string, args: string, verbose?: boolean): string;
+export declare function test(repositoryDir: string, args: string, verbose?: boolean): boolean;
+/**
+ * Information about a changed file in git
+ */
+export interface GitChangedFile {
+    path: string;
+    status: "A" | "M" | "D" | "R" | "C" | "T" | "U";
+}
+/**
+ * Get the list of files that have changed since a specific commit in a git repository.
+ * @param repositoryDir The directory of the git repository
+ * @param sinceCommit The commit hash to compare against (e.g., "HEAD~1", "abc123", etc.)
+ * @param options Options for filtering
+ * @param options.diffFilter Git diff-filter string (default: "AMR").
+ *        A=Added, M=Modified, D=Deleted, R=Renamed, C=Copied, T=Type changed, U=Unmerged
+ * @returns A Map of file paths to their git status
+ */
+export declare function getChangedFilesSinceCommit(repositoryDir: string, sinceCommit: string, options?: {
+    diffFilter?: string;
+}): Map<string, GitChangedFile["status"]>;

package/lib/git.js

@@ -0,0 +1,167 @@
+import { execSync } from "node:child_process";
+import fs from "fs-extra";
+import path from "node:path";
+const MAXBUFFER = 50 * 1024 * 1024;
+export function initRepo(repositoryDir) {
+    if (!fs.existsSync(path.join(repositoryDir, ".git"))) {
+        fs.ensureDirSync(repositoryDir);
+        execSync("git init", {
+            cwd: repositoryDir,
+            env: process.env,
+            encoding: "utf-8",
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+    }
+}
+export function commit(repositoryDir, message) {
+    initRepo(repositoryDir);
+    execSync("git add .", {
+        cwd: repositoryDir,
+        env: process.env,
+        encoding: "utf-8",
+        stdio: ["ignore", "ignore", "pipe"],
+        maxBuffer: MAXBUFFER,
+    });
+    try {
+        execSync(`git commit -m "${message}" --quiet`, {
+            cwd: repositoryDir,
+            env: process.env,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch (childProcess) {
+        if (childProcess.stdout === null ||
+            !/nothing to commit|rien à valider/.test(childProcess.stdout)) {
+            console.error(childProcess.output);
+            throw childProcess;
+        }
+        return false;
+    }
+}
+export function commitAndPush(repositoryDir, message, remotes) {
+    let exitCode = 0;
+    if (commit(repositoryDir, message)) {
+        for (const remote of remotes || []) {
+            try {
+                execSync(`git push ${remote} master`, {
+                    cwd: repositoryDir,
+                    env: process.env,
+                    encoding: "utf-8",
+                    stdio: ["ignore", "ignore", "pipe"],
+                });
+            }
+            catch (childProcess) {
+                // Don't stop when push fails.
+                console.error(childProcess.output);
+                exitCode = childProcess.status;
+            }
+        }
+    }
+    else {
+        // There was nothing to commit.
+        exitCode = 10;
+    }
+    return exitCode;
+}
+export function resetAndPull(gitDir) {
+    execSync("git reset --hard origin/master", {
+        cwd: gitDir,
+        env: process.env,
+        encoding: "utf-8",
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    execSync("git pull --rebase", {
+        cwd: gitDir,
+        env: process.env,
+        encoding: "utf-8",
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    return true;
+}
+export function clone(gitGroupUrl, gitName, workingDir) {
+    if (gitGroupUrl !== undefined) {
+        execSync(`git clone ${gitGroupUrl}/${gitName}.git`, {
+            cwd: workingDir,
+            env: process.env,
+            encoding: "utf-8",
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+    }
+}
+export function run(repositoryDir, args, verbose) {
+    try {
+        if (verbose)
+            console.log(`git -C ${repositoryDir} ${args}`);
+        const output = execSync(`git ${args}`, {
+            cwd: repositoryDir,
+            maxBuffer: MAXBUFFER,
+        })
+            .toString()
+            .trim();
+        if (verbose)
+            console.log(output);
+        return output;
+    }
+    catch (childProcess) {
+        for (const output of ["stdout", "stderr"])
+            console.error(`${output}: ${childProcess[output]}`);
+        throw childProcess;
+    }
+}
+export function test(repositoryDir, args, verbose) {
+    try {
+        if (verbose)
+            console.log(`git -C ${repositoryDir} ${args}`);
+        const output = execSync(`git ${args}`, {
+            cwd: repositoryDir,
+            stdio: ["ignore", "pipe", "pipe"],
+            maxBuffer: MAXBUFFER,
+        })
+            .toString()
+            .trim();
+        if (verbose)
+            console.log(output);
+        return true;
+    }
+    catch (childProcess) {
+        if (childProcess.status != 0)
+            return false;
+        throw childProcess;
+    }
+}
+/**
+ * Get the list of files that have changed since a specific commit in a git repository.
+ * @param repositoryDir The directory of the git repository
+ * @param sinceCommit The commit hash to compare against (e.g., "HEAD~1", "abc123", etc.)
+ * @param options Options for filtering
+ * @param options.diffFilter Git diff-filter string (default: "AMR").
+ *        A=Added, M=Modified, D=Deleted, R=Renamed, C=Copied, T=Type changed, U=Unmerged
+ * @returns A Map of file paths to their git status
+ */
+export function getChangedFilesSinceCommit(repositoryDir, sinceCommit, options = {}) {
+    const { diffFilter } = options;
+    try {
+        // Using diff-filter: A = Added, M = Modified, R = Renamed, D = Deleted, etc.
+        // Default to AMR (excludes deleted files to prevent loading errors)
+        const filter = diffFilter ?? "AMR";
+        const output = run(repositoryDir, `diff --name-status --diff-filter=${filter} ${sinceCommit}`, false);
+        const changedFiles = new Map();
+        for (const line of output.split("\n")) {
+            if (line.trim().length === 0)
+                continue;
+            const parts = line.split("\t");
+            if (parts.length >= 2) {
+                const status = parts[0].charAt(0);
+                const path = parts[1];
+                changedFiles.set(path, status);
+            }
+        }
+        return changedFiles;
+    }
+    catch (error) {
+        console.error(`Error getting changed files since commit ${sinceCommit}:`, error);
+        return new Map();
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+export type { AmendementResult } from "./model/ameli";
+export type { DossierLegislatifResult } from "./model/dosleg";
+export type { ScrutinResult } from "./model/scrutins";
+export type { QuestionResult } from "./model/questions";
+export type { CirconscriptionResult, OrganismeResult, SenateurResult } from "./model/sens";
+export type { AgendaEvent, Reunion, ReunionOdjPoint } from "./types/agenda";
+export type { Ses, Sub, TxtAmeli } from "./types/ameli";
+export type { CompteRendu } from "./types/compte_rendu";
+export type { Debat, LecAssDeb } from "./types/debats";
+export type { Ass, Aud, Auteur, DateSeance, DecCoc, DenRap, DocAtt, Ecr, EtaLoi, LecAss, LecAssRap, Lecture, Loi, Org, OriTxt, Qua, Rap, RapOrg, Scr, Texte, TypAtt, TypLec, TypLoi, TypTxt, TypUrl, } from "./types/dosleg";
+export type { Photo, Sen } from "./types/sens";
+export { UNDEFINED_SESSION, type Session, getSessionsFromStart } from "./types/sessions";
+export type { Alinea, Article, Division, DivisionTag, FlatTexte } from "./types/texte";

package/lib/index.js

@@ -0,0 +1 @@
+export { UNDEFINED_SESSION, getSessionsFromStart } from "./types/sessions";

package/lib/loaders.d.ts

@@ -0,0 +1,58 @@
+import { AmendementResult } from "./model/ameli";
+import { DebatResult } from "./model/debats";
+import { DossierLegislatifResult } from "./model/dosleg";
+import { QuestionResult } from "./model/questions";
+import { ScrutinResult } from "./model/scrutins";
+import { CirconscriptionResult, OrganismeResult, SenateurResult } from "./model/sens";
+import { Reunion } from "./types/agenda";
+import { FlatTexte, DocumentMetadata } from "./types/texte";
+import { CompteRendu } from "./types/compte_rendu";
+import { DocumentResult } from "./model/documents";
+export { EnabledDatasets } from "./datasets";
+export type { DocumentResult } from "./model/documents";
+export declare const AGENDA_FOLDER = "agenda";
+export declare const COMPTES_RENDUS_FOLDER = "seances";
+export declare const COMMISSION_FOLDER = "commissions";
+export declare const DOSLEG_DOSSIERS_FOLDER = "dossiers";
+export declare const SCRUTINS_FOLDER = "scrutins";
+export declare const SENS_CIRCONSCRIPTIONS_FOLDER = "circonscriptions";
+export declare const SENS_ORGANISMES_FOLDER = "organismes";
+export declare const SENS_SENATEURS_FOLDER = "senateurs";
+export declare const TEXTE_FOLDER = "leg";
+export declare const RAPPORT_FOLDER = "rap";
+export declare const DATA_ORIGINAL_FOLDER = "original";
+export declare const DATA_TRANSFORMED_FOLDER = "transformed";
+export declare const DOCUMENT_METADATA_FILE = "metadata.json";
+export type IterItem<T> = {
+    item: T;
+    filePathFromDataset?: string;
+    legislature?: number;
+    gitStatus?: "A" | "M" | "D" | "R" | "C" | "T" | "U";
+};
+export declare function iterFilePaths(dirPath: string): Generator<string>;
+export declare function iterLoadSenatAmendements(dataDir: string, session: number | undefined, options?: {}): Generator<IterItem<AmendementResult>>;
+export declare function iterLoadSenatDebats(dataDir: string, session: number | undefined, options?: {}): Generator<IterItem<DebatResult>>;
+export declare function iterLoadSenatComptesRendusSeances(dataDir: string, session: number): Generator<{
+    compteRendu: CompteRendu;
+    session: number;
+}>;
+export declare function iterLoadSenatComptesRendusCommissions(dataDir: string, session: number): Generator<{
+    compteRendu: CompteRendu;
+    session: number;
+}>;
+export declare function iterLoadSenatDossiersLegislatifs(dataDir: string, session: number | undefined, options?: {}): Generator<IterItem<DossierLegislatifResult>>;
+export declare function iterLoadSenatRapportUrls(dataDir: string, session: number | undefined): Generator<IterItem<DocumentMetadata>>;
+export declare function iterLoadSenatTexteUrls(dataDir: string, session: number | undefined): Generator<IterItem<DocumentMetadata>>;
+export declare function iterLoadSenatDocuments(dataDir: string, session: number | undefined, documentType: "textes" | "rapports", options?: {}): Generator<IterItem<DocumentResult>>;
+export declare function iterLoadSenatRapports(dataDir: string, session: number | undefined, options?: {}): Generator<IterItem<DocumentResult>>;
+export declare function iterLoadSenatTextes(dataDir: string, session: number | undefined, options?: {}): Generator<IterItem<DocumentResult>>;
+export declare function loadSenatTexteContent(dataDir: string, textePathFromDataset: string): IterItem<FlatTexte | null>;
+export declare function loadSenatCompteRenduContent(dataDir: string, session: number, debatId: string | number): {
+    item: CompteRendu | null;
+};
+export declare function iterLoadSenatAgendas(dataDir: string, session: number | undefined): Generator<IterItem<Reunion>>;
+export declare function iterLoadSenatCirconscriptions(dataDir: string, options?: {}): Generator<IterItem<CirconscriptionResult>>;
+export declare function iterLoadSenatOrganismes(dataDir: string, options?: {}): Generator<IterItem<OrganismeResult>>;
+export declare function iterLoadSenatSenateurs(dataDir: string, options?: {}): Generator<IterItem<SenateurResult>>;
+export declare function iterLoadSenatQuestions(dataDir: string, legislature: number, options?: {}): Generator<IterItem<QuestionResult>>;
+export declare function iterLoadSenatScrutins(dataDir: string, session: number | undefined, options?: {}): Generator<IterItem<ScrutinResult>>;