types-mediawiki-response 1.0.0-alpha.1

package/dist/extensions/discussiontools.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Opt-in extension pack: **DiscussionTools**
+ * (`action=discussiontoolspageinfo`, `action=discussiontoolsfindcomment`,
+ * `action=discussiontoolsgetsubscriptions`, `action=discussiontoolssubscribe`,
+ * `action=discussiontoolsthank`, `action=discussiontoolscompare`,
+ * `action=discussiontoolspreview`, `action=discussiontoolsedit`).
+ *
+ * Not in the default export. These are standalone action responses — import what
+ * you need directly:
+ *
+ * ```ts
+ * import type { ApiDiscussionToolsPageInfoResponse } from 'types-mediawiki-response/ext/discussiontools';
+ * ```
+ *
+ * Nothing here merges into `ApiPage`/`ApiQueryResult`: most modules write a
+ * root-level key named after themselves (`discussiontoolspageinfo`,
+ * `discussiontoolsedit`, …). Two exceptions: `discussiontoolsgetsubscriptions`
+ * writes a root-level `subscriptions` map, and `discussiontoolsthank` writes a
+ * root-level `result` — the same shape as `action=thank` from the Thanks
+ * extension.
+ *
+ * Comments are addressed by a generated `id` (`h-<slug>-<timestamp>` for a topic
+ * heading, `c-<user>-<timestamp>` for a comment) and a `name` (`h-<user>-<timestamp>`
+ * for a topic, where `<user>` is the thread starter; `c-<user>-<timestamp>` for a
+ * comment); `findcomment` resolves either into both fields, which is the reliable
+ * way to obtain them. Replies nest arbitrarily deep under `replies`.
+ *
+ * @see https://www.mediawiki.org/wiki/Extension:DiscussionTools
+ */
+import type { Flag, Timestamp } from "../common";
+import type { ApiEnvelope } from "../envelope";
+import type { ApiParse } from "../core/parse";
+import type { ApiThankResult } from "./thanks";
+import type { ApiLastModified } from "./visualeditor";
+/** One node of a reply/indent tree (`prop=threaditemshtml`). */
+export interface ApiDiscussionToolsComment {
+    /** Comment id, e.g. `h-Example_topic-20240115083000`. */
+    id: string;
+    /**
+     * Comment name — headings only (`h-<user>-<timestamp>`, where `<user>` is
+     * the thread starter, or bare `h-` for an empty section); comment items do
+     * not serialize a name.
+     */
+    name?: string;
+    /** Rendering level of the heading (`0` for the topic itself). */
+    level?: number;
+    /** Heading level as written in wikitext (`==` → 2), headings only; `null` for placeholder headings. */
+    headingLevel?: number | null;
+    /**
+     * The heading opens a section that cannot be edited here (no edit-section
+     * link was rendered); headings only.
+     */
+    uneditableSection?: Flag;
+    /** Who wrote the comment. */
+    author?: string;
+    /** Display name shown in the signature, when it differs from {@link author}. */
+    displayName?: string;
+    /** When it was signed. */
+    timestamp?: Timestamp;
+    /** Comment type, e.g. `comment`, `heading`. Open union. */
+    type: string;
+    /** Rendered HTML of this comment. */
+    html?: string;
+    /** HTML of the content between an empty section's heading and the next one; headings only. */
+    othercontent?: string;
+    /** Nested replies (same shape, recursively). */
+    replies?: ApiDiscussionToolsComment[];
+    /**
+     * Number of comments below this heading. Headings only
+     * (`prop=threaditemshtml`).
+     *
+     * @since MediaWiki 1.45
+     */
+    commentCount?: number;
+    /**
+     * Distinct authors below this heading. Headings only.
+     *
+     * @since MediaWiki 1.45
+     */
+    authorCount?: number;
+    /**
+     * Timestamp of the latest reply under this heading, or `null` when there is
+     * none. Headings only.
+     *
+     * @since MediaWiki 1.45
+     */
+    latestReplyTimestamp?: Timestamp | null;
+    /**
+     * The most recent reply, serialized as a comment item without its `replies`;
+     * `null` when there is none. Headings only, and only with
+     * `threaditemsflags=activity` (alongside `prop=threaditemshtml`).
+     *
+     * @since MediaWiki 1.46
+     */
+    latestReply?: ApiDiscussionToolsComment | null;
+    /**
+     * The earliest reply, same serialization as {@link latestReply}; `null` when
+     * there is none. Headings only, and only with `threaditemsflags=activity`
+     * (alongside `prop=threaditemshtml`).
+     *
+     * @since MediaWiki 1.46
+     */
+    oldestReply?: ApiDiscussionToolsComment | null;
+}
+/**
+ * `prop=transcludedfrom`: whether each comment is a transclusion target here.
+ * Keyed by comment id **and** name; `false` when the content is local, `true`
+ * when transcluded but the source could not be determined, otherwise the
+ * source page title.
+ */
+export interface ApiDiscussionToolsTranscludedFrom {
+    [commentIdOrName: string]: boolean | string | undefined;
+}
+/** Response of `action=discussiontoolspageinfo`. */
+export interface ApiDiscussionToolsPageInfoResponse extends ApiEnvelope {
+    discussiontoolspageinfo: {
+        /** Parsed reply tree. `prop=threaditemshtml`. */
+        threaditemshtml?: ApiDiscussionToolsComment[];
+        /** Per-comment transclusion map (local vs transcluded, with source title). `prop=transcludedfrom`. */
+        transcludedfrom?: ApiDiscussionToolsTranscludedFrom;
+    };
+}
+/** One candidate returned by `action=discussiontoolsfindcomment`. */
+export interface ApiDiscussionToolsFoundComment {
+    /** Canonical comment id. */
+    id: string;
+    /** Canonical comment name. */
+    name: string;
+    /** Page the comment lives on. */
+    title: string;
+    /** Revision id of the permalink; `null` when the revision is the current one. */
+    oldid: number | null;
+    /** How the lookup matched: `id`, `name` or `heading`. */
+    matchedby: "id" | "name" | "heading" | (string & {});
+    /**
+     * Whether the request could be redirected to a permalink. Absent in the 1.41
+     * `findcomment` release, which unset it; emitted from 1.42.
+     *
+     * @since MediaWiki 1.42
+     */
+    couldredirect?: boolean;
+    /**
+     * Whether it should be (the target differs from what was asked).
+     *
+     * @since MediaWiki 1.41
+     */
+    shouldredirect?: boolean;
+}
+/** Response of `action=discussiontoolsfindcomment` (a list of candidates). */
+export interface ApiDiscussionToolsFindCommentResponse extends ApiEnvelope {
+    discussiontoolsfindcomment: ApiDiscussionToolsFoundComment[];
+}
+/**
+ * Response of `action=discussiontoolsgetsubscriptions`. The map is keyed by
+ * comment **name** (the same strings as the `commentname` request parameter);
+ * each value is `0` (unsubscribed), `1` (subscribed) or `2` (auto-subscribed)
+ * — numeric, not boolean, because the underlying column is.
+ */
+export interface ApiDiscussionToolsGetSubscriptionsResponse extends ApiEnvelope {
+    subscriptions: Record<string, number>;
+}
+/** Response of `action=discussiontoolssubscribe`. */
+export interface ApiDiscussionToolsSubscribeResponse extends ApiEnvelope {
+    discussiontoolssubscribe: {
+        /** Page the comment is on. */
+        page: string;
+        /** Canonical comment name the subscription applies to. */
+        commentname: string;
+        /** Requested state, echoed back. */
+        subscribe: boolean;
+    };
+}
+/**
+ * Response of `action=discussiontoolsthank`. The module inherits the Thanks
+ * extension's result: a root-level `result` key, not one named after the
+ * module.
+ */
+export interface ApiDiscussionToolsThankResponse extends ApiEnvelope {
+    /** The thanks result, the same shape as `action=thank` ({@link ApiThankResult}). */
+    result?: ApiThankResult;
+}
+/**
+ * One comment item in a `discussiontoolscompare` diff: the thread-item shape
+ * (see `ApiDiscussionToolsComment`) with `replies` flattened to comment ids
+ * and the heading references appended.
+ */
+export interface ApiDiscussionToolsCommentForDiff {
+    /** Comment id. */
+    id?: string;
+    /** Comment type, e.g. `comment`. */
+    type?: string;
+    /** Rendering level. */
+    level?: number;
+    /** Ids of nested replies (shallow serialization). */
+    replies?: string[];
+    /** When it was signed — the compact id/name timestamp form (`YYYYMMDDHHMMSS`); comments predating 2022-07 are ISO 8601 instead. */
+    timestamp?: Timestamp;
+    /** Who wrote the comment. */
+    author?: string;
+    /** Id of the heading the comment sits under. */
+    headingId?: string;
+    /** Id of the nearest subscribable heading; `null` when there is none. */
+    subscribableHeadingId?: string | null;
+}
+/** Response of `action=discussiontoolscompare` (comment-level diff of two revisions). */
+export interface ApiDiscussionToolsCompareResponse extends ApiEnvelope {
+    discussiontoolscompare: {
+        /** Left revision id. */
+        fromrevid?: number;
+        /** Page title of the left revision. */
+        fromtitle?: string;
+        /** Right revision id. */
+        torevid?: number;
+        /** Page title of the right revision. */
+        totitle?: string;
+        /** Comments present only in the left revision. */
+        removedcomments?: ApiDiscussionToolsCommentForDiff[];
+        /** Comments present only in the right revision. */
+        addedcomments?: ApiDiscussionToolsCommentForDiff[];
+    };
+}
+/** Response of `action=discussiontoolspreview`. */
+export interface ApiDiscussionToolsPreviewResponse extends ApiEnvelope {
+    discussiontoolspreview: {
+        /** The parsed preview, same shape as an `action=parse` payload. */
+        parse?: ApiParse;
+    };
+}
+/** Response of `action=discussiontoolsedit`. */
+export interface ApiDiscussionToolsEditResponse extends ApiEnvelope {
+    discussiontoolsedit: {
+        /** `success` when the comment was saved. */
+        result?: "success" | (string & {});
+        /** Rendered HTML of the saved comment area. */
+        content?: string;
+        /**
+         * `true` when the content above was withheld (the `nocontent` request
+         * parameter) but had to be fetched internally anyway.
+         *
+         * @since MediaWiki 1.42
+         */
+        nocontent?: Flag;
+        /** Page subtitle (parsed HTML), copied from the underlying `action=parse` output. */
+        contentSub?: string;
+        /** Category HTML added by the saved comment. */
+        categorieshtml?: string;
+        /** Section list after the edit. */
+        sections?: unknown[];
+        /** Display title, HTML form. */
+        displayTitleHtml?: string;
+        /** ResourceLoader module names to load. */
+        modules?: string[];
+        /** ResourceLoader config variables (includes the thread model). */
+        jsconfigvars?: Record<string, unknown>;
+        /**
+         * Empty string for a normal page. The module copies `action=parse`'s field,
+         * which is a `Flag`-like empty string under fv2 rather than a boolean.
+         */
+        isRedirect?: string;
+        /** When the page last changed, in display parts. */
+        lastModified?: ApiLastModified;
+        /** New revision id; absent when nothing was saved. */
+        newrevid?: number;
+        /** `true` when a temporary account was created by this edit. */
+        tempusercreated?: Flag;
+        /** Redirect URL for a just-created temporary account, when one applies. */
+        tempusercreatedredirect?: string;
+        /** Whether the user now watches the page. */
+        watched?: boolean;
+        /** When that watch expires; `null` for a permanent watch. */
+        watchlistexpiry?: Timestamp | null;
+    };
+}

package/dist/extensions/echo.d.ts

@@ -0,0 +1,306 @@
+/**
+ * Opt-in extension pack: **Echo / Notifications** (`meta=notifications`,
+ * `meta=unreadnotificationpages`, `action=echomute`, `action=echocreateevent`,
+ * `action=echoarticlereminder`, `action=echopushsubscriptions`).
+ * `echomarkread`/`echomarkseen` are top-level actions (not `meta=` modules)
+ * that report their result under `query`.
+ *
+ * Not in the default export: importing anything from this file — even just the
+ * field-group type you are about to use — activates the augmentation shipped at
+ * the bottom, which merges the field groups into the root package automatically
+ * (no manual `declare module`):
+ *
+ * ```ts
+ * import type {} from 'types-mediawiki-response/ext/echo';
+ * ```
+ *
+ * The `action=` responses (`echomute`, `echocreateevent`) are standalone — import them by name.
+ *
+ * `ApiEchoNotification` is one notification row; the unread counts (localized
+ * `count` string next to numeric `rawcount`) live on the result objects and on
+ * the `echomarkread` response.
+ * `ApiEchoMarkSeen` returns the server "all seen" timestamp. Pass
+ * `timestampformat=ISO_8601` to avoid the deprecated MW-timestamp format.
+ *
+ * fv2 notes worth knowing: `count` is a **localized string** while `rawcount` is a
+ * number; `notifications.continue` is explicitly `null` when there is nothing left
+ * to page through (not an omitted key); with `notgroupbysection=1` the result is
+ * keyed by `alert`/`message` instead of carrying a flat `list`; and
+ * `notformat=model` replaces the rendered strings with a structured
+ * {@link ApiEchoNotificationModel} body.
+ *
+ * @see https://www.mediawiki.org/wiki/Extension:Echo
+ */
+import type { NamespaceIndex, Timestamp } from "../common";
+import type { ApiEnvelope } from "../envelope";
+/** A notification count: numeric `rawcount` plus a localized `count` string. */
+export interface ApiEchoNotificationCount {
+    /** Raw numeric count. */
+    rawcount: number;
+    /** Count formatted for display (a string; e.g. `"0"`, `"1,234"`). */
+    count: string;
+}
+/** The `echomarkread` object (returned under `query` by `action=echomarkread`). */
+export interface ApiQueryEchoMarkRead {
+    /** Echo status string; `success` on completion. */
+    result: "success" | (string & {});
+    /** Per-wiki error from a failed foreign (cross-wiki) subrequest. */
+    errors?: {
+        [wiki: string]: {
+            code?: string;
+            info?: string;
+            [key: string]: unknown;
+        };
+    };
+    /** Remaining unread `alert`-section count. */
+    alert: ApiEchoNotificationCount;
+    /** Remaining unread `message`-section count. */
+    message: ApiEchoNotificationCount;
+    /** Overall remaining unread count. */
+    rawcount: number;
+    /** Overall remaining unread count, formatted. */
+    count: string;
+}
+/** The `echomarkseen` object (returned under `query` by `action=echomarkseen`). */
+export interface ApiQueryEchoMarkSeen {
+    /** Echo status string; `success` on completion. */
+    result?: "success" | (string & {});
+    /** The "all notifications seen" timestamp just recorded. */
+    timestamp?: Timestamp;
+}
+/** Every timestamp form Echo attaches to a notification (`timestamp=` object). */
+export interface ApiEchoTimestamp {
+    /** ISO 8601 (UTC), e.g. `2024-01-15T08:30:00Z`. */
+    utciso8601?: Timestamp;
+    /** Unix epoch seconds as a number. */
+    utcunix?: number;
+    /** Unix epoch seconds as a **string**, in the receiving user's local timezone ({@link utcunix} is UTC). */
+    unix?: string;
+    /** MediaWiki 14-digit timestamp. */
+    utcmw?: string;
+    /** MediaWiki 14-digit timestamp in the user's local timezone (`utcmw` is the UTC one). */
+    mw?: string;
+    /**
+     * Localized date-group header: `Today`/`Yesterday`, or a pretty date such as
+     * `May 10` for notifications older than 48 hours.
+     */
+    date?: string;
+}
+/** The title of the page a notification points at. */
+export interface ApiEchoTitle {
+    /** Full title with namespace prefix. */
+    full?: string;
+    /** Localized namespace prefix (`""` in the main namespace). */
+    namespace?: string;
+    /** Namespace index; hyphenated key, spelled literally. */
+    "namespace-key"?: number;
+    /** Title without the namespace prefix. */
+    text?: string;
+}
+/** The user whose action triggered a notification. */
+export interface ApiEchoAgent {
+    /** User id. */
+    id?: number;
+    /** User name. */
+    name?: string;
+    /**
+     * Suppression marker: when the agent's identity is hidden, the agent object
+     * collapses to `{ userhidden: "" }` and carries no other keys.
+     */
+    userhidden?: "";
+}
+/** One link attached to a model-format notification. */
+export interface ApiEchoNotificationLink {
+    /** Link text. */
+    label?: string;
+    /** Target URL. */
+    url?: string;
+}
+/** Structured payload a notification's presenter exposes (`notformat=model`). */
+export interface ApiEchoNotificationModel {
+    /** Rendered body HTML. */
+    body?: string;
+    /** Short header line. */
+    header?: string;
+    /** Condensed header for the flyout. */
+    compactHeader?: string;
+    /** Icon name from the Echo icon registry. */
+    icon?: string;
+    /** Icon URL. */
+    iconUrl: string;
+    /** Primary/secondary action links. Open: extensions add their own keys. */
+    links?: {
+        primary?: ApiEchoNotificationLink;
+        secondary?: ApiEchoNotificationLink[];
+        [key: string]: unknown;
+    };
+    /** Presenter-specific extras (bundled notifications, watch titles, …). */
+    [key: string]: unknown;
+}
+/** One notification row (`meta=notifications`, `notprop=list`). */
+export interface ApiEchoNotification {
+    /** Wiki the notification came from — cross-wiki notifications carry other sites. */
+    wiki?: string;
+    /** Notification id; feed it back to `action=echomarkread` or `action=echomute`. */
+    id?: number;
+    /** Event type, e.g. `mention`, `thank-you-edit`, `page-linked`. Open union. */
+    type?: string;
+    /** Event category, usually mirrors {@link type}. */
+    category?: string;
+    /** Section the notification lives in. */
+    section?: "alert" | "message" | (string & {});
+    /** Timestamp in every form Echo publishes. */
+    timestamp?: ApiEchoTimestamp;
+    /** Ids of the notifications bundled into this one (bundled notifications present). */
+    bundledIds?: number[];
+    /** Presentation variant of the event, when the event carries one. */
+    variant?: string;
+    /** Target page of the notification. */
+    title?: ApiEchoTitle;
+    /** Actor that triggered it. */
+    agent?: ApiEchoAgent;
+    /** Revision id associated with the event. */
+    revid?: number;
+    /** When the notification was marked read (MediaWiki 14-digit timestamp). */
+    read?: string;
+    /** Page ids the notification targets (empty array when there are none). */
+    targetpages?: number[];
+    /**
+     * Rendered notification body, present whenever `notformat` is given. The
+     * shape depends on the format: `model` returns a structured
+     * {@link ApiEchoNotificationModel} object, the other formats (`special`,
+     * plus the deprecated `flyout`/`html`) return an HTML string.
+     */
+    "*"?: ApiEchoNotificationModel | string;
+    /**
+     * The notifications bundled into this one, formatted like the parent row
+     * (expandable bundles; requires `notformat`).
+     */
+    bundledNotifications?: ApiEchoNotification[];
+}
+/** A `count` / `list` slice, either flat or grouped per section. */
+export interface ApiEchoNotificationSection {
+    /** Notification rows. */
+    list?: ApiEchoNotification[];
+    /** Continue cursor for this section, or `null` when the list is complete. */
+    continue?: string | null;
+    /** Raw numeric unread count. */
+    rawcount?: number;
+    /** Unread count formatted for display. */
+    count?: string;
+    /**
+     * Last-seen timestamp. At the top level of `notifications` (flat mode) this
+     * is a map keyed by section name; inside a per-section object (grouped mode,
+     * `notgroupbysection=1`) it is a single ISO timestamp.
+     */
+    seenTime?: Timestamp | Record<string, Timestamp>;
+}
+/** The `notifications` object (returned under `query` by `meta=notifications`). */
+export interface ApiQueryEchoNotifications extends ApiEchoNotificationSection {
+    /**
+     * Per-section results, present only with `notgroupbysection=1` — then
+     * {@link ApiEchoNotificationSection.list} sits inside each section instead.
+     */
+    alert?: ApiEchoNotificationSection;
+    /** Message-section grouping; see {@link alert}. */
+    message?: ApiEchoNotificationSection;
+}
+/** One wiki's unread-notification summary inside `unreadnotificationpages`. */
+export interface ApiEchoUnreadSource {
+    /** Article-path base of the source wiki. */
+    base?: string;
+    /** URL of the source wiki's `api.php` endpoint. */
+    url?: string;
+    /** Display name of the source wiki (localized project name, sitename fallback). */
+    title?: string;
+}
+/** Per-wiki unread summary keyed by page title. */
+export interface ApiEchoUnreadPage {
+    /**
+     * Page title; `null` for the pseudo-row aggregating notifications not tied
+     * to any page (only appears with `unpgrouppages` off).
+     */
+    title?: string | null;
+    /** Namespace index (only with `unpgrouppages`). */
+    ns?: NamespaceIndex;
+    /** Title without the namespace prefix (only with `unpgrouppages`). */
+    unprefixed?: string;
+    /**
+     * Subject- and talk-page titles this count covers (only with
+     * `unpgrouppages`); contains `null` for the requesting user's own page.
+     */
+    pages?: (string | null)[];
+    /** Unread notifications for this page. */
+    count?: number;
+}
+/** One wiki's entry in `meta=unreadnotificationpages` (keyed by wiki id). */
+export interface ApiEchoUnreadWiki {
+    /** Where the notifications came from. */
+    source?: ApiEchoUnreadSource;
+    /** Per-page unread counts. */
+    pages?: ApiEchoUnreadPage[];
+    /**
+     * Total unread notifications on the wiki (badge-count semantics, capped at
+     * the notifications-badge limit); not the sum of {@link ApiEchoUnreadPage.count}.
+     */
+    totalCount?: number;
+}
+/**
+ * The `unreadnotificationpages` object: a map from wiki id (e.g.
+ * `mediawikiwiki`) to that wiki's unread summary. A PHP map, so an empty result
+ * serializes as `[]`.
+ */
+export interface ApiQueryEchoUnreadPages {
+    [wikiId: string]: ApiEchoUnreadWiki | unknown[] | undefined;
+}
+/**
+ * Response of `action=echomute`. The module writes a plain status **string**
+ * (no wrapper object): `success` after muting or unmuting.
+ */
+export interface ApiEchoMuteResponse extends ApiEnvelope {
+    echomute: "success" | (string & {});
+}
+/**
+ * Response of `action=echocreateevent`. Shape of the `ApiEchoCreateEvent`
+ * module (off by default — `$wgEchoEnableApiEvents`).
+ *
+ * @since MediaWiki 1.43
+ */
+export interface ApiEchoCreateEventResponse extends ApiEnvelope {
+    echocreateevent: {
+        /** `success` when the event was stored. */
+        result?: "success" | (string & {});
+    };
+}
+/**
+ * The `echoarticlereminder` object (returned under `query`). The module is
+ * only registered when `$wgAllowArticleReminderNotification` is on.
+ */
+export interface ApiQueryEchoArticleReminder {
+    /** `success` when the reminder was scheduled. */
+    result?: "success" | (string & {});
+}
+/**
+ * Responses of `action=echopushsubscriptions`: the `command` value is the
+ * response key (`create` or `delete`). The module is experimental and only
+ * registered when `$wgEchoEnablePush` is on.
+ */
+export interface ApiEchoPushSubscriptionsResponse extends ApiEnvelope {
+    /** `command=create` — the subscription was stored. */
+    create?: {
+        result?: "Success" | (string & {});
+    };
+    /** `command=delete` — the subscription was removed. */
+    delete?: {
+        result?: "Success" | (string & {});
+    };
+}
+declare module "types-mediawiki-response" {
+    interface ApiQueryResult {
+        notifications?: ApiQueryEchoNotifications;
+        unreadnotificationpages?: ApiQueryEchoUnreadPages;
+        echomarkread?: ApiQueryEchoMarkRead;
+        echomarkseen?: ApiQueryEchoMarkSeen;
+        echoarticlereminder?: ApiQueryEchoArticleReminder;
+    }
+}

package/dist/extensions/extracts.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Opt-in extension pack: **TextExtracts** (`prop=extracts`).
+ *
+ * Not in the default export: importing anything from this file — even just the
+ * field-group type you are about to use — activates the augmentation shipped at
+ * the bottom, which merges the field groups into the root package automatically
+ * (no manual `declare module`):
+ *
+ * ```ts
+ * import type {} from 'types-mediawiki-response/ext/extracts';
+ * ```
+ *
+ * `exintro` limits to the intro, `explaintext` returns plain text (else HTML).
+ *
+ * @see https://www.mediawiki.org/wiki/Extension:TextExtracts
+ */
+import type { PlainText } from "../common";
+/** A page content extract ({@link PlainText} with `explaintext`, else HTML). */
+export type ApiExtract = PlainText;
+declare module "types-mediawiki-response" {
+    interface ApiPage {
+        extract?: ApiExtract;
+    }
+}