@wilm-ai/wilma-client 1.5.2 → 1.6.0

package/dist/parsers/gradebook.js

@@ -0,0 +1,44 @@
+import * as cheerio from "cheerio";
+/**
+ * The gradebook (Suoritukset): subjects, their syllabi and courses, each with
+ * a grade, scope and completion date. Rows carry their depth as a class
+ * ("level1", "level2", …), which gives the tree. An empty gradebook (nothing
+ * graded yet) has no table and gives [].
+ */
+export function parseGradebookHtml(html) {
+    const $ = cheerio.load(html);
+    const roots = [];
+    const stack = [];
+    $("table tbody tr").each((_, row) => {
+        const depthMatch = /\blevel(\d+)\b/.exec($(row).attr("class") ?? "");
+        const cells = $(row).find("td");
+        if (!depthMatch || cells.length < 2)
+            return;
+        const depth = Number(depthMatch[1]);
+        const text = (index) => $(cells[index]).text().replace(/\s+/g, " ").trim();
+        const label = text(0);
+        if (!label)
+            return;
+        const codeMatch = /^([\p{L}\d]+_[\p{L}\d.]*)\s+(.*)$/u.exec(label);
+        const entry = {
+            name: codeMatch ? codeMatch[2] : label,
+            code: codeMatch ? codeMatch[1] : null,
+            grade: text(1) || null,
+            credits: cells.length > 3 ? text(2) || null : null,
+            date: isoDate(text(cells.length > 3 ? 3 : 2)),
+            children: [],
+        };
+        while (stack.length && stack[stack.length - 1].depth >= depth)
+            stack.pop();
+        if (stack.length)
+            stack[stack.length - 1].entry.children.push(entry);
+        else
+            roots.push(entry);
+        stack.push({ depth, entry });
+    });
+    return roots;
+}
+function isoDate(value) {
+    const match = /^(\d{1,2})\.(\d{1,2})\.(\d{4})$/.exec(value);
+    return match ? `${match[3]}-${match[2].padStart(2, "0")}-${match[1].padStart(2, "0")}` : null;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * 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.
+ */
+export declare function htmlToText(html: string | null | undefined): string;

package/dist/parsers/html-text.js

@@ -0,0 +1,42 @@
+import * as cheerio from "cheerio";
+const BLOCKS = "p, div, tr, h1, h2, h3, h4, h5, h6, blockquote, table, ul, ol";
+/**
+ * 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.
+ */
+export function htmlToText(html) {
+    if (!html)
+        return "";
+    const $ = cheerio.load(`<div id="wilmai-root">${html}</div>`);
+    const root = $("#wilmai-root");
+    root.find("script, style").remove();
+    root.find("a[href]").each((_, anchor) => {
+        const link = $(anchor);
+        const href = (link.attr("href") ?? "").trim();
+        const label = link.text().replace(/\s+/g, " ").trim();
+        if (!/^(https?:|mailto:)/i.test(href))
+            return;
+        const address = href.replace(/^mailto:/i, "");
+        if (!label)
+            link.text(address);
+        else if (!label.includes(address) && !address.includes(label))
+            link.text(`${label} (${address})`);
+    });
+    root.find("br").replaceWith("\n");
+    root.find("li").each((_, item) => {
+        $(item).prepend("- ");
+        $(item).append("\n");
+    });
+    root.find(BLOCKS).each((_, block) => {
+        $(block).prepend("\n");
+        $(block).append("\n");
+    });
+    return root
+        .text()
+        .replace(/ /g, " ")
+        .replace(/[ \t]+/g, " ")
+        .replace(/ *\n */g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}

package/dist/parsers/messages.d.ts

@@ -1,5 +1,9 @@
 import type { Message, MessageFolder } from "../types.js";
 export declare function parseMessagesList(data: unknown, folder: MessageFolder): Message[];
+/**
+ * A message thread from `/messages/<id>?format=json`: the message, who it went
+ * to, and every reply. Returns null when the data isn't a thread (older Wilma
+ * versions answer with the HTML page instead).
+ */
+export declare function parseMessageDetailJson(data: unknown, messageId: number): Message | null;
 export declare function parseMessageDetailHtml(html: string, messageId: number): Message;
-/** Export for debugging - returns raw field names from first message */
-export declare function debugMessageFields(data: unknown): string[];

package/dist/parsers/messages.js

@@ -1,11 +1,15 @@
 import * as cheerio from "cheerio";
 import { parseWilmaTimestamp } from "./dates.js";
+import { htmlToText } from "./html-text.js";
 export function parseMessagesList(data, folder) {
     const now = new Date();
     const list = normalizeMessagesList(data);
     return list.flatMap((item) => {
         try {
             const wilmaId = Number(item["id"] ?? item["Id"]);
+            // Without a usable id a message can't be opened; skip it rather than carry NaN.
+            if (!Number.isInteger(wilmaId) || wilmaId <= 0)
+                return [];
             const subject = compactText(String(item["Subject"] ?? item["subject"] ?? ""));
             // Try many possible field names for the timestamp
             const timeValue = item["Time"] ??
@@ -23,12 +27,17 @@ export function parseMessagesList(data, folder) {
                 item["created"] ??
                 item["CreatedAt"] ??
                 item["createdAt"];
+            const sender = item["Sender"] ?? item["sender"];
             return [
                 {
                     wilmaId,
                     subject,
                     sentAt: parseWilmaTimestamp(timeValue),
                     folder,
+                    senderName: typeof sender === "string" && sender.trim() ? compactText(sender) : null,
+                    // Wilma marks unopened messages with a truthy Status (shown in bold).
+                    unread: Boolean(item["Status"]),
+                    replyCount: Number(item["Replies"]) || 0,
                     fetchedAt: now,
                 },
             ];
@@ -38,6 +47,51 @@ export function parseMessagesList(data, folder) {
         }
     });
 }
+/**
+ * A message thread from `/messages/<id>?format=json`: the message, who it went
+ * to, and every reply. Returns null when the data isn't a thread (older Wilma
+ * versions answer with the HTML page instead).
+ */
+export function parseMessageDetailJson(data, messageId) {
+    const list = data?.messages;
+    const m = Array.isArray(list) ? list[0] : undefined;
+    if (!m || typeof m !== "object")
+        return null;
+    const str = (value) => (typeof value === "string" && value.trim() ? value.trim() : null);
+    const recipients = Array.isArray(m["Recipients"])
+        ? m["Recipients"].map(str).filter((r) => Boolean(r))
+        : str(m["Recipient"])
+            ? [str(m["Recipient"])]
+            : null;
+    const replies = Array.isArray(m["ReplyList"])
+        ? m["ReplyList"].flatMap((reply) => {
+            if (!reply || typeof reply !== "object")
+                return [];
+            return [
+                {
+                    id: Number(reply["Id"]) || 0,
+                    sentAt: parseWilmaTimestamp(reply["TimeStamp"]),
+                    senderName: str(reply["Sender"]),
+                    content: htmlToText(str(reply["ContentHtml"])),
+                },
+            ];
+        })
+        : [];
+    replies.sort((a, b) => a.sentAt.getTime() - b.sentAt.getTime());
+    return {
+        wilmaId: Number(m["Id"]) || messageId,
+        subject: compactText(String(m["Subject"] ?? "")),
+        sentAt: parseWilmaTimestamp(m["TimeStamp"]),
+        folder: String(m["Folder"] ?? "unknown"),
+        senderId: typeof m["SenderId"] === "number" ? m["SenderId"] : null,
+        senderType: typeof m["SenderType"] === "number" ? m["SenderType"] : null,
+        senderName: str(m["Sender"]),
+        content: htmlToText(str(m["ContentHtml"])),
+        recipients,
+        replies,
+        fetchedAt: new Date(),
+    };
+}
 export function parseMessageDetailHtml(html, messageId) {
     const $ = cheerio.load(html);
     const panelBody = $("div#page-content-area.panel-body");
@@ -171,14 +225,6 @@ function normalizeMessagesList(data) {
     }
     return [];
 }
-/** Export for debugging - returns raw field names from first message */
-export function debugMessageFields(data) {
-    const list = normalizeMessagesList(data);
-    if (list.length > 0) {
-        return Object.keys(list[0]);
-    }
-    return [];
-}
 function compactText(value) {
     return value.replace(/\s+/g, " ").trim();
 }

package/dist/parsers/news.js

@@ -7,6 +7,8 @@ export function parseNewsList(data) {
         return data.flatMap((item) => {
             try {
                 const wilmaId = Number(item["id"] ?? item["Id"]);
+                if (!Number.isInteger(wilmaId) || wilmaId <= 0)
+                    return [];
                 const title = String(item["Title"] ?? item["title"] ?? "");
                 const published = parseWilmaTimestamp(item["Published"] ?? item["published"]);
                 return [
@@ -26,7 +28,8 @@ export function parseNewsList(data) {
     return [];
 }
 export function parseNewsDetailJson(newsId, data, baseUrl) {
-    const content = (data["content"] ?? data["Content"]);
+    const rawContent = data["content"] ?? data["Content"];
+    const content = typeof rawContent === "string" ? rawContent : null;
     let resources = [];
     if (content && content.includes("<a")) {
         const $ = cheerio.load(content);
@@ -35,7 +38,7 @@ export function parseNewsDetailJson(newsId, data, baseUrl) {
     return {
         wilmaId: newsId,
         title: String(data["title"] ?? data["Title"] ?? ""),
-        subtitle: (data["subtitle"] ?? data["Subtitle"]),
+        subtitle: typeof (data["subtitle"] ?? data["Subtitle"]) === "string" ? (data["subtitle"] ?? data["Subtitle"]) : null,
         author: (data["author"] ?? data["Author"]),
         published: parseWilmaTimestamp(data["Published"] ?? data["published"]),
         content,
@@ -74,17 +77,31 @@ export function parseNewsDetailHtml(html, newsId, baseUrl) {
         proseOnly.find("a[href]").remove();
         content = proseOnly.text().trim() ? text : null;
     }
+    // "Sär (Teacher Name) Julkaistu 27.9." — the date (this year's lack the
+    // year) and the author's profile link sit together under the bulletin.
+    let published = null;
+    let author = null;
+    const meta = $("p, span, div")
+        .filter((_, el) => PUBLISHED_RE.test($(el).text()) && $(el).find("p, div").length === 0)
+        .first();
+    const publishedMatch = PUBLISHED_RE.exec(meta.text().replace(/\s+/g, " "));
+    if (publishedMatch) {
+        published = parseWilmaTimestamp(publishedMatch[1]);
+        const authorLink = meta.find("a.profile-link").first();
+        author = authorLink.attr("title")?.trim() || authorLink.text().trim() || null;
+    }
     return {
         wilmaId: newsId,
         title,
         subtitle,
-        author: null,
-        published: null,
+        author,
+        published,
         content,
         resources,
         fetchedAt: new Date(),
     };
 }
+const PUBLISHED_RE = /(?:Julkaistu|Publicerad|Published)\s*:?\s*(\d{1,2}\.\d{1,2}\.(?:\d{4})?)/i;
 function extractNewsResources($, contentElem, baseUrl) {
     const resources = [];
     const seen = new Set();
@@ -143,9 +160,6 @@ export function parseNewsListHtml(html) {
     const newsItems = [];
     const seenIds = new Set();
     const headers = $("div.left h2.no-border, h2.no-border");
-    if (!headers.length) {
-        return newsItems;
-    }
     headers.each((_, header) => {
         const headerEl = $(header);
         const timestampRaw = headerEl.text().trim();
@@ -202,11 +216,51 @@ export function parseNewsListHtml(html) {
                     subtitle,
                     author,
                     published,
+                    // A padlock icon marks a bulletin pinned to the page.
+                    pinned: container.find(".vismaicon-locked").length > 0,
+                    archived: false,
                     fetchedAt: now,
                 });
             }
             sib = sib.next();
         }
     });
+    // The side panels list pinned bulletins and older ones (titles only; the
+    // date is on each bulletin). Recognised by their heading, in Finnish,
+    // Swedish or English.
+    $("div.panel-body > h2").each((_, heading) => {
+        const label = $(heading).text().trim();
+        const pinned = SIDE_PANEL_PINNED.test(label);
+        const archived = SIDE_PANEL_OLDER.test(label);
+        if (!pinned && !archived)
+            return;
+        $(heading)
+            .parent()
+            .find("a[href*='/news/']")
+            .each((_, anchor) => {
+            const match = /\/news\/(\d+)/.exec($(anchor).attr("href") ?? "");
+            const newsId = match ? Number(match[1]) : null;
+            if (!newsId)
+                return;
+            const known = newsItems.find((item) => item.wilmaId === newsId);
+            if (known) {
+                if (pinned)
+                    known.pinned = true;
+                return;
+            }
+            newsItems.push({
+                wilmaId: newsId,
+                title: $(anchor).text().trim() || "Untitled News",
+                subtitle: null,
+                author: null,
+                published: null,
+                pinned,
+                archived,
+                fetchedAt: now,
+            });
+        });
+    });
     return newsItems;
 }
+const SIDE_PANEL_PINNED = /^(pysyvät|permanent|pinned|bestående|fasta|stående)/i;
+const SIDE_PANEL_OLDER = /^(vanhat|vanhemmat|old|older|gamla|äldre|arkiv|archive)/i;

package/dist/parsers/overview.d.ts

@@ -1,2 +1,3 @@
 import type { OverviewData } from "../types.js";
-export declare function parseOverview(raw: unknown): OverviewData;
+/** `now` decides which exams are upcoming (default: the current time). */
+export declare function parseOverview(raw: unknown, now?: Date): OverviewData;

package/dist/parsers/overview.js

@@ -1,3 +1,4 @@
+import { finnishDateString } from "../finnish-time.js";
 /* ------------------------------------------------------------------ */
 /*  Helpers                                                           */
 /* ------------------------------------------------------------------ */
@@ -23,10 +24,10 @@ function firstScheduleTeacher(teachers) {
 /* ------------------------------------------------------------------ */
 /*  Main parser                                                       */
 /* ------------------------------------------------------------------ */
-export function parseOverview(raw) {
+/** `now` decides which exams are upcoming (default: the current time). */
+export function parseOverview(raw, now = new Date()) {
     const data = (raw ?? {});
-    const now = new Date();
-    const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+    const today = finnishDateString(now);
     return {
         schedule: parseSchedule(data.Schedule ?? []),
         upcomingExams: parseUpcomingExams(data.Groups ?? [], today),

package/dist/parsers/printouts.d.ts

@@ -0,0 +1,3 @@
+import type { Printout } from "../types.js";
+/** Printouts (Tulosteet): PDF documents the school offers, e.g. report cards or absence reports. */
+export declare function parsePrintoutsHtml(html: string): Printout[];

package/dist/parsers/printouts.js

@@ -0,0 +1,20 @@
+import * as cheerio from "cheerio";
+/** Printouts (Tulosteet): PDF documents the school offers, e.g. report cards or absence reports. */
+export function parsePrintoutsHtml(html) {
+    const $ = cheerio.load(html);
+    const printouts = [];
+    const seen = new Set();
+    $("a[href]").each((_, anchor) => {
+        const href = $(anchor).attr("href") ?? "";
+        const match = /^(?:https?:\/\/[^/]+)?(\/(?:![^/]+\/)?printouts\/(\d+)\.pdf)(?:[?#].*)?$/.exec(href);
+        if (!match || seen.has(match[2]))
+            return;
+        seen.add(match[2]);
+        printouts.push({
+            id: match[2],
+            title: $(anchor).text().replace(/\s+/g, " ").trim() || `Printout ${match[2]}`,
+            path: match[1],
+        });
+    });
+    return printouts;
+}

package/dist/parsers/schedule.d.ts

@@ -1,2 +1,8 @@
 import type { ScheduleLesson } from "../types.js";
 export declare function parseScheduleHtml(html: string): ScheduleLesson[];
+/**
+ * Lessons from the timetable API (`/api/v1/schedules/timetable`): one entry
+ * per date a lesson takes place, with every teacher and room. Field values
+ * match the schedule page's ("BI_ Biologia", "Lastname Firstname").
+ */
+export declare function parseTimetableJson(payload: unknown): ScheduleLesson[];

package/dist/parsers/schedule.js

@@ -81,3 +81,40 @@ function firstTeacher(groups) {
 function firstSubjectToken(subject) {
     return subject.trim().split(/\s+/, 1)[0] ?? "";
 }
+/**
+ * Lessons from the timetable API (`/api/v1/schedules/timetable`): one entry
+ * per date a lesson takes place, with every teacher and room. Field values
+ * match the schedule page's ("BI_ Biologia", "Lastname Firstname").
+ */
+export function parseTimetableJson(payload) {
+    if (!Array.isArray(payload))
+        return [];
+    const lessons = [];
+    for (const lesson of payload) {
+        const start = (lesson.startAt ?? "").slice(0, 5);
+        const end = (lesson.endsAt ?? "").slice(0, 5);
+        for (const rawDate of lesson.dates ?? []) {
+            const date = rawDate.slice(0, 10);
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
+                continue;
+            for (const module of lesson.modules ?? []) {
+                const subject = (module.caption ?? "").trim();
+                const teachers = module.teachers ?? [];
+                const rooms = (module.rooms ?? []).map((room) => (room.abbreviation ?? room.caption ?? "").trim()).filter(Boolean);
+                lessons.push({
+                    date,
+                    dayOfWeek: new Date(`${date}T12:00:00Z`).getUTCDay(),
+                    start,
+                    end,
+                    subject,
+                    subjectCode: firstSubjectToken(subject),
+                    teacher: teachers.map((t) => [t.lastname, t.firstname].filter(Boolean).join(" ")).join(", "),
+                    teacherCode: teachers.map((t) => t.abbreviation ?? "").filter(Boolean).join(", "),
+                    groupId: Number(module.id) || 0,
+                    room: rooms.length ? rooms.join(", ") : null,
+                });
+            }
+        }
+    }
+    return lessons.sort((a, b) => a.date.localeCompare(b.date) || a.start.localeCompare(b.start));
+}

package/dist/parsers/students.d.ts

@@ -1,8 +1,5 @@
-export interface StudentInfo {
-    studentNumber: string;
-    name: string;
-    href: string;
-}
+import type { StudentInfo } from "../types.js";
+export type { StudentInfo };
 export declare function studentNumberFromHref(href: string): string | null;
 export declare function parseStudentFromUrl(url: string): StudentInfo | null;
 /**

package/dist/parsers/students.js

@@ -46,7 +46,12 @@ function roleType(rec) {
     return rec.Type ?? rec.type ?? rec.RoleType ?? rec.roleType;
 }
 function roleName(rec, fallback) {
-    return String(rec.Name ?? rec.name ?? rec.Caption ?? rec.caption ?? fallback);
+    // First non-empty name; an empty Name must not drop the student.
+    for (const value of [rec.Name, rec.name, rec.Caption, rec.caption]) {
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return fallback;
 }
 function collectStudent(students, studentNumber, name) {
     if (!students.has(studentNumber)) {
@@ -100,6 +105,8 @@ export function parseStudentsFromAccountsRoles(data) {
 export function parseStudentsFromHome(html, pageUrl) {
     const $ = cheerio.load(html);
     const named = new Map();
+    // Names from links deeper than a student's root: used only when a student has no root link.
+    const deepNamed = new Map();
     const fromHref = new Map();
     $("a[href]").each((_, anchor) => {
         const href = $(anchor).attr("href") ?? "";
@@ -118,20 +125,28 @@ export function parseStudentsFromHome(html, pageUrl) {
         if (!text) {
             return;
         }
-        const lower = text.toLowerCase();
-        if (NAV_KEYWORDS.some((kw) => lower.includes(kw))) {
+        // Keywords match whole words only, so a name like "Ella Newsome" isn't
+        // mistaken for "news".
+        const words = text.toLowerCase().split(/[\s()]+/);
+        if (NAV_KEYWORDS.some((kw) => words.includes(kw))) {
             return;
         }
-        if (!named.has(studentNumber)) {
-            named.set(studentNumber, {
+        // Menu links go deeper than the student's root (/!123/messages) and their
+        // text is usually a section name, so a root link's text wins.
+        const target = /\/!\d+\/[^/?#]+/.test(href) ? deepNamed : named;
+        if (!target.has(studentNumber)) {
+            target.set(studentNumber, {
                 studentNumber,
                 name: text,
                 href,
             });
         }
     });
-    if (named.size > 0) {
-        return [...named.values()];
+    if (named.size > 0 || deepNamed.size > 0) {
+        // Every named student, in page order; none dropped for lacking a root link.
+        return [...fromHref.keys()]
+            .map((number) => named.get(number) ?? deepNamed.get(number))
+            .filter((student) => Boolean(student));
     }
     if (fromHref.size > 0) {
         return [...fromHref.values()];

package/dist/session.d.ts

@@ -1,5 +1,6 @@
 import { type RequestInit, type Response } from "undici";
 export declare class AuthenticationError extends Error {
+    constructor(message: string);
 }
 export declare class MfaRequiredError extends Error {
     formkey: string;
@@ -11,24 +12,75 @@ export declare class APIError extends Error {
 }
 export declare class WilmaSession {
     private baseUrl;
-    private cookieJar;
-    private loggedIn;
-    private username?;
-    private password?;
+    private auth;
     private studentNumber?;
     private debug;
     constructor(baseUrl: string, opts?: {
         studentNumber?: string | null;
         debug?: boolean;
     });
+    /** The login's cookies, so another process can resume the session (see resumeState). */
+    exportState(): string;
+    /**
+     * Continue a session saved by exportState() instead of logging in. If Wilma
+     * has ended it meanwhile, the first request notices (401/403 or the login
+     * page) and logs in again with these credentials. Returns false when the
+     * state holds no session to resume.
+     */
+    resumeState(state: string, username: string, password: string): boolean;
+    /** Called after every successful login (first or again). */
+    onLogin(callback: (() => void) | undefined): void;
+    /** Used to answer the two-step verification challenge when the session has to log in again. */
+    setMfaCallback(onMfa?: (formkey: string) => Promise<string>): void;
+    /**
+     * A session for another student on the same account. It shares this
+     * session's login (cookies and credentials), so no new login is needed —
+     * Wilma picks the student from the "/!<number>/" path prefix.
+     */
+    forStudent(studentNumber: string | null): WilmaSession;
     get urlPrefix(): string | null;
     getPrefixedPath(path: string): string;
     login(username: string, password: string): Promise<void>;
     submitMfaCode(formkey: string, otpCode: string): Promise<void>;
     private getLoginFormFields;
-    request(path: string, init?: RequestInit): Promise<Response>;
-    get(path: string, init?: RequestInit): Promise<Response>;
+    /**
+     * An authenticated request to this Wilma. Follows redirects within Wilma
+     * only; a redirect to another site is an error unless `externalRedirect`
+     * is "return" (then the 3xx response is handed back, e.g. so a download can
+     * continue without Wilma credentials).
+     */
+    request(path: string, init?: RequestInit, opts?: {
+        externalRedirect?: "error" | "return"; /** Idle timeout, e.g. longer for downloads. */
+        timeoutMs?: number;
+    }): Promise<Response>;
+    /** A redirect to this Wilma's login page: the session is gone. */
+    private isLoginRedirect;
+    /**
+     * Is this login still live? A cancelled session gets 401/403 everywhere;
+     * a live one answers the account roles API (or 404 on Wilmas without it).
+     * Lets a 403 on one item be told apart from a cancelled session without
+     * logging in again (which would log the parent out of their own browser).
+     */
+    private sessionAlive;
+    /**
+     * Answer a two-step verification challenge. If Wilma rejects the code (most
+     * likely because it was already used — logins less than 30 seconds apart
+     * share one), ask once more for the same challenge; the callback then
+     * waits for a fresh code.
+     */
+    answerMfa(formkey: string, onMfa: (formkey: string) => Promise<string>): Promise<void>;
+    /** Log in again, once for everyone sharing this login even if many requests notice at the same time. */
+    private relogin;
+    get(path: string, init?: RequestInit, opts?: {
+        externalRedirect?: "error" | "return";
+        timeoutMs?: number;
+    }): Promise<Response>;
     post(path: string, init?: RequestInit): Promise<Response>;
     private getLoginToken;
+    /**
+     * One request to this Wilma, following redirects within Wilma hop by hop
+     * (cookies are stored per hop, and only for Wilma). A redirect to another
+     * origin is returned as-is: Wilma's cookies never travel there.
+     */
     private rawRequest;
 }