@wilm-ai/wilma-client 1.6.1 → 1.7.0

package/dist/parsers/exams.js

@@ -1,4 +1,5 @@
 import * as cheerio from "cheerio";
+import { htmlToText } from "./html-text.js";
 export function parseExamsHtml(html) {
     const $ = cheerio.load(html);
     const exams = [];
@@ -76,6 +77,96 @@ export function parseExamsHtml(html) {
     });
     return exams;
 }
+/**
+ * Wilma's past exams page (Kokeet > Menneet): a table with a row per exam,
+ * columns seen, date, teachers, exam, notes, grade and verbal assessment. The
+ * exam cell reads "name : group course-code : course title", e.g.
+ * "Verbikoe 4 : RUB1_ Ruotsin kieli, B1.t RUB1_91 : Ruotsin kieli, B1".
+ * Columns are found by their headings (Finnish, Swedish or English), or by
+ * Wilma's usual order. Newest first.
+ */
+export function parsePastExamsHtml(html) {
+    const $ = cheerio.load(html);
+    const table = $("table#examtable").first().length ? $("table#examtable").first() : $("main table").first();
+    if (!table.length)
+        return [];
+    const headings = table.find("tr").first().find("th").toArray().map((th) => $(th).text().trim().toLowerCase());
+    const column = (pattern, fallback) => {
+        const at = headings.findIndex((h) => pattern.test(h));
+        return at >= 0 ? at : fallback;
+    };
+    const col = {
+        seen: column(/nähty|sedd|seen/, 0),
+        date: column(/^pvm|päivä|datum|date/, 1),
+        teacher: column(/opettaja|lärare|teacher/, 2),
+        exam: column(/^(koe|prov|exam)$/, 3),
+        info: column(/lisätied|tilläggs|additional|info/, 4),
+        grade: column(/^(arvosana|vitsord|grade)$/, 5),
+        verbal: column(/sanallinen|verbal/, 6),
+    };
+    const isoDate = (text) => {
+        const m = /(\d{1,2})\.(\d{1,2})\.(\d{4})/.exec(text);
+        return m ? `${m[3]}-${m[2].padStart(2, "0")}-${m[1].padStart(2, "0")}` : null;
+    };
+    const exams = [];
+    table.find("tr").each((_, row) => {
+        const cells = $(row).children("td").toArray();
+        if (cells.length < 6)
+            return;
+        const cell = (i) => (cells[i] ? $(cells[i]) : null);
+        const date = isoDate(cell(col.date)?.text() ?? "");
+        if (!date)
+            return;
+        const { name, subject, subjectCode } = splitPastExamTitle(compactText(cell(col.exam)?.text() ?? ""));
+        const links = (cell(col.teacher)?.find("a.profile-link").toArray() ?? []).map((a) => $(a));
+        const teacherText = compactText(cell(col.teacher)?.text() ?? "");
+        const grade = compactText(cell(col.grade)?.text() ?? "");
+        const info = htmlToText(cell(col.info)?.html());
+        const verbal = htmlToText(cell(col.verbal)?.html());
+        exams.push({
+            date,
+            name,
+            subject,
+            subjectCode,
+            grade: grade || null,
+            verbalGrade: verbal || null,
+            info: info || null,
+            teacher: links.length ? links.map((a) => compactText(a.attr("title") || a.text())).join(", ") : teacherText,
+            teacherCode: links.length ? links.map((a) => compactText(a.text())).join(", ") : "",
+            seen: isoDate(cell(col.seen)?.text() ?? ""),
+        });
+    });
+    // Newest first; the order Wilma gave within a day.
+    return exams.map((exam, i) => ({ exam, i })).sort((a, b) => b.exam.date.localeCompare(a.exam.date) || a.i - b.i).map((x) => x.exam);
+}
+const COURSE_CODE = /^[\p{Lu}\d]+_[\p{L}\d]*$/u;
+/** "RUB1_ Ruotsin kieli, B1.t RUB1_91": a group and its course, ending in the course code; that code, else null. */
+function courseCodeOf(part) {
+    const words = part.trim().split(/\s+/);
+    return words.length >= 2 && COURSE_CODE.test(words[0]) && COURSE_CODE.test(words[words.length - 1]) ? words[words.length - 1] : null;
+}
+/**
+ * "Name : GROUP_ Group title CODE_91 : Course title" → its name, course title
+ * and code. Without a name Wilma writes only "GROUP_ Group title CODE_91 :
+ * Course title"; without a course, "Name : Course title".
+ */
+function splitPastExamTitle(text) {
+    const parts = text.split(" : ");
+    if (parts.length >= 3) {
+        const middle = parts[parts.length - 2].trim().split(/\s+/);
+        const last = middle[middle.length - 1] ?? "";
+        return {
+            name: parts.slice(0, -2).join(" : ").trim(),
+            subject: parts[parts.length - 1].trim(),
+            subjectCode: COURSE_CODE.test(last) ? last : "",
+        };
+    }
+    if (parts.length === 2) {
+        const code = courseCodeOf(parts[0]);
+        return code ? { name: "", subject: parts[1].trim(), subjectCode: code } : { name: parts[0].trim(), subject: parts[1].trim(), subjectCode: "" };
+    }
+    return { name: text, subject: "", subjectCode: "" };
+}
 /**
  * Add start times from the exam calendar to upcoming exams (the front page's
  * exam list has dates only). An exam is matched by date and its course code

package/dist/parsers/forms.d.ts

@@ -0,0 +1,40 @@
+import type { CheerioAPI, Cheerio, load } from "cheerio";
+/** A parsed node (domhandler's AnyNode, without depending on domhandler). */
+export type AnyNode = Extract<Parameters<typeof load>[0], {
+    type: unknown;
+}>;
+export interface WilmaForm {
+    /** Where the form posts: a path on this Wilma. */
+    action: string;
+    /** Name/value pairs a browser would send, without any submit button. */
+    fields: [string, string][];
+    /** The form's submit buttons, in page order. */
+    buttons: {
+        name: string;
+        value: string;
+        label: string;
+    }[];
+    selects: {
+        name: string;
+        options: {
+            value: string;
+            label: string;
+            selected: boolean;
+        }[];
+    }[];
+    textareas: string[];
+}
+export declare class FormOutsideWilmaError extends Error {
+    constructor();
+}
+/** A path on this Wilma for a link or form action on a page at `pageUrl`. */
+export declare function wilmaPath(href: string, pageUrl: string): string;
+export declare function readForm($: CheerioAPI, form: Cheerio<AnyNode>, pageUrl: string): WilmaForm;
+/** The form key on a page (Wilma's anti-forgery token), preferring one outside the logout form. */
+export declare function pageFormkey($: CheerioAPI): string | null;
+/** Set a field's value, replacing every earlier value of that name (or adding it). */
+export declare function setField(fields: [string, string][], name: string, value: string): [string, string][];
+/** The text of Wilma's error messages on a page (after a refused form), if any. */
+export declare function pageErrors($: CheerioAPI): string | null;
+/** Wilma's success and info notices on a page, one string each. */
+export declare function pageNotices($: CheerioAPI): string[];

package/dist/parsers/forms.js

@@ -0,0 +1,93 @@
+export class FormOutsideWilmaError extends Error {
+    constructor() {
+        super("Wilma's form points outside Wilma; nothing was sent");
+        this.name = "FormOutsideWilmaError";
+    }
+}
+/** A path on this Wilma for a link or form action on a page at `pageUrl`. */
+export function wilmaPath(href, pageUrl) {
+    const page = new URL(pageUrl);
+    const url = new URL(href || pageUrl, pageUrl);
+    if (url.origin !== page.origin)
+        throw new FormOutsideWilmaError();
+    return url.pathname + url.search;
+}
+const clean = (text) => text.replace(/\s+/g, " ").trim();
+export function readForm($, form, pageUrl) {
+    const fields = [];
+    const buttons = [];
+    const selects = [];
+    const textareas = [];
+    form.find("input, select, textarea, button").each((_, el) => {
+        const control = $(el);
+        const name = control.attr("name");
+        if (!name || control.attr("disabled") !== undefined)
+            return;
+        const tag = el.tagName?.toLowerCase();
+        if (tag === "select") {
+            const options = control
+                .find("option")
+                .map((_, o) => ({
+                value: $(o).attr("value") ?? clean($(o).text()),
+                label: clean($(o).text()),
+                selected: $(o).attr("selected") !== undefined,
+            }))
+                .get();
+            selects.push({ name, options });
+            const chosen = options.find((o) => o.selected) ?? (control.attr("multiple") === undefined ? options[0] : undefined);
+            if (chosen)
+                fields.push([name, chosen.value]);
+            return;
+        }
+        if (tag === "textarea") {
+            textareas.push(name);
+            fields.push([name, control.text()]);
+            return;
+        }
+        const type = (control.attr("type") ?? (tag === "button" ? "submit" : "text")).toLowerCase();
+        const value = control.attr("value") ?? "";
+        if (type === "submit" || type === "image") {
+            buttons.push({ name, value, label: clean(control.text()) || value });
+        }
+        else if (type === "checkbox" || type === "radio") {
+            if (control.attr("checked") !== undefined)
+                fields.push([name, control.attr("value") ?? "on"]);
+        }
+        else if (type !== "file" && type !== "reset" && type !== "button") {
+            fields.push([name, value]);
+        }
+    });
+    return { action: wilmaPath(form.attr("action") ?? "", pageUrl), fields, buttons, selects, textareas };
+}
+/** The form key on a page (Wilma's anti-forgery token), preferring one outside the logout form. */
+export function pageFormkey($) {
+    const keys = $('input[name="formkey"]')
+        .filter((_, el) => $(el).closest("#logout-form").length === 0)
+        .map((_, el) => $(el).attr("value") ?? "")
+        .get()
+        .filter(Boolean);
+    return keys[0] ?? ($('#logout-form input[name="formkey"]').attr("value") || null);
+}
+/** Set a field's value, replacing every earlier value of that name (or adding it). */
+export function setField(fields, name, value) {
+    const out = fields.filter(([n]) => n !== name);
+    const at = fields.findIndex(([n]) => n === name);
+    out.splice(at === -1 ? out.length : at, 0, [name, value]);
+    return out;
+}
+/** The text of Wilma's error messages on a page (after a refused form), if any. */
+export function pageErrors($) {
+    const text = $(".alert-danger, .alert-error, .has-error .help-block, .error-message")
+        .map((_, el) => clean($(el).text()))
+        .get()
+        .filter(Boolean)
+        .join(" ");
+    return text ? text.slice(0, 300) : null;
+}
+/** Wilma's success and info notices on a page, one string each. */
+export function pageNotices($) {
+    return $(".alert-success, .alert-info, .notification-success")
+        .map((_, el) => clean($(el).text()))
+        .get()
+        .filter(Boolean);
+}

package/dist/parsers/html-text.d.ts

@@ -1,6 +1,7 @@
 /**
- * Readable text from a fragment of Wilma HTML (message and reply bodies):
- * paragraphs and line breaks kept, list items bulleted, and links written as
- * "label (address)" so the address isn't lost.
+ * Readable text from a fragment of Wilma HTML (message, reply and bulletin
+ * bodies): paragraphs and line breaks kept, list items bulleted ("- ", or
+ * "1. " in a numbered list) and indented two spaces per nested level, and
+ * links written as "label (address)" so the address isn't lost.
  */
 export declare function htmlToText(html: string | null | undefined): string;

package/dist/parsers/html-text.js

@@ -1,14 +1,18 @@
 import * as cheerio from "cheerio";
 const BLOCKS = "p, div, tr, h1, h2, h3, h4, h5, h6, blockquote, table, ul, ol";
+/** Stands in for a nested list item's indent until spaces are tidied (then two spaces per level). */
+const INDENT = "\u0002";
 /**
- * Readable text from a fragment of Wilma HTML (message and reply bodies):
- * paragraphs and line breaks kept, list items bulleted, and links written as
- * "label (address)" so the address isn't lost.
+ * Readable text from a fragment of Wilma HTML (message, reply and bulletin
+ * bodies): paragraphs and line breaks kept, list items bulleted ("- ", or
+ * "1. " in a numbered list) and indented two spaces per nested level, and
+ * links written as "label (address)" so the address isn't lost.
  */
 export function htmlToText(html) {
     if (!html)
         return "";
-    const $ = cheerio.load(`<div id="wilmai-root">${html}</div>`);
+    // Wilma's editor writes "<br>" and then a newline in the source: one line break, not two.
+    const $ = cheerio.load(`<div id="wilmai-root">${html.replace(/<br\s*\/?>[ \t]*\r?\n/gi, "<br>")}</div>`);
     const root = $("#wilmai-root");
     root.find("script, style").remove();
     root.find("a[href]").each((_, anchor) => {
@@ -24,19 +28,46 @@ export function htmlToText(html) {
             link.text(`${label} (${address})`);
     });
     root.find("br").replaceWith("\n");
-    root.find("li").each((_, item) => {
-        $(item).prepend("- ");
-        $(item).append("\n");
+    // The source's line breaks and tabs around list items aren't text (they made blank lines).
+    root.find("ul, ol, li").each((_, el) => {
+        $(el)
+            .contents()
+            .filter((_, node) => node.type === "text" && !$(node).text().trim())
+            .remove();
+    });
+    root.find("li > ul, li > ol").each((_, list) => {
+        const before = list.prev;
+        if (before?.type === "text")
+            before.data = before.data.replace(/\s+$/, "");
     });
     root.find(BLOCKS).each((_, block) => {
-        $(block).prepend("\n");
-        $(block).append("\n");
+        const el = $(block);
+        // A list inside an item starts on the next line; the item ends where the list does.
+        if (el.is("ul, ol") && el.parents("li").length) {
+            el.prepend("\n");
+            return;
+        }
+        // A paragraph that opens or closes an item stays on the bullet's line.
+        const inItem = el.parent().is("li") && el.is("p, div");
+        if (!(inItem && el.prev().length === 0))
+            el.prepend("\n");
+        if (!(inItem && el.next().length === 0))
+            el.append("\n");
+    });
+    root.find("li").each((_, item) => {
+        const li = $(item);
+        const list = li.parent();
+        const marker = list.is("ol") ? `${list.children("li").index(li) + (Number(list.attr("start")) || 1)}. ` : "- ";
+        li.prepend(INDENT.repeat(li.parents("li").length) + marker);
+        if (!li.contents().last().is("ul, ol"))
+            li.append("\n");
     });
     return root
         .text()
-        .replace(/ /g, " ")
+        .replace(/\u00a0/g, " ")
         .replace(/[ \t]+/g, " ")
         .replace(/ *\n */g, "\n")
         .replace(/\n{3,}/g, "\n\n")
+        .replace(new RegExp(INDENT, "g"), "  ")
         .trim();
 }

package/dist/parsers/invitations.d.ts

@@ -0,0 +1,13 @@
+import type { Invitation, InvitationListing, InvitationSlot, InvitationSlotState, Message } from "../types.js";
+/** A message's EventData (a JSON string or already parsed); null when it isn't an invitation. */
+export declare function parseInvitation(raw: unknown): Invitation | null;
+/**
+ * What can be done with a slot right now (the states Wilma's own page shows).
+ * Pass the invitation to tell a free slot from one the family can't take
+ * because it already has another.
+ */
+export declare function slotState(slot: InvitationSlot, now?: Date, invitation?: Invitation): InvitationSlotState;
+/** The invitation still waits for an answer: nobody in the family signed up or said they won't attend, and a slot is open. */
+export declare function awaitingAnswer(invitation: Invitation, now?: Date): boolean;
+/** The invitations list: each message with where this family stands. */
+export declare function parseInvitationListings(data: unknown, messages: Message[]): InvitationListing[];

package/dist/parsers/invitations.js

@@ -0,0 +1,121 @@
+/*
+ * Event invitations (Tapahtumakutsut): parents' evenings, learning
+ * discussions with time slots, a choice between events.
+ *
+ * Seen 2026-10-06 (Helsinki, Wilma 2.36):
+ * - list: `/messages/list/appointments`, the inbox JSON plus IsEvent and
+ *   Applying {Status: "Applied" | "ExpiredReg" | …, ExtraInfo};
+ * - detail: `/messages/<id>?format=json` with EventData, a JSON string
+ *   {MustApply, Events: [{EventID, Start, End, EnrollStart, EnrollEnd,
+ *   CancelDate, Info, MaxPeople, PeopleCount, State, CanDismissEvent,
+ *   IsDismissed}]} (a string, or already an object on some messages).
+ *
+ * State (2026-10-08, the class of the button Wilma's page shows for it):
+ * "available"; "selected-cancellable" for your slot while it can be
+ * cancelled, "selected" once it can't ("Perumisaika on umpeutunut");
+ * "selected-other" with SelectedOther naming the guardian who signed up;
+ * "full"; "pending" before sign-up opens; "expired" after it closes.
+ * CanDismissEvent: the page offers "En osallistu" (won't attend), which
+ * covers every such slot; IsDismissed: the family said so.
+ */
+import { finnishTime } from "../finnish-time.js";
+/** "2026-10-14 17:30" (Finnish time) as an instant; null when there's no date. */
+function wilmaTime(value) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}))?/.exec(String(value ?? ""));
+    if (!m)
+        return null;
+    return finnishTime(Number(m[1]), Number(m[2]), Number(m[3]), Number(m[4] ?? 0), Number(m[5] ?? 0));
+}
+/** A message's EventData (a JSON string or already parsed); null when it isn't an invitation. */
+export function parseInvitation(raw) {
+    let data = raw;
+    if (typeof raw === "string") {
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    const d = data;
+    if (!d || typeof d !== "object" || !Array.isArray(d.Events))
+        return null;
+    const slots = d.Events.flatMap((e) => {
+        if (!e || typeof e !== "object" || e.EventID === undefined || e.EventID === null)
+            return [];
+        return [
+            {
+                id: String(e.EventID),
+                start: wilmaTime(e.Start),
+                end: wilmaTime(e.End),
+                enrollStart: wilmaTime(e.EnrollStart),
+                enrollEnd: wilmaTime(e.EnrollEnd),
+                cancelUntil: wilmaTime(e.CancelDate),
+                info: String(e.Info ?? "").trim(),
+                subject: String(e.Subject ?? "").trim(),
+                maxPeople: Number(e.MaxPeople) || 0,
+                peopleCount: Number(e.PeopleCount) || 0,
+                selected: e.State === "selected" || e.State === "selected-cancellable",
+                selectedByOther: e.State === "selected-other" ? String(e.SelectedOther ?? "").trim() || "another guardian" : null,
+                wilmaState: typeof e.State === "string" ? e.State : "",
+                canDecline: e.CanDismissEvent === true,
+                declined: e.IsDismissed === true,
+            },
+        ];
+    });
+    const declinable = slots.filter((slot) => slot.canDecline);
+    return {
+        mustApply: Boolean(d.MustApply),
+        slots,
+        // As Wilma's page: the button shows while a slot can be declined and none is chosen for good.
+        canDecline: declinable.length > 0 && !slots.some((slot) => slot.wilmaState === "selected"),
+        declined: declinable.length > 0 && declinable.every((slot) => slot.declined),
+    };
+}
+/**
+ * What can be done with a slot right now (the states Wilma's own page shows).
+ * Pass the invitation to tell a free slot from one the family can't take
+ * because it already has another.
+ */
+export function slotState(slot, now = new Date(), invitation) {
+    if (slot.selected)
+        return slot.wilmaState === "selected" || (slot.cancelUntil && now > slot.cancelUntil) ? "chosen-locked" : "chosen";
+    if (slot.selectedByOther)
+        return "chosen-by-other";
+    if (slot.wilmaState === "expired")
+        return "closed";
+    if (slot.wilmaState === "full")
+        return "full";
+    if (slot.wilmaState === "pending")
+        return "not-yet";
+    if (slot.enrollStart && now < slot.enrollStart)
+        return "not-yet";
+    if (slot.enrollEnd && now > slot.enrollEnd)
+        return "closed";
+    if (slot.maxPeople > 0 && slot.peopleCount >= slot.maxPeople)
+        return "full";
+    if (invitation && answered(invitation))
+        return "taken";
+    return "open";
+}
+/** You or another guardian signed up for one of the slots. */
+function answered(invitation) {
+    return invitation.slots.some((slot) => slot.selected || slot.selectedByOther);
+}
+/** The invitation still waits for an answer: nobody in the family signed up or said they won't attend, and a slot is open. */
+export function awaitingAnswer(invitation, now = new Date()) {
+    if (answered(invitation) || invitation.declined)
+        return false;
+    return invitation.slots.some((slot) => slotState(slot, now) === "open");
+}
+/** The invitations list: each message with where this family stands. */
+export function parseInvitationListings(data, messages) {
+    const list = data ?? {};
+    const raw = (Array.isArray(list.Messages) ? list.Messages : Array.isArray(list.messages) ? list.messages : []);
+    const byId = new Map(raw.filter((m) => m && typeof m === "object").map((m) => [Number(m["Id"] ?? m["id"]), m]));
+    return messages.map((message) => {
+        const applying = byId.get(message.wilmaId)?.["Applying"];
+        const text = (value) => (typeof value === "string" && value.trim() ? value.replace(/\s+/g, " ").trim() : null);
+        return { message, status: text(applying?.Status), extra: text(applying?.ExtraInfo) };
+    });
+}

package/dist/parsers/messages.js

@@ -1,6 +1,7 @@
 import * as cheerio from "cheerio";
 import { parseWilmaTimestamp } from "./dates.js";
 import { htmlToText } from "./html-text.js";
+import { parseInvitation } from "./invitations.js";
 export function parseMessagesList(data, folder) {
     const now = new Date();
     const list = normalizeMessagesList(data);
@@ -89,6 +90,9 @@ export function parseMessageDetailJson(data, messageId) {
         content: htmlToText(str(m["ContentHtml"])),
         recipients,
         replies,
+        discussion: m["AllowCollatedReply"] === true,
+        canReply: typeof m["AllowReply"] === "boolean" ? m["AllowReply"] : null,
+        invitation: m["IsEvent"] ? parseInvitation(m["EventData"]) : null,
         fetchedAt: new Date(),
     };
 }

package/dist/parsers/news.js

@@ -1,4 +1,5 @@
 import * as cheerio from "cheerio";
+import { htmlToText } from "./html-text.js";
 import { parseWilmaTimestamp } from "./dates.js";
 const FILE_EXTENSION_RE = /\.(?:pdf|docx?|xlsx?|pptx?|odt|ods|odp|rtf|txt|csv|zip|7z|png|jpe?g|gif|webp)$/i;
 export function parseNewsList(data) {
@@ -29,12 +30,14 @@ export function parseNewsList(data) {
 }
 export function parseNewsDetailJson(newsId, data, baseUrl) {
     const rawContent = data["content"] ?? data["Content"];
-    const content = typeof rawContent === "string" ? rawContent : null;
+    const html = typeof rawContent === "string" ? rawContent : null;
     let resources = [];
-    if (content && content.includes("<a")) {
-        const $ = cheerio.load(content);
+    if (html && html.includes("<a")) {
+        const $ = cheerio.load(html);
         resources = extractNewsResources($, $.root(), baseUrl);
     }
+    // The body is the editor's HTML: as text with its paragraphs and lists.
+    const content = html ? htmlToText(html) || null : null;
     return {
         wilmaId: newsId,
         title: String(data["title"] ?? data["Title"] ?? ""),
@@ -70,7 +73,8 @@ export function parseNewsDetailHtml(html, newsId, baseUrl) {
         resources = extractNewsResources($, contentElem, baseUrl);
         const cleanContent = contentElem.clone();
         cleanContent.find("script, style").remove();
-        const text = cleanContent.text().trim();
+        // As text with its paragraphs and lists (the page's own indentation and spacer lines aren't text).
+        const text = htmlToText(cleanContent.html());
         // A container made entirely from resource anchors has no prose body. Keep
         // the labels in resources instead of duplicating them in content.
         const proseOnly = cleanContent.clone();

package/dist/parsers/overview.js

@@ -120,6 +120,7 @@ function parseTopLevelGrades(exams) {
             info: exam.Info?.trim() || null,
             teacher: teacher?.TeacherName ?? "",
             teacherCode: teacher?.TeacherCode ?? "",
+            seen: /^\d{4}-\d{2}-\d{2}/.exec(exam.ExamSeen ?? "")?.[0] ?? null,
         });
     }
     grades.sort((a, b) => b.date.localeCompare(a.date));

package/dist/parsers/recipients.d.ts

@@ -0,0 +1,16 @@
+import type { MessageRecipient, StudentDetails } from "../types.js";
+/** A compose link as a path on this Wilma, or null for anything else. */
+export declare function composePath(href: string | undefined, pageUrl: string): string | null;
+/** What a compose link writes to, from its r_ parameters (a repeated or mixed one: several people). */
+export declare function recipientKind(path: string): MessageRecipient["kind"];
+/** The child's class and supervisors from their front page (`/!<n>/`); empty fields when the panel isn't there. */
+export declare function parseStudentDetailsHtml(html: string, pageUrl: string): StudentDetails;
+/**
+ * The recipients page (`/messages/recipients`), or a list it loads (own
+ * teachers). Only recipients Wilma lets the parent write to are returned.
+ */
+export declare function parseRecipientsHtml(html: string, pageUrl: string, defaults?: {
+    group?: string;
+}): MessageRecipient[];
+/** Lists the recipients page loads on demand (own teachers one by one): [panel title, path]. */
+export declare function recipientListSources(html: string, pageUrl: string): [string, string][];