@falkenslab/moodle-driver 0.5.0 → 0.5.1

package/dist/moodle-methods.generated.d.ts

@@ -0,0 +1,1127 @@
+/**
+ * The methods a `Moodle` has from the driver's functions: each is the function of the same name
+ * without its first two parameters (the browser context and the site), and its doc comment.
+ */
+export interface MoodleMethods {
+    /**
+     * Moodle 5's activities overview of a course for one type ("resource" for every resource type):
+     * per activity, the columns its overview page shows the person (due dates, submissions, what needs
+     * grading, their own grade…). Without a type, every type in the course's state: "resource" first,
+     * which brings pages, books, files, folders and links at once, then each type still missing.
+     */
+    activitiesOverview(courseId: number, type?: string): Promise<{
+        fields: import("./areas/courses/overview.js").OverviewField[];
+        available?: boolean | undefined;
+        visible: boolean;
+        url?: string | undefined;
+        id: number;
+        name: string;
+        type: string;
+    }[]>;
+    /**
+     * A course's activity report: per activity, how many times it was viewed, by how many people, and
+     * when last, from the logs (between `from` and `until` when given). Activities nobody viewed come with
+     * zero views.
+     */
+    activityReport(courseId: number, options?: {
+        from?: Date | undefined;
+        until?: Date | undefined;
+    }): Promise<import("./areas/reports/reports.js").ActivityViews[]>;
+    /**
+     * An activity's settings as its form holds them, without submitting it: its module, name and
+     * description, every field by the name `updateActivity` takes in `settings`, the files of a
+     * resource, folder or SCORM, and its restrictions and completion in plain terms. Teachers only.
+     */
+    activitySettings(activityId: number): Promise<{
+        id: number;
+        module: string;
+        courseId: number;
+        name: string;
+        description: string;
+        fields: import("./areas/activities/build.js").FormField[];
+        files: import("./core/forms.js").DraftFile[] | undefined;
+        restrictions: import("./areas/activities/conditions.js").Restrictions | undefined;
+        completion: import("./areas/activities/conditions.js").Completion | undefined;
+    }>;
+    /** Adds a grade category (at the course's top level, or inside `parentId`); returns it as the setup shows it. */
+    addGradeCategory(courseId: number, options: {
+        name: string;
+        aggregation?: "mean" | "median" | "lowest" | "highest" | "mode" | "weighted-mean" | "simple-weighted-mean" | "mean-with-extra-credits" | "natural" | undefined;
+        parentId?: number | undefined;
+    }): Promise<{
+        changed: string;
+        category?: import("./areas/grades/gradebook.js").GradebookCategory | undefined;
+    }>;
+    /**
+     * Adds a manual grade item (one graded in the gradebook, not by an activity): out of `maxGrade`
+     * (Moodle's default, 100, when left out) or on a scale (`scaleId`), at the course's top level or in
+     * `categoryId`, hidden from students when asked. Returns it as the setup shows it.
+     */
+    addGradeItem(courseId: number, options: {
+        name: string;
+        maxGrade?: number | undefined;
+        scaleId?: number | undefined;
+        categoryId?: number | undefined;
+        hidden?: boolean | undefined;
+    }): Promise<{
+        changed: string;
+        item?: import("./areas/grades/gradebook.js").GradebookItem | undefined;
+    }>;
+    /**
+     * Adds bank questions to a quiz by id, and random questions from a bank category, at the end or on a
+     * page, as the edit page's bank actions post them. Returns the quiz's structure afterwards. A quiz
+     * already attempted can't change its questions: Moodle refuses, and so does this.
+     */
+    addQuestionsToQuiz(activityId: number, options: {
+        questionIds?: number[] | undefined;
+        random?: {
+            categoryId: number;
+            count: number;
+            includeSubcategories?: boolean | undefined;
+        } | undefined;
+        page?: number | undefined;
+    }): Promise<import("./areas/quizzes/structure.js").QuizChange>;
+    /**
+     * Adds a section to a quiz starting at a slot, with its heading and whether its questions are
+     * shuffled, as the edit page's "Add a new section heading" and its heading and shuffle controls do.
+     * A section starts at a page: the slot must be the first of its page (see `setQuizPages`).
+     */
+    addQuizSection(activityId: number, options: {
+        firstSlot: number;
+        heading: string;
+        shuffle?: boolean | undefined;
+    }): Promise<import("./areas/quizzes/structure.js").QuizChange & {
+        sectionId: number;
+    }>;
+    /** Adds a section after another one (at the end without it), named when a name is given, with a description (HTML) when `summary` is. */
+    addSection(courseId: number, options?: {
+        name?: string | undefined;
+        afterSectionId?: number | undefined;
+        summary?: string | undefined;
+    }): Promise<import("./areas/activities/build.js").CourseChange>;
+    /**
+     * Allocates a marker (the user id of someone who can grade; several where the assignment uses
+     * several markers per submission) to participants' submissions, as the grading table's "Allocate
+     * marker" does. Moodle leaves alone submissions past marking (marking completed, in review, ready
+     * for release, released).
+     */
+    allocateMarker(activityId: number, userIds: number[], markerId: number | number[]): Promise<{
+        changed: string;
+    }>;
+    /** Answers a choice with one option (several where it allows them) by id, as "Save my choice" does; returns the choice afterwards. */
+    answerChoice(activityId: number, optionIds: number[]): Promise<{
+        changed: string;
+        choice: import("./areas/surveys/choice.js").Choice;
+    }>;
+    /**
+     * Assesses a submission as the person, through the workshop's assessment form (its grading
+     * strategy's: accumulative, comments, number of errors or rubric), as "Assess" on the submission's
+     * page and the form do: a teacher who hasn't assessed it yet gets an assessment of their own, and one
+     * already made is changed. `criteria` go in the form's order; `feedback` is the overall feedback for
+     * the author (HTML), where the workshop has it on; `fields` sets any other field of the form by name
+     * (`weight`…). Returns a sentence of what changed, the assessment's id, and the grade it gives the
+     * submission out of the workshop's grade. Throws `WorkshopError` outside the assessment phase, when a
+     * criterion's grade isn't one it takes, or when the workshop has no overall feedback; `FormError` when
+     * Moodle refuses the form (a criterion left without a grade).
+     */
+    assessWorkshopSubmission(activityId: number, submissionId: number, options: {
+        criteria?: import("./areas/workshops/workshops.js").WorkshopCriterion[] | undefined;
+        feedback?: string | undefined;
+        fields?: Record<string, import("./core/forms.js").FieldValue> | undefined;
+    }): Promise<{
+        changed: string;
+        assessmentId: number;
+        grade?: number | undefined;
+        maxGrade?: number | undefined;
+    }>;
+    /**
+     * Every participant's submission to an assignment, with the group they submit for (group
+     * submissions), and, unless `includeContent` is false, its content, the feedback files they have,
+     * its marking workflow state and markers (all from each participant's grading panel).
+     */
+    assignmentSubmissions(activityId: number, options?: {
+        includeContent?: boolean | undefined;
+    }): Promise<import("./areas/assignments/grading.js").Submission[]>;
+    /**
+     * Backs a course up to a `.mbz` file, through Moodle's backup wizard (initial settings, schema,
+     * confirmation), and downloads it into `destDir`. Without users' data unless `withUsers`, which
+     * needs `moodle/backup:userinfo` (`anonymize` makes their names anonymous). An asynchronous backup
+     * is waited for up to `timeoutMs` (ten minutes). Moodle keeps the file in the course's or the
+     * person's backup area too.
+     */
+    backupCourse(courseId: number, destDir: string, options?: {
+        withUsers?: boolean | undefined;
+        anonymize?: boolean | undefined;
+        timeoutMs?: number | undefined;
+    }): Promise<{
+        changed: string;
+        file: import("./core/files.js").DownloadedFile;
+    }>;
+    /** One calendar event by its id, as `upcomingEvents` gives them. */
+    calendarEvent(eventId: number): Promise<import("./areas/calendar/calendar.js").CalendarEvent>;
+    /**
+     * A course's progress report: every participant's completion of every activity that tracks it, page
+     * by page, in one group when given. People come as user id and full name only.
+     */
+    completionReport(courseId: number, options?: {
+        group?: number | undefined;
+    }): Promise<import("./areas/completion/completion.js").CompletionReport>;
+    /**
+     * A conversation's messages, oldest first, as text, and its members as `conversations()` gives them:
+     * everyone but the person, whether they wrote in it or not (the person alone in their own conversation).
+     */
+    conversation(conversationId: number): Promise<{
+        id: number;
+        members: {
+            userId: number;
+            fullName: string;
+        }[];
+        messages: {
+            id: number;
+            fromUserId: number;
+            text: string;
+            time: string | undefined;
+        }[];
+    }>;
+    /** The person's conversations, latest first, with their last message as text. */
+    conversations(): Promise<import("./areas/messages/messages.js").ConversationSummary[]>;
+    /**
+     * Copies a course into a new one, as Moodle's "Copy course" does: its content (and its people's
+     * data and enrolments, `withUsers`), under a new full and short name, in a category (the course's
+     * unless given), with new dates. Goes through Moodle's copy service, then waits for the copy, which
+     * Moodle makes in its scheduled tasks, up to `timeoutMs` (ten minutes). Needs the rights to back
+     * up, restore and create courses (`moodle/backup:backupcourse`, `moodle/restore:restorecourse`,
+     * `moodle/course:create`); without them, `BackupError` says so.
+     */
+    copyCourse(courseId: number, options: {
+        fullName: string;
+        shortName: string;
+        categoryId?: number | undefined;
+        start?: Date | undefined;
+        end?: Date | undefined;
+        withUsers?: boolean | undefined;
+        visible?: boolean | undefined;
+        timeoutMs?: number | undefined;
+    }): Promise<{
+        changed: string;
+        course: import("./areas/backup/backup.js").CourseRef;
+    }>;
+    /**
+     * What the person can do in a course, asked of read-only services that need the capability: the
+     * activity types they can add (none without `moodle/course:manageactivities`) and the grader
+     * report's users (`nopermissions` without `gradereport/grader:view`). Nothing is changed.
+     */
+    courseAbilities(courseId: number, sectionId: number): Promise<{
+        canEdit: boolean;
+        canGrade: boolean;
+    }>;
+    /** The activity and resource types the person can add to a course: none when they can't edit it. */
+    courseActivityTypes(courseId: number): Promise<{
+        purpose?: string | undefined;
+        type: string;
+        title: string;
+    }[]>;
+    /**
+     * A course's logs, newest first, as its logs report lists them: by a user, an activity, a kind of
+     * action, and a time span, up to `limit` entries (100 unless given). Moodle filters by user, activity
+     * and action; the span is read page by page, stopping at the first entry older than `from`. Every
+     * entry's time comes as an ISO date, read back with the site language's own format.
+     */
+    courseLogs(courseId: number, options?: {
+        userId?: number | undefined;
+        activityId?: number | undefined;
+        from?: Date | undefined;
+        until?: Date | undefined;
+        action?: "create" | "view" | "update" | "delete" | "change" | undefined;
+        limit?: number | undefined;
+    }): Promise<import("./areas/reports/reports.js").LogEntry[]>;
+    /** A user's roles in a course, from their profile there: role links carry the role id in any language. */
+    courseRoles(userId: number, courseId: number): Promise<{
+        id: number;
+        name: string;
+    }[]>;
+    /**
+     * A course's sections and activities; with `details`, each activity's dates and restriction and each
+     * section's description, from the course page (slower).
+     */
+    courseStructure(courseId: number, options?: {
+        details?: boolean | undefined;
+    }): Promise<import("./areas/courses/structure.js").CourseSection[]>;
+    /** What changed in a course's activities since a date, with their names from the course's state. */
+    courseUpdates(courseId: number, since: Date): Promise<{
+        changes: {
+            items?: number | undefined;
+            time?: string | undefined;
+            what: string;
+        }[];
+        name?: string | undefined;
+        type?: string | undefined;
+        id: number;
+    }[]>;
+    /**
+     * Creates an activity or resource of any type at the end of a section, through Moodle's own form,
+     * hidden from students unless `visibility` says otherwise. `files` are local paths uploaded to a file
+     * resource or folder (a `DraftUpload` puts one in a folder's subfolder); a SCORM (`type: "scorm"`) or
+     * an H5P activity (`type: "h5pactivity"`) takes the first as its package.
+     */
+    createActivity(input: import("./areas/activities/build.js").ActivityFields & {
+        courseId: number;
+        sectionId: number;
+        type: string;
+        files?: (string | import("./core/forms.js").DraftUpload)[] | undefined;
+    }): Promise<import("./areas/activities/build.js").CourseChange>;
+    /**
+     * Creates a course event, through the calendar's own form: its start, and its duration and
+     * description when given. Returns it as the calendar has it.
+     */
+    createEvent(options: {
+        courseId: number;
+        name: string;
+        start: Date;
+        durationMinutes?: number | undefined;
+        description?: string | undefined;
+    }): Promise<{
+        changed: string;
+        event: import("./areas/calendar/calendar.js").CalendarEvent;
+    }>;
+    /**
+     * Creates a group in a course with its group form (`group/group.php`). Throws `FormError` with
+     * Moodle's reason when it refuses (a name already used, an enrolment key another group has).
+     */
+    createGroup(courseId: number, settings: import("./areas/participants/groups.js").GroupSettings & {
+        name: string;
+    }): Promise<{
+        changed: string;
+        groupId: number;
+    }>;
+    /** Creates a grouping in a course with its form (`group/grouping.php`); add its groups with `setGroupingGroups`. */
+    createGrouping(courseId: number, settings: import("./areas/participants/groups.js").GroupingSettings & {
+        name: string;
+    }): Promise<{
+        changed: string;
+        groupingId: number;
+    }>;
+    /**
+     * Creates one question in a bank through its type's edit form; returns its id. Imports are the way
+     * for several; this is for one-offs.
+     */
+    createQuestion(activityId: number, input: import("./areas/questions/banks.js").QuestionInput): Promise<{
+        changed: string;
+        questionId?: number | undefined;
+    }>;
+    /**
+     * What the person has to do by a date (calendar action events: submit, attempt, grade…), from the
+     * last `pastDays` to `days` ahead, in one course or all. Teachers' grading counts come from the
+     * activities overview instead: Moodle gives them few action events.
+     */
+    deadlines(options?: {
+        courseId?: number | undefined;
+        days?: number | undefined;
+        pastDays?: number | undefined;
+    }): Promise<{
+        action?: {
+            url?: string | undefined;
+            count?: number | undefined;
+            name: string;
+            actionable: boolean;
+        } | undefined;
+        course?: {
+            shortname?: string | undefined;
+            id: number;
+        } | undefined;
+        event: string;
+        kind: string;
+        date: string;
+        overdue: boolean;
+        type?: string | undefined;
+        activity: string;
+        activityId?: number | undefined;
+    }[]>;
+    /** Deletes an activity, with its participants' data (submissions, posts, attempts); gives the course afterwards. */
+    deleteActivity(courseId: number, activityId: number): Promise<import("./areas/activities/build.js").CourseChange>;
+    /** Deletes a calendar event the person can manage. */
+    deleteEvent(eventId: number): Promise<{
+        changed: string;
+    }>;
+    /**
+     * Deletes a grade category. Moodle moves what it held (items and categories) into its parent and
+     * deletes the grades of its total; the course's own category can't be deleted.
+     */
+    deleteGradeCategory(courseId: number, categoryId: number): Promise<{
+        changed: string;
+    }>;
+    /**
+     * Deletes a manual grade item and its grades. An activity's item goes with its activity (Moodle
+     * would make it again), so it's refused.
+     */
+    deleteGradeItem(courseId: number, itemId: number): Promise<{
+        changed: string;
+    }>;
+    /** Deletes a group, as the groups page's "Delete selected group" does once confirmed; its members stay in the course. */
+    deleteGroup(groupId: number): Promise<{
+        changed: string;
+    }>;
+    /** Deletes a grouping, as its delete icon does once confirmed; its groups stay. */
+    deleteGrouping(groupingId: number): Promise<{
+        changed: string;
+    }>;
+    /**
+     * Deletes a post and its replies through Moodle's own confirmation (`post.php?delete=`); a
+     * discussion's first post takes the whole discussion. Only a moderator deletes a post with replies,
+     * or someone else's. `replies` says how many replies went with it. Throws `ForumError` with
+     * Moodle's reason when it refuses.
+     */
+    deletePost(postId: number): Promise<{
+        changed: string;
+        discussionId?: number | undefined;
+        replies: number;
+        discussionDeleted: boolean;
+    }>;
+    /**
+     * Deletes questions from a bank, every version of each, as the bank's delete action does: asked,
+     * then confirmed. Moodle doesn't delete a question a quiz uses: it hides it, and `hidden` lists those.
+     */
+    deleteQuestions(activityId: number, questionIds: number[]): Promise<{
+        changed: string;
+        deleted: number[];
+        hidden: number[];
+    }>;
+    /** Deletes a section and every activity in it, with their participants' data. */
+    deleteSection(courseId: number, sectionId: number): Promise<import("./areas/activities/build.js").CourseChange>;
+    /** A discussion's posts, oldest first, with their messages as text. */
+    discussion(discussionId: number): Promise<{
+        discussion: {
+            id: number;
+            forumInstanceId: number;
+            courseId: number;
+        };
+        posts: import("./areas/forums/posts.js").ForumPost[];
+    }>;
+    /** Duplicates an activity as the course page's "Duplicate" does (right after it, named with "(copy)"); gives the copy's id and the course afterwards. */
+    duplicateActivity(courseId: number, activityId: number): Promise<import("./areas/activities/build.js").CourseChange>;
+    /** Renames, shows or hides, or moves an activity (to a section's end, or before another one). */
+    editActivity(courseId: number, activityId: number, options: {
+        name?: string | undefined;
+        visibility?: "shown" | "hidden" | "stealth" | undefined;
+        sectionId?: number | undefined;
+        beforeActivityId?: number | undefined;
+    }): Promise<import("./areas/activities/build.js").CourseChange>;
+    /**
+     * Changes a post through Moodle's own post form (`post.php?edit=`), as its author (within the site's
+     * editing time) or a moderator: only what's given changes. Returns the post afterwards. Throws
+     * `ForumError` with Moodle's reason when it refuses.
+     */
+    editPost(postId: number, changes: import("./areas/forums/posts.js").PostChanges): Promise<{
+        changed: string;
+        post?: import("./areas/forums/posts.js").ForumPost | undefined;
+    }>;
+    /**
+     * Changes one slot of a quiz (by its place, from 1): its maximum mark, through the slots' service,
+     * and where it is, as dragging it on the edit page does: after another slot (`moveAfter`, 0 for
+     * first) and on a page. Moodle lets the mark change after attempts (it regrades them), not the rest.
+     */
+    editQuizSlot(activityId: number, slot: number, options: {
+        maxMark?: number | undefined;
+        moveAfter?: number | undefined;
+        page?: number | undefined;
+    }): Promise<import("./areas/quizzes/structure.js").QuizChange>;
+    /**
+     * Renames, shows or hides, describes (`summary`, HTML), restricts (`restrictions`; `{ conditions: [] }`
+     * removes them) or moves a section after another one.
+     */
+    editSection(courseId: number, sectionId: number, options: {
+        name?: string | undefined;
+        visible?: boolean | undefined;
+        summary?: string | undefined;
+        restrictions?: import("./areas/activities/conditions.js").Restrictions | undefined;
+        afterSectionId?: number | undefined;
+    }): Promise<import("./areas/activities/build.js").CourseChange>;
+    /**
+     * Enrols users in a course by manual enrolment, as the participants page's "Enrol users" dialog does:
+     * with `roleId` or the enrolment's default role, from `start` (now, unless given) until `end` (the
+     * enrolment's default duration, unless given). Users already enrolled keep their enrolment, with the
+     * new dates. Throws `EnrolmentError` with Moodle's reason when it refuses (a role the person can't
+     * assign, no manual enrolment).
+     */
+    enrolUsers(courseId: number, userIds: number[], options?: {
+        roleId?: number | undefined;
+        start?: Date | undefined;
+        end?: Date | undefined;
+    }): Promise<{
+        changed: string;
+        count: number;
+        roleId?: number | undefined;
+    }>;
+    /**
+     * A course's enrolment methods, in the order Moodle tries them: each one's type, name, whether it's
+     * enabled and how many users it enrolled, and from its form the role it gives and, for self enrolment
+     * and guest access, whether it asks for a key (never the key), self enrolment's dates and limit.
+     * Throws `EnrolmentError` when the person can't manage the course's enrolment methods.
+     */
+    enrolmentMethods(courseId: number): Promise<import("./areas/participants/methods.js").EnrolmentMethod[]>;
+    /** Submits an attempt for grading, and gives its review when the quiz shows it. */
+    finishQuizAttempt(attemptId: number): Promise<{
+        changed: string;
+        attemptId: number;
+        finished: true;
+        review: {
+            summary: import("./areas/quizzes/attempts.js").Detail[];
+            questions: import("./areas/quizzes/attempts.js").Question[];
+        } | undefined;
+    }>;
+    /** A forum's discussions, as its page lists them: who started each, replies, last post. */
+    forumDiscussions(activityId: number): Promise<import("./areas/forums/posts.js").ForumDiscussion[]>;
+    /**
+     * Everyone's whole-forum grade in a forum graded as a whole, as its grader shows them: one per
+     * person it can grade (only the active ones when the forum says so), with how it's graded. One
+     * service call per person. Throws `NotAForumError` for another activity, and `GradingError` when
+     * the forum isn't graded as a whole or uses an advanced grading method.
+     */
+    forumGrades(activityId: number, options?: {
+        groupId?: number | undefined;
+    }): Promise<import("./areas/forums/grading.js").ForumGrades>;
+    /** A choice: its options, whether it can be answered or changed, and the person's answer. */
+    getChoice(activityId: number): Promise<import("./areas/surveys/choice.js").Choice>;
+    /** A survey (questionnaire or feedback): whether it can be answered, its intro and messages, and its questions page by page. Its module is found when not given. */
+    getSurvey(activityId: number, type?: import("./areas/surveys/surveys.js").SurveyType): Promise<{
+        questions: import("./areas/surveys/surveys.js").SurveyQuestion[];
+        canAnswer: boolean;
+        intro: string;
+        messages: string[];
+    }>;
+    /**
+     * Gives a person their whole-forum grade, as the forum's grader does: points (out of the forum's
+     * maximum), or a scale item by name or value; `null` takes the grade away. Moodle's forum grader
+     * has no feedback text. `notify` sends the person Moodle's notification, as the grader's checkbox
+     * does. Returns a sentence of what changed and the grade afterwards. Throws `GradingError` when the
+     * forum isn't graded as a whole, the grade is out of range or not on the scale, or Moodle refuses it.
+     */
+    gradeForumUser(activityId: number, userId: number, options: {
+        grade: string | number | null;
+        notify?: boolean | undefined;
+    }): Promise<{
+        changed: string;
+        grade: Omit<import("./areas/forums/grading.js").ForumGrade, "fullName">;
+    }>;
+    /**
+     * Grades one question of a finished attempt by hand, with a comment, through Moodle's comment form
+     * (the review's "Make comment or override mark"): an essay waiting for grading, or any question whose
+     * mark the teacher overrides. The mark is in the question's points (0 to its maximum in the quiz).
+     * Returns the attempt's grade afterwards when the results report shows it.
+     */
+    gradeQuizQuestion(attemptId: number, slot: number, options: {
+        mark: number;
+        comment?: string | undefined;
+    }): Promise<{
+        changed: string;
+        attemptId: number;
+        slot: number;
+        mark: number;
+        maxMark?: number | undefined;
+        grade?: string | undefined;
+    }>;
+    /**
+     * Grades a participant as the grader does: a grade (simple grading), a rubric's level per criterion
+     * or a marking guide's score per criterion (by their ids, from `rubric()`), remarks per criterion,
+     * feedback comments (HTML), feedback files (local paths that replace the ones the participant has;
+     * `[]` removes them), whether to notify, and any other grading field by name. Returns the grade
+     * saved and the gradebook's grade, the total Moodle computes for a rubric or a guide, and the
+     * feedback files after saving when they were given. Throws `GradingError` when Moodle refuses the
+     * grade, or when files are given to an assignment without feedback files.
+     */
+    gradeSubmission(activityId: number, userId: number, options: {
+        grade?: string | number | undefined;
+        rubric?: Record<number, number> | undefined;
+        guide?: Record<number, number> | undefined;
+        remarks?: Record<number, string> | undefined;
+        feedback?: string | undefined;
+        feedbackFiles?: string[] | undefined;
+        workflowState?: "notmarked" | "inmarking" | "readyforreview" | "inreview" | "readyforrelease" | "released" | undefined;
+        applyToGroup?: boolean | undefined;
+        notify?: boolean | undefined;
+        fields?: Record<string, import("./core/forms.js").FieldValue> | undefined;
+    }): Promise<{
+        workflowState?: "notmarked" | "inmarking" | "readyforreview" | "inreview" | "readyforrelease" | "released" | undefined;
+        feedbackFiles?: {
+            name: string;
+            url: string;
+        }[] | undefined;
+        grade?: string | undefined;
+        gradebookGrade?: string | undefined;
+        feedback?: string | undefined;
+        changed: string;
+    }>;
+    /** A course's gradebook setup: its categories (aggregation, weights) and grade items (category, maximum, weight). */
+    gradebookSetup(courseId: number): Promise<{
+        categories: import("./areas/grades/gradebook.js").GradebookCategory[];
+        items: import("./areas/grades/gradebook.js").GradebookItem[];
+    }>;
+    /**
+     * Everyone's grades in a course as the grader report shows them, page by page, in one group when
+     * given. People come as user id and full name only.
+     */
+    graderReport(courseId: number, options?: {
+        group?: number | undefined;
+    }): Promise<import("./areas/grades/gradebook.js").GraderReport>;
+    /**
+     * Grants participants an extension until a date, through the assignment's extension form (several at
+     * once as its bulk action does). Moodle refuses a date before the assignment's due date, and a person
+     * without its "grant extension" capability only on saving (the form opens for anyone, confirmed
+     * empirically on the sandbox, 5.2): both throw.
+     */
+    grantExtension(activityId: number, userIds: number[], until: Date): Promise<{
+        changed: string;
+    }>;
+    /** A course's groupings with their groups' ids, from its groupings page and each grouping's groups page. Throws `MoodleError` with Moodle's refusal for a person who can't manage groups. */
+    groupings(courseId: number): Promise<import("./areas/participants/groups.js").Grouping[]>;
+    /** A course's groups the person can see, with their members' user ids. */
+    groups(courseId: number): Promise<import("./areas/participants/participants.js").CourseGroup[]>;
+    /** An H5P activity: its content type, whether attempts are tracked, and the person's attempts with their scores. */
+    h5pActivity(activityId: number): Promise<import("./areas/h5p/h5p.js").H5PActivity>;
+    /**
+     * Imports activities from another course into a course, as Moodle's "Import" does: every activity
+     * of `fromCourseId`, or only `activityIds`, added to `toCourseId`'s content (with their sections),
+     * without users' data. Needs `moodle/restore:restoretargetimport` in the course imported into and
+     * `moodle/backup:backuptargetimport` in the other. Returns the activities the course has afterwards
+     * that it didn't have before, by id.
+     */
+    importActivities(fromCourseId: number, toCourseId: number, options?: {
+        activityIds?: number[] | undefined;
+    }): Promise<{
+        changed: string;
+        activityIds: number[];
+    }>;
+    /**
+     * Imports questions into a bank from a GIFT or Moodle XML file (a local path) or text, through the
+     * bank's import form; returns the questions created. A file Moodle can't parse comes back as a
+     * `QuestionBankError` with its messages, and nothing is imported.
+     */
+    importQuestions(activityId: number, options: {
+        format: "xml" | "gift";
+        file?: string | undefined;
+        text?: string | undefined;
+        categoryId?: number | undefined;
+    }): Promise<{
+        changed: string;
+        questions: import("./areas/questions/banks.js").BankQuestion[];
+    }>;
+    /** The lesson page the person is on (starting the lesson the first time). */
+    lessonPage(activityId: number): Promise<import("./areas/lessons/lessons.js").LessonPage>;
+    /** The course's assignments, in the course's order, with the section each is in. */
+    listAssignments(courseId: number): Promise<import("./areas/courses/structure.js").CourseAssignment[]>;
+    /** The courses the person is enrolled in, as teacher or student. */
+    listCourses(classification?: "all" | "inprogress" | "future" | "past"): Promise<import("./areas/courses/list.js").Course[]>;
+    /**
+     * Logs the person out of Moodle through the user menu's logout link (it carries the sesskey; without
+     * one Moodle asks to confirm, and the confirmation is accepted). Returns false when nobody was logged
+     * in. Only Moodle's session ends: a single sign-on provider may keep its own.
+     */
+    logOut(): Promise<boolean>;
+    /** Marks all the person's notifications read, as the popover's "Mark all as read" does; doing it twice changes nothing. */
+    markNotificationsRead(): Promise<{
+        changed: string;
+    }>;
+    /**
+     * Sends one message to several participants of a course, as the participants page's "Send a message"
+     * does for the users selected: one private message each, in one call. They are `userIds`, or the
+     * participants `participants()` chooses with `role`, `group` and `inactiveSince` (all of them when
+     * none is given), the person left out. `sentTo` lists exactly who got it, `refused` who Moodle
+     * didn't write to and why (they blocked the person, their privacy settings); someone who may message
+     * any user (a teacher, `moodle/site:messageanyuser`) gets through a block, as in Moodle's own page
+     * (confirmed empirically, Moodle 5.2). Throws `MessageError`
+     * for an empty message or nobody to write to, `NoParticipantsError` when the person can't see the
+     * course's participants.
+     */
+    messageParticipants(courseId: number, text: string, selection?: import("./areas/messages/messages.js").ParticipantSelection): Promise<{
+        changed: string;
+        sentTo: number[];
+        refused: {
+            userId: number;
+            reason: string;
+        }[];
+    }>;
+    /** The person's own grade report for a course. */
+    myGrades(courseId: number): Promise<import("./areas/grades/user-report.js").GradeRow[]>;
+    /** The person's notifications, newest first, only the unread ones when asked. */
+    notifications(options?: {
+        unreadOnly?: boolean | undefined;
+    }): Promise<import("./areas/messages/messages.js").Notification[]>;
+    /** Opens a Moodle form page and waits for its editors to be ready. */
+    openForm(pathAndQuery: string): Promise<import("playwright-core").Page>;
+    /**
+     * Opens a page of the site (`path` relative to it) in a new tab and checks the session; throws
+     * `NotLoggedInError`, closing the tab, when Moodle answers with its login page.
+     */
+    openSitePage(path: string, options?: {
+        follow?: boolean | undefined;
+    }): Promise<import("playwright-core").Page>;
+    /** Sets someone's completion of an activity as a teacher does from the progress report; returns the state saved. */
+    overrideCompletion(activityId: number, userId: number, state: "incomplete" | "complete" | "complete-pass" | "complete-fail"): Promise<{
+        changed: string;
+        state: "incomplete" | "complete" | "complete-pass" | "complete-fail";
+        overridden: boolean;
+    }>;
+    /**
+     * The roles and groups the participants page filters by in a course (its filters' options), as the
+     * person may use them: every group, or only their own in a course with separate groups. "No roles"
+     * and "no group" left out.
+     */
+    participantFilters(courseId: number): Promise<{
+        roles: {
+            id: number;
+            name: string;
+        }[];
+        groups: {
+            id: number;
+            name: string;
+        }[];
+    }>;
+    /**
+     * A course's participants with their roles and groups, as the participants page lists them: only
+     * those with a role (its id), in a group, or (`inactiveSince`) who haven't accessed the course since
+     * that date, when asked. Each role and group is a filter of its own, so ids come in any language.
+     */
+    participants(courseId: number, options?: {
+        role?: number | undefined;
+        group?: number | undefined;
+        inactiveSince?: Date | undefined;
+    }): Promise<import("./areas/participants/participants.js").Participant[]>;
+    /**
+     * Who took part in an activity of a course, as its participation report counts it: everyone with
+     * the role (every role the report offers, unless `roleId`), with how many actions they made there
+     * (views or posts only, when `action`; since `since`, when given); those who did nothing come with 0.
+     */
+    participationReport(courseId: number, activityId: number, options?: {
+        roleId?: number | undefined;
+        since?: Date | undefined;
+        action?: "view" | "post" | undefined;
+    }): Promise<import("./areas/reports/reports.js").ActivityParticipant[]>;
+    /**
+     * What the person still has to do in a course: activities whose completion is tracked and not
+     * complete or, where completion isn't tracked, graded activities without a grade yet.
+     */
+    pendingActivities(courseId: number): Promise<{
+        completionTracked: boolean;
+        pending: import("./areas/courses/structure.js").PendingActivity[];
+    }>;
+    /**
+     * Users the person may enrol in a course by manual enrolment, matching `search` anywhere in their
+     * name or the identity fields the site shows (all of them, a page of up to 100, when empty), as the
+     * "Enrol users" dialog finds them. Throws `EnrolmentError` when the course has no manual enrolment
+     * the person can use.
+     */
+    potentialUsers(courseId: number, search?: string): Promise<import("./areas/participants/enrolments.js").PotentialUser[]>;
+    /** A course's question banks: its shared ones and the activities' own, as the banks page lists them. */
+    questionBanks(courseId: number): Promise<import("./areas/questions/banks.js").QuestionBank[]>;
+    /** A bank's categories and every question in them, category by category. */
+    questions(activityId: number): Promise<{
+        categories: import("./areas/questions/banks.js").BankCategory[];
+        questions: import("./areas/questions/banks.js").BankQuestion[];
+    }>;
+    /**
+     * The questions of a quiz that wait for grading by hand (essays…), as its manual grading report lists
+     * them, each with the finished attempts whose answer requires grading (from the results report).
+     * People as user id and full name.
+     */
+    questionsToGrade(activityId: number): Promise<{
+        quiz: {
+            id: number;
+        };
+        questions: import("./areas/quizzes/grading.js").QuestionToGrade[];
+    }>;
+    /** A quiz's page as the person sees it: its description and dates, the person's attempts with their summary, and whether they can start one. */
+    quizInfo(activityId: number): Promise<import("./areas/quizzes/attempts.js").QuizInfo>;
+    /**
+     * A quiz's attempts as its grades report shows them: per attempt the user, state, dates, grade and
+     * the mark per question; with `responses`, also the answer per question from the responses report.
+     * Every page of the report.
+     */
+    quizResults(activityId: number, options?: {
+        responses?: boolean | undefined;
+    }): Promise<{
+        quiz: {
+            id: number;
+        };
+        attempts: import("./areas/quizzes/results.js").QuizAttemptResult[];
+    }>;
+    /** A quiz's questions as its edit page lists them: slots with their page, question, type, name and mark, and its sections. */
+    quizStructure(activityId: number): Promise<{
+        quiz: {
+            id: number;
+        };
+        slots: import("./areas/quizzes/structure.js").QuizSlot[];
+        sections: import("./areas/quizzes/structure.js").QuizSection[];
+    }>;
+    /**
+     * Rates a forum post, a glossary entry or a database record as the person, as the rating menu under
+     * it does: by a scale item's name, or its number (the points of a point scale). `null` takes the
+     * person's rating away. Returns a sentence of what changed and the item's aggregate afterwards (as
+     * Moodle shows it, by the activity's aggregation) with the number of ratings. Throws `GradingError`
+     * when the item has no rating menu for the person (ratings off, their own item, outside the
+     * rating period, or no permission) or the rating isn't on its scale.
+     */
+    rate(item: import("./areas/ratings/ratings.js").RateableItem, rating: string | number | null): Promise<{
+        changed: string;
+        aggregate?: string | undefined;
+        count?: number | undefined;
+    }>;
+    /** Every question of an attempt, page by page, with the page each is on. */
+    readAttempt(attemptId: number): Promise<import("./areas/quizzes/attempts.js").Question[]>;
+    /** A finished attempt's review, as far as the quiz's review options let the person see it. */
+    readReview(attemptId: number): Promise<{
+        summary: import("./areas/quizzes/attempts.js").Detail[];
+        questions: import("./areas/quizzes/attempts.js").Question[];
+    }>;
+    /** Removes a slot (by its place, from 1) from a quiz, as the edit page's delete icon does; the question stays in its bank. */
+    removeQuizSlot(activityId: number, slot: number): Promise<import("./areas/quizzes/structure.js").QuizChange>;
+    /** Replies to a post; returns the new post's id and its discussion's. */
+    replyToPost(postId: number, input: import("./areas/forums/posts.js").PostInput & {
+        subject?: string | undefined;
+    }): Promise<{
+        changed: string;
+        postId: number | undefined;
+        discussionId: number | undefined;
+    }>;
+    /**
+     * Resets a course for a new year, as Moodle's reset form does: deletes only what's named in `delete`
+     * (in every module of the course that has it), unenrols the people with `unenrolRoles` (role ids),
+     * moves the course's start date to `start` (and its activities' dates with it), and sets any other of
+     * the form's fields by name (`fields`). Nothing is deleted unless asked: the form's own defaults are
+     * unticked first. It can't be undone. Returns Moodle's report: per component, what it did and its
+     * errors. Needs `moodle/course:reset`.
+     */
+    resetCourse(courseId: number, options: {
+        delete?: import("./areas/courses/reset.js").ResetDeletions | undefined;
+        unenrolRoles?: number[] | undefined;
+        start?: Date | undefined;
+        fields?: Record<string, import("./core/forms.js").FieldValue> | undefined;
+    }): Promise<{
+        changed: string;
+        report: import("./areas/courses/reset.js").ResetStatus[];
+    }>;
+    /**
+     * Restores a backup file (`.mbz`) through Moodle's restore wizard: into a new course in a category
+     * (`into: "new"`, with `categoryId`, which needs `moodle/course:create` there), or into an existing
+     * course (`into: <course id>`), its content added to the course's (`mode: "merge"`, the default) or
+     * replacing it (`"replace"`: the course's content is deleted first). A new course takes the backup's
+     * names unless `fullName` and `shortName` are given. Users' data is restored when `withUsers` and the
+     * backup has it. An asynchronous restore is waited for up to `timeoutMs` (ten minutes). Needs
+     * `moodle/restore:restorecourse` where it restores.
+     */
+    restoreCourse(file: string, options: {
+        into: number | "new";
+        categoryId?: number | undefined;
+        mode?: "merge" | "replace" | undefined;
+        fullName?: string | undefined;
+        shortName?: string | undefined;
+        withUsers?: boolean | undefined;
+        timeoutMs?: number | undefined;
+    }): Promise<{
+        changed: string;
+        course: import("./areas/backup/backup.js").CourseRef;
+    }>;
+    /**
+     * An assignment's grading method and, for a rubric or a marking guide, its criteria with the ids
+     * `gradeSubmission` takes: read from the grader's panel for its first participant.
+     */
+    rubric(activityId: number): Promise<{
+        assignment: {
+            id: number;
+        };
+    } & import("./areas/assignments/grading.js").GradingDefinition>;
+    /** Saves the submission's online text and adds files, as "Save changes" on the edit page does; gives the assignment afterwards. */
+    saveSubmission(activityId: number, input: {
+        onlineText?: string | undefined;
+        files?: string[] | undefined;
+    }): Promise<{
+        changed: string;
+        assignment: import("./areas/assignments/student.js").StudentAssignment;
+    }>;
+    /**
+     * A SCORM activity as the person sees it: its attempts (allowed and made), the grading method, the
+     * grade reported and each attempt's, and its SCOs with the person's status and score in the last
+     * attempt. Moodle doesn't show a SCORM's version on its page: `openScorm` tells it.
+     */
+    scorm(activityId: number): Promise<import("./areas/scorm/scorm.js").ScormActivity>;
+    /** Sends a private message to a user, as the messaging drawer does; returns the message and its conversation. */
+    sendMessage(userId: number, text: string): Promise<{
+        changed: string;
+        messageId: number;
+        conversationId?: number | undefined;
+    }>;
+    /**
+     * Marks the person's own completion of an activity with manual completion, done or not, as its
+     * "Mark as done" button does; doing it twice changes nothing. An activity that completes on its own
+     * gives a `CompletionError`.
+     */
+    setCompletion(activityId: number, done: boolean): Promise<{
+        changed: string;
+    }>;
+    /**
+     * Pins or unpins, locks or unlocks a discussion, as the discussion list's menu does; what's already
+     * so is left alone. Returns the discussion as the forum lists it afterwards.
+     */
+    setDiscussionState(activityId: number, discussionId: number, options: {
+        pinned?: boolean | undefined;
+        locked?: boolean | undefined;
+    }): Promise<{
+        changed: string;
+        discussion?: import("./areas/forums/posts.js").ForumDiscussion | undefined;
+    }>;
+    /**
+     * Sets an enrolment method with its form: by id, or the course's first method of a type
+     * (`{ type: "self" }`), added when the course has none and the "Add method" menu offers it. Only
+     * what's given changes. Returns the method afterwards. Throws `EnrolmentError` for a method the
+     * course doesn't have or can't add, `FormError` with Moodle's reason when it refuses the form (a key
+     * required by the site, an end before the start).
+     */
+    setEnrolmentMethod(courseId: number, method: number | {
+        type: string;
+    }, settings: import("./areas/participants/methods.js").EnrolmentMethodSettings): Promise<{
+        changed: string;
+        method: import("./areas/participants/methods.js").EnrolmentMethod;
+    }>;
+    /**
+     * Sets a person's grade in a grade item through the gradebook's single view report, as a teacher
+     * does there: a manual item takes the grade; an activity's or a category's is overridden (Moodle
+     * keeps the override until it's taken off with `override: false`). Feedback and excluding from
+     * the totals go the same way. Returns a sentence of what changed and the grade afterwards.
+     * Throws `GradebookError` when the item or the person isn't in the course's gradebook, the grade
+     * is locked, or Moodle refuses the value (out of range, a scale item it doesn't have).
+     */
+    setGrade(courseId: number, itemId: number, userId: number, options: import("./areas/grades/singleview.js").SetGradeOptions): Promise<{
+        changed: string;
+        grade: import("./areas/grades/singleview.js").GradebookGrade;
+    }>;
+    /**
+     * Adds and removes a group's members (user ids), as its members page does. Only the course's
+     * participants can be added: ids the page doesn't offer (not enrolled, or already members) and
+     * members not in it are left as they were and named in `changed`. Returns the members afterwards.
+     */
+    setGroupMembers(groupId: number, options: {
+        add?: number[] | undefined;
+        remove?: number[] | undefined;
+    }): Promise<{
+        changed: string;
+        members: number[];
+    }>;
+    /**
+     * Makes a grouping's groups exactly `groupIds`, as its groups page adds and removes them. Groups of
+     * other courses aren't offered there and are left out, named in `changed`. Returns the groups afterwards.
+     */
+    setGroupingGroups(groupingId: number, groupIds: number[]): Promise<{
+        changed: string;
+        groupIds: number[];
+    }>;
+    /** Sets a question ready (quizzes can use it) or draft, as the bank's status menu does, through its service. */
+    setQuestionStatus(questionId: number, status: "ready" | "draft"): Promise<{
+        changed: string;
+        questionId: number;
+        status: "ready" | "draft";
+    }>;
+    /**
+     * Sets a user override on a quiz, through its override form: other opening and closing dates, a time
+     * limit in minutes, or a number of attempts (0 unlimited); what isn't given stays the quiz's.
+     */
+    setQuizOverride(activityId: number, userId: number, options: {
+        open?: Date | undefined;
+        close?: Date | undefined;
+        timeLimitMinutes?: number | undefined;
+        attempts?: number | undefined;
+    }): Promise<{
+        changed: string;
+    }>;
+    /**
+     * Sets a quiz's pages: `perPage` questions a page (0 for all on one), as the edit page's
+     * "Repaginate" does, or page breaks exactly after the given slots (and nowhere else), as its page
+     * break icons do one by one.
+     */
+    setQuizPages(activityId: number, pages: {
+        perPage: number;
+    } | {
+        breaksAfter: number[];
+    }): Promise<import("./areas/quizzes/structure.js").QuizChange>;
+    /**
+     * Sets a user's roles in a course, as the participants page's roles column does: gives the roles in
+     * `roleIds` the person may assign, and takes away the others the person may assign. Roles the person
+     * can't assign that the user already holds, and those from elsewhere (a category, an enrolment that
+     * protects them), stay. Returns the user's roles afterwards, as that column shows them. Throws
+     * `EnrolmentError` with Moodle's reason for a role the person can't assign or a user not enrolled.
+     */
+    setUserRoles(courseId: number, userId: number, roleIds: number[]): Promise<{
+        changed: string;
+        roleIds: number[];
+    }>;
+    /**
+     * Sets the marking workflow state of participants' submissions, as the grading table's "Set marking
+     * workflow state" does; "released" shows them their grades, notifying them when `notify` is true
+     * (the form's default is not to). With several markers, it sets the submission's overall state.
+     */
+    setWorkflowState(activityId: number, userIds: number[], state: "inmarking" | "readyforreview" | "inreview" | "readyforrelease" | "released", options?: {
+        notify?: boolean | undefined;
+    }): Promise<{
+        changed: string;
+    }>;
+    /**
+     * Switches a workshop to a phase, as its page's phase links do, confirming Moodle's question (any
+     * phase, forwards or back; Moodle allocates nothing and calculates no grades on its own when it
+     * switches). Returns a sentence of what changed and the phase afterwards. Throws `WorkshopError` when
+     * the person can't switch the workshop's phases (Moodle's `mod/workshop:switchphase`, a teacher's) or
+     * the id isn't a workshop's.
+     */
+    setWorkshopPhase(activityId: number, phase: import("./areas/workshops/workshops.js").WorkshopPhase): Promise<{
+        changed: string;
+        phase: import("./areas/workshops/workshops.js").WorkshopPhase;
+    }>;
+    /** The site's name, from its public settings; `undefined` where the mobile app support is off. */
+    siteName(): Promise<string | undefined>;
+    /** Starts a discussion in a forum; returns its id. */
+    startDiscussion(activityId: number, input: import("./areas/forums/posts.js").PostInput & {
+        subject: string;
+    }): Promise<{
+        changed: string;
+        discussionId: number | undefined;
+    }>;
+    /** Starts an attempt, or continues the one in progress, and gives its questions. */
+    startQuizAttempt(activityId: number): Promise<{
+        changed: string;
+        attemptId: number;
+        questions: import("./areas/quizzes/attempts.js").Question[];
+    }>;
+    /** An assignment as the student sees it: its description and files, dates, the submission's status and files, the feedback, and whether it can be edited or submitted now. */
+    studentAssignment(activityId: number): Promise<import("./areas/assignments/student.js").StudentAssignment>;
+    /**
+     * Submits the saved submission for grading, accepting the site's statement when it asks for one
+     * (`acceptStatement`, once the person agrees; a bare boolean as before 0.2 too); gives the
+     * assignment afterwards.
+     */
+    submitForGrading(activityId: number, options?: boolean | {
+        acceptStatement?: boolean | undefined;
+    }): Promise<{
+        changed: string;
+        assignment: import("./areas/assignments/student.js").StudentAssignment;
+    }>;
+    /**
+     * Fills the survey page by page with `responses` (field name → value) and submits it on the last
+     * page. Every name is checked against the form first, so nothing is sent with a wrong one.
+     */
+    submitSurvey(activityId: number, type: import("./areas/surveys/surveys.js").SurveyType, responses: Record<string, string>): Promise<{
+        changed: string;
+        messages: string[];
+    }>;
+    /**
+     * Fills the survey page by page with `responses` (field name → value) and submits it on the last
+     * page. Every name is checked against the form first, so nothing is sent with a wrong one.
+     */
+    submitSurvey(activityId: number, responses: Record<string, string>, options?: {
+        type?: import("./areas/surveys/surveys.js").SurveyType | undefined;
+    }): Promise<{
+        changed: string;
+        messages: string[];
+    }>;
+    /**
+     * Unenrols a user from a course: removes every enrolment of theirs the person may remove (its
+     * unenrol link on the participants page), with their roles and group memberships in the course, as
+     * that link does. `changed` and `removed` say which ones (by enrolment method's name), `kept` those
+     * the person may not remove (a cohort sync, another teacher's method). Throws `EnrolmentError` when
+     * the user isn't enrolled.
+     */
+    unenrolUser(courseId: number, userId: number): Promise<{
+        changed: string;
+        removed: string[];
+        kept: string[];
+    }>;
+    /** The person's upcoming events, as the calendar's "Upcoming events" view lists them, in one course or all. */
+    upcomingEvents(options?: {
+        courseId?: number | undefined;
+    }): Promise<import("./areas/calendar/calendar.js").CalendarEvent[]>;
+    /**
+     * Changes an existing activity through its form: only what's given changes. A file resource's or
+     * folder's files stay as they are unless `files` says what to add, remove or replace.
+     */
+    updateActivity(activityId: number, input: import("./areas/activities/build.js").ActivityFields & {
+        files?: import("./areas/activities/build.js").FileChanges | undefined;
+    }): Promise<import("./areas/activities/build.js").CourseChange>;
+    /**
+     * Changes a course's full name, short name, summary (HTML) or any other setting by its form field
+     * name, through the course's settings form; returns the course as `listCourses` gives it. Moodle's
+     * refusals (a short name already taken) come back as `FormError` by field.
+     */
+    updateCourse(courseId: number, options: {
+        fullName?: string | undefined;
+        shortName?: string | undefined;
+        summary?: string | undefined;
+        settings?: Record<string, import("./core/forms.js").FieldValue> | undefined;
+    }): Promise<{
+        changed: string;
+        course?: import("./areas/courses/list.js").Course | undefined;
+    }>;
+    /**
+     * Changes a calendar event through the calendar's own form, opened on it: only what's given
+     * changes. A new start keeps the event's length unless a new one is given. Returns the event as the
+     * calendar has it afterwards.
+     */
+    updateEvent(eventId: number, changes: import("./areas/calendar/calendar.js").EventChanges): Promise<{
+        changed: string;
+        event: import("./areas/calendar/calendar.js").CalendarEvent;
+    }>;
+    /**
+     * Changes a grade category: its name, its aggregation, its weight in its parent (percent, overriding
+     * Natural's automatic one), or moves it into another category. Returns the category afterwards.
+     */
+    updateGradeCategory(courseId: number, categoryId: number, options: {
+        name?: string | undefined;
+        aggregation?: "mean" | "median" | "lowest" | "highest" | "mode" | "weighted-mean" | "simple-weighted-mean" | "mean-with-extra-credits" | "natural" | undefined;
+        weight?: number | undefined;
+        parentId?: number | undefined;
+    }): Promise<{
+        changed: string;
+        category?: import("./areas/grades/gradebook.js").GradebookCategory | undefined;
+    }>;
+    /**
+     * Changes a grade item: moves it into a category, sets its weight (percent, overriding Natural's
+     * automatic one), or its maximum grade (a manual item's; an activity's is set in the activity).
+     * Returns the item afterwards.
+     */
+    updateGradeItem(courseId: number, itemId: number, options: {
+        category?: number | undefined;
+        weight?: number | undefined;
+        maxGrade?: number | undefined;
+    }): Promise<{
+        changed: string;
+        item?: import("./areas/grades/gradebook.js").GradebookItem | undefined;
+    }>;
+    /** Changes a group's name, description, ID number or enrolment key with its form; what isn't given stays. */
+    updateGroup(groupId: number, settings: import("./areas/participants/groups.js").GroupSettings): Promise<{
+        changed: string;
+    }>;
+    /**
+     * Changes a question of a bank through its type's edit form, with the same inputs as
+     * `createQuestion` and only what's given (`answers` replaces them all). Saving makes a new version
+     * of the question, with an id of its own: the one returned, which quizzes using the latest version
+     * get from then on.
+     */
+    updateQuestion(activityId: number, questionId: number, input: Partial<Omit<import("./areas/questions/banks.js").QuestionInput, "type">>): Promise<{
+        changed: string;
+        questionId?: number | undefined;
+    }>;
+    /**
+     * A user by id, or `undefined` when there's nobody: no such user, one the person may not see, or a
+     * deleted account. Moodle keeps a deleted account's record and its user service still gives it to an
+     * administrator, renamed, with the email replaced by an MD5 hash of the old username (`delete_user`,
+     * confirmed empirically on the sandbox, 5.2); the driver treats it as gone.
+     */
+    userById(userId: number): Promise<import("./areas/site/users.js").User | undefined>;
+    /** Who the logged-in person is; with `courseId`, also their roles and abilities in that course. */
+    whoAmI(courseId?: number): Promise<import("./areas/site/users.js").Me>;
+    /**
+     * A workshop's phase, and its report as the workshop's page shows it to a teacher: every submission
+     * (its author, title, and grade once calculated) and every assessment (reviewer, the submission's
+     * author, the grade it gives, its weight, the grade for assessing once calculated), all of its pages.
+     * The report is Moodle's own: it shows from the submission phase on to those who can see every
+     * submission, in the course's current group; for anyone else the lists are empty. Grades are out of
+     * the workshop's grade for submission, as Moodle shows them. Throws `WorkshopError` for an activity
+     * that isn't a workshop the person can view.
+     */
+    workshopInfo(activityId: number): Promise<import("./areas/workshops/workshops.js").WorkshopInfo>;
+}