types-mediawiki-response 1.0.0-alpha.1

package/dist/core/watch.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `action=watch` response — adds/removes pages from the watchlist; needs CSRF.
+ * The result is a top-level `watch` **array** (one entry per title) in pageset
+ * mode (`titles`/`pageids`/`revids`), a **single object** with the legacy
+ * `title` parameter. Requires the `watch` token (`meta=tokens&type=watch`).
+ *
+ * @see https://www.mediawiki.org/wiki/API:Watch
+ */
+import type { ApiWatchlistLabel, NamespaceIndex, Timestamp, ApiSpecMessage } from "../common";
+import type { ApiEnvelope } from "../envelope";
+/** One watched/unwatched page. */
+export interface ApiWatchEntry {
+    /** Page title. */
+    title: string;
+    /** Namespace index. */
+    ns: NamespaceIndex;
+    /** The page was added to the watchlist. A real `boolean`. */
+    watched?: boolean;
+    /** The page was removed from the watchlist. A real `boolean`. */
+    unwatched?: boolean;
+    /**
+     * The page is not watchable — always `0`; `watched`/`unwatched` are absent.
+     */
+    watchable?: 0;
+    /**
+     * Expiry applied to the watch (`expiry` parameter echo, formatted by
+     * `ApiResult::formatExpiry`). Watch direction only.
+     */
+    expiry?: Timestamp | "infinity";
+    /** In-band messages when the watch/unwatch operation failed (pageset mode; the legacy `title` mode dies with a top-level error instead). */
+    errors?: ApiSpecMessage[];
+    /** In-band warnings for a failed operation (present when non-empty). */
+    warnings?: ApiSpecMessage[];
+    /**
+     * Watchlist labels just saved for this page, echoed back when the request
+     * passed `labels` and `$wgEnableWatchlistLabels` is on.
+     *
+     * @since MediaWiki 1.46
+     */
+    labels?: ApiWatchlistLabel[];
+}
+/** Response of `action=watch`. */
+export interface ApiWatchResponse extends ApiEnvelope {
+    watch: ApiWatchEntry | ApiWatchEntry[];
+}

package/dist/envelope/index.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Core response envelope types shared by all MediaWiki Action API responses.
+ *
+ * Note: this package models responses requested with `formatversion=2`
+ * unless explicitly documented otherwise.
+ *
+ * The error/warning shape depends on the request's `errorformat`:
+ * - default (`bc`): a single `error` object and a module-keyed `warnings` object;
+ * - modern (`plaintext`/`wikitext`/`html`/`raw`/`none`): an `errors` array and a
+ *   `warnings` array of message objects, plus a top-level `docref`.
+ *
+ * @see https://www.mediawiki.org/wiki/API:Errors_and_warnings
+ */
+/**
+ * A single message under a modern `errorformat` (an entry of the `errors` or
+ * `warnings` array). Which text-bearing field is present depends on the
+ * format: `text` for `plaintext`/`wikitext`, `html` for `html`, `key`/`params`
+ * for `raw`.
+ */
+export interface ApiMessage {
+    /** Machine-readable code, e.g. `badvalue`, `unrecognizedparams`. */
+    code?: string;
+    /** Rendered message (`errorformat=plaintext`/`wikitext`). */
+    text?: string;
+    /** Parsed message HTML (`errorformat=html`). */
+    html?: string;
+    /** i18n message key (`errorformat=raw`). */
+    key?: string;
+    /**
+     * i18n message parameters (`errorformat=raw`). Numeric params occur too,
+     * and a parameter may itself be a message, serialized as
+     * `{ message: ApiRawMessage }`.
+     */
+    params?: (string | number | {
+        message?: ApiRawMessage;
+    })[];
+    /** Module the message originated from, e.g. `main`, `query+info`. */
+    module?: string;
+    /** Extra structured data some messages attach. */
+    data?: unknown;
+}
+/**
+ * An i18n message spec nested inside another message's `params`
+ * (`errorformat=raw`) when a parameter is itself a message, serialized as
+ * `{ message: ApiRawMessage }`. The nested `params` may recursively contain
+ * further messages.
+ */
+export interface ApiRawMessage {
+    /** i18n message key of the nested message. */
+    key?: string;
+    /** Parameters of the nested message, which may themselves be messages. */
+    params?: (string | number | {
+        message?: ApiRawMessage;
+    })[];
+}
+/** The `error` object under the default (`bc`) `errorformat`. */
+export interface ApiError {
+    /** Machine-readable error code, e.g. `badtoken`. */
+    code?: string;
+    /** Human-readable description provided by the server. */
+    info?: string;
+    /** Docs link plus deprecation notices; nested in `error` under the `bc` format. */
+    docref?: string;
+    /** PHP backtrace, when `$wgShowExceptionDetails` is on (non-usage exceptions). */
+    trace?: string;
+    /**
+     * Structured `apiData` attached to the message by the emitting code, merged
+     * into this object as top-level keys.
+     */
+    [key: string]: unknown;
+}
+/** One `bc`-format warning entry (the value of a module key in `warnings`). */
+export interface ApiWarningDetail {
+    /** Warning text (`bc` errorformat). */
+    warnings?: string;
+}
+/**
+ * Warnings shape, polymorphic on `errorformat`:
+ * `bc` → object keyed by module name; modern → array of {@link ApiMessage}.
+ */
+export type ApiWarnings = Record<string, ApiWarningDetail> | ApiMessage[];
+/** Fields that may appear on every API response, successful or not. */
+export interface ApiEnvelope {
+    /**
+     * Present and `true` when all data for the current batch of pages has been
+     * returned. Continuation may still be ongoing: the generator runs again for
+     * the next batch of pages, and list/meta modules may continue independently.
+     * Serialized as a real boolean under `formatversion=2`.
+     */
+    batchcomplete?: true;
+    /**
+     * Identifier of the server that handled the request. Present by default on
+     * error responses; on successful responses only when explicitly requested.
+     */
+    servedby?: string;
+    /** Current server time (ISO 8601), present when the request set `curtimestamp`. */
+    curtimestamp?: string;
+    /** Opaque value echoed back from the request's `requestid` parameter. */
+    requestid?: string;
+    /** Non-fatal warnings; shape depends on `errorformat` (see {@link ApiWarnings}). */
+    warnings?: ApiWarnings;
+    /** Language of the interface strings in the response (`responselanginfo=1`). */
+    uselang?: string;
+    /** Language error messages are rendered in (`responselanginfo=1`). */
+    errorlang?: string;
+}
+/** Error response under the default (`bc`) `errorformat`: a single `error` object. */
+export interface ApiBcErrorResponse extends ApiEnvelope {
+    error: ApiError;
+}
+/** Error response under a modern `errorformat`: an `errors` array plus top-level `docref`. */
+export interface ApiModernErrorResponse extends ApiEnvelope {
+    errors: ApiMessage[];
+    /** Docs link plus deprecation notices (top-level under modern `errorformat`). */
+    docref?: string;
+    /** PHP backtrace, when `$wgShowExceptionDetails` is on (non-usage exceptions). */
+    trace?: string;
+}
+/** An API response describing a failed request (either `errorformat` family). */
+export type ApiErrorResponse = ApiBcErrorResponse | ApiModernErrorResponse;
+/** Discriminated union helper: a response is either successful or an error. */
+export type ApiResponseWith<TSuccess> = ApiErrorResponse | (TSuccess & ApiEnvelope);

package/dist/extensions/abusefilters.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Opt-in extension pack: **AbuseFilter** (`list=abusefilters`, `list=abuselog`,
+ * `action=abusefilterchecksyntax`, `action=abusefilterevalexpression`,
+ * `action=abusefiltercheckmatch`, `action=abusefilterunblockautopromote`,
+ * `action=abuselogprivatedetails`).
+ *
+ * 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/abusefilters';
+ * ```
+ *
+ * The `action=` responses are standalone — import them by name.
+ *
+ * fv2 notes: `hits` is withheld (surfaced as `hitsredacted: true` on newer
+ * builds) for viewers without `abusefilter-log-detail`; `abfprop=flags` expands
+ * the booleans. Continuation uses `abfstartid`/`aflstart` (covered by the core
+ * `ApiQueryContinue` index signature). `abuselog` visibility is permission
+ * sensitive: `filter_id`/`revid` come back as `""` rather than being omitted when
+ * the viewer may not see the details, and `details`/`filter`/`wiki` appear only
+ * with the matching `aflprop`.
+ *
+ * @see https://www.mediawiki.org/wiki/Extension:AbuseFilter/Raw_format_of_filters
+ * @see https://www.mediawiki.org/wiki/Extension:AbuseFilter/API
+ */
+import type { Flag, NamespaceIndex, Timestamp } from "../common";
+import type { ApiEnvelope } from "../envelope";
+/** One abuse filter definition. */
+export interface ApiAbuseFilter {
+    /** Filter id. */
+    id?: number;
+    /** Human-readable filter description. `abfprop=description`. */
+    description?: string;
+    /** The filter's regex/rule string. `abfprop=pattern` (withheld for private/protected filters). */
+    pattern?: string;
+    /**
+     * The actions the filter performs. `abfprop=actions`.
+     * * Up to MediaWiki 1.46: the raw `af_actions` column, a comma-joined
+     *   string such as `"disallow,tag"`.
+     * * 1.47 onward: the same value split into a `string[]`.
+     */
+    actions?: string | string[];
+    /** The filter's comments. `abfprop=comments` (withheld for private/protected filters). */
+    comments?: string;
+    /** Number of matches (only when the viewer may see it). `abfprop=hits`. */
+    hits?: number;
+    /**
+     * `true` when `hits` was withheld from this viewer. A {@link Flag}. Before
+     * 1.47, a withheld {@link hits} was simply omitted.
+     *
+     * @since MediaWiki 1.47
+     */
+    hitsredacted?: Flag;
+    /**
+     * `true` when `pattern` was withheld from this viewer. A {@link Flag}.
+     * Before 1.47, a withheld {@link pattern} was simply omitted.
+     *
+     * @since MediaWiki 1.47
+     */
+    patternredacted?: Flag;
+    /**
+     * `true` when `comments` was withheld from this viewer. A {@link Flag}.
+     * Before 1.47, a withheld {@link comments} was simply omitted.
+     *
+     * @since MediaWiki 1.47
+     */
+    commentsredacted?: Flag;
+    /** Last editor of the filter. `abfprop=lasteditor`. */
+    lasteditor?: string;
+    /** Last edit timestamp. `abfprop=lastedittime`. */
+    lastedittime?: Timestamp;
+    /**
+     * Whether the filter is enabled. `abfprop=status`.
+     * * 1.43: present as an **empty string** when the flag applies, and absent otherwise.
+     * * Newer builds (`abfprop=flags`): real booleans, always present.
+     */
+    enabled?: "" | boolean;
+    /** Whether the filter is soft-deleted. `abfprop=status`; same `""` (1.43) vs real boolean (newer `abfprop=flags`) behaviour as {@link enabled}. */
+    deleted?: "" | boolean;
+    /** Whether the filter is private (hidden from the viewer). `abfprop=private`; same `""` (1.43) vs real boolean (newer `abfprop=flags`) behaviour as {@link enabled}. */
+    private?: "" | boolean;
+    /**
+     * Whether the filter's protected variables are hidden. Same `""` (1.43) vs
+     * real boolean (newer `abfprop=flags`) behaviour as {@link enabled}.
+     *
+     * @since MediaWiki 1.43
+     */
+    protected?: "" | boolean;
+    /**
+     * Whether the filter is suppressed (oversight). A real `boolean` under
+     * `abfprop=flags`; the per-flag `abfprop=suppressed` alias is itself
+     * deprecated since 1.47.
+     *
+     * @since MediaWiki 1.47
+     */
+    suppressed?: boolean;
+}
+/** One abuse-log entry (`list=abuselog`). */
+export interface ApiAbuseLogEntry {
+    /** Log record id (`afl_id`). `aflprop=ids`. */
+    id?: number;
+    /**
+     * Filter that matched: the filter id as a string, prefixed `global-` for
+     * central filters (e.g. `global-42`). `aflprop=ids`; an **empty string**
+     * when the viewer may not see the details.
+     */
+    filter_id?: string;
+    /** Public description of the filter. `aflprop=filter`. */
+    filter?: string;
+    /** Actor name. `aflprop=user`. */
+    user?: string;
+    /** Namespace of the affected page. `aflprop=title`. */
+    ns?: NamespaceIndex;
+    /** Title of the affected page. `aflprop=title`. */
+    title?: string;
+    /** Action that was filtered, e.g. `edit`, `create`. `aflprop=action`. */
+    action?: string;
+    /**
+     * Consequences applied, e.g. `disallow`. `aflprop=result`; a comma-joined
+     * string on 1.43, as stored in `afl_actions`.
+     */
+    result?: string;
+    /** Revision the log entry points at. `aflprop=revid`; `""` when withheld. */
+    revid?: number | "";
+    /** When the entry was recorded. `aflprop=timestamp`. */
+    timestamp?: Timestamp;
+    /** Whether the entry is revdel'd. `aflprop=hidden`; a real `boolean`. */
+    hidden?: boolean;
+    /**
+     * Filter variables in effect. `aflprop=details`; a map keyed by variable name.
+     * Values are strings, numbers or booleans, but may also be arrays or `null`
+     * (the raw `AFPData::toNative()` dump); withheld variables arrive as empty
+     * strings. An empty map arrives as `[]`.
+     */
+    details?: Record<string, unknown> | unknown[];
+    /** Source wiki id. `aflprop=wiki`, and only on a central filter wiki. */
+    wiki?: string;
+}
+/** Status of a syntax check (`action=abusefilterchecksyntax`). */
+export type AbuseFilterSyntaxStatus = "ok" | "error" | (string & {});
+/** Response of `action=abusefilterchecksyntax`. */
+export interface ApiAbuseFilterCheckSyntaxResponse extends ApiEnvelope {
+    abusefilterchecksyntax: {
+        /** Check outcome; `ok` when the pattern parses. */
+        status?: AbuseFilterSyntaxStatus;
+        /** Localized message text describing the problem. */
+        message?: string;
+        /** Character offset of the problem within the pattern. */
+        character?: number;
+        /**
+         * Parser warnings (e.g. an empty-match regex); present only when there is
+         * at least one, each with its own message and character offset.
+         */
+        warnings?: {
+            message?: string;
+            character?: number;
+        }[];
+    };
+}
+/** Response of `action=abusefilterevalexpression`. */
+export interface ApiAbuseFilterEvalExpressionResponse extends ApiEnvelope {
+    abusefilterevalexpression: {
+        /**
+         * Evaluated value. A boolean, number, string or (with `prettyprint`) a
+         * formatted representation, and a structured value for some expressions.
+         */
+        result?: unknown;
+    };
+}
+/** Response of `action=abusefiltercheckmatch`. */
+export interface ApiAbuseFilterCheckMatchResponse extends ApiEnvelope {
+    abusefiltercheckmatch: {
+        /** Whether the pattern matches the supplied variables. A real `boolean`. */
+        result?: boolean;
+    };
+}
+/** Response of `action=abusefilterunblockautopromote`. */
+export interface ApiAbuseFilterUnblockAutopromoteResponse extends ApiEnvelope {
+    abusefilterunblockautopromote: {
+        /** Canonical name of the user whose autopromote block was lifted. */
+        user?: string;
+    };
+}
+/** Response of `action=abuselogprivatedetails` (needs `abusefilter-privatedetails`). */
+export interface ApiAbuseLogPrivateDetailsResponse extends ApiEnvelope {
+    abuselogprivatedetails: {
+        /** Log record the details belong to. */
+        "log-id"?: number;
+        /** Actor of that log entry. */
+        user?: string;
+        /** Filter that matched. */
+        "filter-id"?: number;
+        /** Public filter description. */
+        "filter-description"?: string;
+        /** Real IP behind the entry; `null` when the log stored none. */
+        "ip-address"?: string | null;
+    };
+}
+declare module "types-mediawiki-response" {
+    interface ApiQueryResult {
+        abusefilters?: ApiAbuseFilter[];
+        abuselog?: ApiAbuseLogEntry[];
+    }
+}

package/dist/extensions/babel.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Opt-in extension pack: **Babel** (`meta=babel`).
+ *
+ * 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/babel';
+ * ```
+ *
+ * `ApiQueryBabel` (prefix `bab`, requiring `babuser`) returns a **flat map** of
+ * language code to Babel level (`"babel": { "en": "1", "de": "2", … }`) — one
+ * entry per language, no further grouping. The keys are site-configured Babel
+ * codes, so the object is open-ended; a user with no Babel entry yields an
+ * empty object (the module forces an associative type, so an empty result
+ * stays `{}` rather than `[]`).
+ *
+ * @see https://www.mediawiki.org/wiki/Extension:Babel
+ */
+/**
+ * A `meta=babel` result: language code → Babel level string (e.g. `"N"`, `"1"`…
+ * `"5"`). Site-configured, so the key set is open. An unknown user is an
+ * {@link ApiErrorResponse}, not this type.
+ */
+export type ApiBabelResult = Record<string, string>;
+declare module "types-mediawiki-response" {
+    interface ApiQueryResult {
+        babel?: ApiBabelResult;
+    }
+}

package/dist/extensions/categorytree.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Opt-in extension pack: **CategoryTree** (`action=categorytree`).
+ *
+ * Not in the default export. Standalone action response — import it directly:
+ *
+ * ```ts
+ * import type { ApiCategoryTreeResponse } from 'types-mediawiki-response/ext/categorytree';
+ * ```
+ *
+ * The module returns **pre-rendered HTML**, not structured rows: `category` is
+ * the root category, `html` the tree markup. Everything you would expect as
+ * data (page list, subcategories, sort keys) has to be parsed out of `html`, so
+ * prefer `list=allpages`/`prop=categories` when you need structure.
+ *
+ * The knobs are packed into a single JSON-encoded `options` string — there is
+ * **no `flavor` request parameter**; the tree shape comes from `mode`, and an
+ * unrecognized request parameter is what a `flavor=…` attempt earns you. The
+ * keys honored by the API are those in `$wgCategoryTreeDefaultOptions`
+ * (`mode`, `hideprefix`, `showcount`, `namespaces`, `notranslations`) plus
+ * `depth`; `hideroot` and `onlyroot` are read by the `<categorytree>` tag
+ * only, not by this module. Other scalar keys are tolerated but ignored, so
+ * the bag stays open.
+ * `html` is `""` when the category is empty or does not exist.
+ *
+ * @see https://www.mediawiki.org/wiki/Extension:CategoryTree
+ * @see https://www.mediawiki.org/wiki/Extension:CategoryTree/API
+ */
+import type { ApiEnvelope } from "../envelope";
+/**
+ * Options accepted inside the JSON-encoded `options` parameter. Which keys are
+ * honored comes from `$wgCategoryTreeDefaultOptions` (plus `depth`);
+ * `hideroot` and `onlyroot` apply to the `<categorytree>` tag only.
+ */
+export interface ApiCategoryTreeOptions {
+    /**
+     * What to list: `0` subcategories, `10` pages, `20` both, `100` parents
+     * (inverse listing). Also accepts the names `categories`/`sub`, `pages`,
+     * `all` and `parents`/`super`/`inverse`.
+     */
+    mode?: number | "categories" | "pages" | "all" | "parents" | (string & {});
+    /** How many levels deep to expand from the root category. Defaults to 1. */
+    depth?: number;
+    /** Restrict listed pages to these namespace indexes; `false` means all. */
+    namespaces?: number[] | false;
+    /** Append per-category member counts. */
+    showcount?: boolean;
+    /**
+     * Strip the namespace prefix from displayed titles: `always`, `never`,
+     * `auto`, or `categories` (aliases `category`, `smart` — strip it only on
+     * subcategories). Boolean and yes/no spellings are accepted too.
+     */
+    hideprefix?: "always" | "never" | "auto" | "categories" | (string & {});
+    /** Exclude translated versions of pages from the listing. */
+    notranslations?: boolean;
+    /**
+     * Omit the root category itself from the output. Read by the
+     * `<categorytree>` tag only; the API ignores it.
+     */
+    hideroot?: boolean;
+    /**
+     * Emit only the root node, without its children. Read by the
+     * `<categorytree>` tag only; the API ignores it.
+     */
+    onlyroot?: boolean;
+    /** Additional scalar keys are tolerated (but ignored) by the API. */
+    [key: string]: unknown;
+}
+/** Response of `action=categorytree`. */
+export interface ApiCategoryTreeResponse extends ApiEnvelope {
+    /**
+     * The module's only output is a content value: `html` holds the rendered tree.
+     * The requested category is **not** echoed back.
+     */
+    categorytree: {
+        /** Rendered tree markup; `""` for an empty or non-existent category. */
+        html?: string;
+    };
+}

package/dist/extensions/checkuser.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Opt-in extension pack: **CheckUser** (`list=checkuser`, `list=checkuserlog`).
+ *
+ * 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/checkuser';
+ * ```
+ *
+ * `list=checkuser` requires `mustBePosted()` and a csrf token (`cutoken`) plus
+ * the `checkuser` right; `list=checkuserlog` is a plain GET needing only the
+ * `checkuser-log` right. Every successful `list=checkuser` lookup is itself
+ * logged to cu_log (reason prefixed `API: ` for API requests), which is what
+ * populates `list=checkuserlog`.
+ *
+ * From MediaWiki 1.45 `list=checkuser` is switched off by default: unless the
+ * wiki sets `$wgCheckUserDisableCheckUserAPI = false`, every request fails with
+ * `disabled`. `list=checkuserlog` is unaffected.
+ *
+ * fv2 notes: values that were never recorded come back as `null` rather than
+ * being omitted — `agent`, and `ip` / `user` on rows that carry neither an actor
+ * nor an IP address.
+ * Continuation for `checkuserlog` uses `culcontinue` (covered by the core
+ * `ApiQueryContinue` index signature); `list=checkuser` does not paginate.
+ *
+ * @see https://www.mediawiki.org/wiki/Extension:CheckUser
+ */
+import type { NamespaceIndex, Timestamp } from "../common";
+/** One IP row of `curequest=userips`: an IP the target user edited from. */
+export interface ApiCheckUserIpRow {
+    /** Last edit from this IP. */
+    end: Timestamp;
+    /** Number of edits made from this IP within the requested time frame. */
+    editcount: number;
+    /**
+     * First edit from this IP; only present once the IP has more than one edit.
+     */
+    start?: Timestamp;
+    /**
+     * The IP address; `""` for a row recorded without one, as this mode
+     * stringifies the column.
+     */
+    address: string;
+}
+/** One action row of `curequest=actions` (deprecated alias `edits`). */
+export interface ApiCheckUserActionRow {
+    /** When the action happened. */
+    timestamp: Timestamp;
+    /** Namespace of the affected page. */
+    ns: NamespaceIndex;
+    /**
+     * Title (DB key form with underscores) of the affected page; a user page
+     * whose name is hidden comes back as a `rev-deleted-user` placeholder.
+     */
+    title: string;
+    /**
+     * Performing user name; IP for anonymous actions, or a `rev-deleted-user`
+     * placeholder. `null` on rows recorded with neither an actor nor an IP.
+     */
+    user: string | null;
+    /** IP address the action was made from; `null` when none was recorded. */
+    ip: string | null;
+    /**
+     * User-Agent string of the request, or `null` (not omitted under fv2) when
+     * none was recorded.
+     */
+    agent: string | null;
+    /** Edit summary / log action text, when there is one. */
+    summary?: string;
+    /** `m` for minor edits; the key is absent otherwise. */
+    minor?: "m";
+    /**
+     * X-Forwarded-For chain of the request, when one was recorded. Reported
+     * independently of `cuxff`, which only decides what the lookup matches on.
+     */
+    xff?: string;
+}
+/** One user row of `curequest=ipusers`: an account that edited from the target IP. */
+export interface ApiCheckUserIpUserRow {
+    /** Last edit by this user from the target IP. */
+    end: Timestamp;
+    /** Number of edits by this user from the target IP within the time frame. */
+    editcount: number;
+    /**
+     * Distinct IPs the user edited from — one for a single-IP target, but several
+     * when the target is a CIDR range or `cuxff` was passed (rows are then
+     * matched on XFF while the reported address stays the recorded IP). An entry
+     * is `null` when its row was recorded without an IP.
+     */
+    ips: (string | null)[];
+    /** Distinct User-Agent strings seen, entries may be `null` when unrecorded. */
+    agents: (string | null)[];
+    /**
+     * First edit by this user from the target IP; only present once the user has
+     * more than one edit.
+     */
+    start?: Timestamp;
+    /**
+     * User name, or a `rev-deleted-user` placeholder when suppressed; `""` for
+     * rows recorded with neither an actor nor an IP.
+     */
+    name: string;
+}
+/** The `checkuser` object: shaped by `curequest`, one key per request mode. */
+export interface ApiQueryCheckUserResult {
+    /** `curequest=userips`: IPs a user edited from. */
+    userips?: ApiCheckUserIpRow[];
+    /**
+     * `curequest=actions`, and its deprecated alias `curequest=edits` (which
+     * only draws a deprecation warning): individual actions by a user / IP.
+     *
+     * @since MediaWiki 1.42 for the `actions` spelling; earlier releases accept
+     * only `edits`.
+     */
+    edits?: ApiCheckUserActionRow[];
+    /** `curequest=ipusers`: users who edited from an IP or range. */
+    ipusers?: ApiCheckUserIpUserRow[];
+}
+/** One entry of `list=checkuserlog`. */
+export interface ApiCheckUserLogEntry {
+    /** When the check was performed. */
+    timestamp: Timestamp;
+    /** The checkuser who ran the lookup. */
+    checkuser: string;
+    /**
+     * Lookup type, e.g. `userips`, `useredits`, `ipusers`, `ipedits`,
+     * `ipedits-xff`, `ipusers-xff`, `investigate`.
+     */
+    type: string;
+    /** Check reason, prefixed `API: ` for lookups made through the API. */
+    reason: string;
+    /** Looked-up target (user name or IP). */
+    target: string;
+}
+/** The `checkuserlog` object of a `list=checkuserlog` response. */
+export interface ApiQueryCheckUserLogResult {
+    /** Log entries, ordered per `culdir` (default newest first). */
+    entries?: ApiCheckUserLogEntry[];
+}
+declare module "types-mediawiki-response" {
+    interface ApiQueryResult {
+        checkuser?: ApiQueryCheckUserResult;
+        checkuserlog?: ApiQueryCheckUserLogResult;
+    }
+}

package/dist/extensions/description.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Opt-in extension pack: **Wikibase Client** (`prop=description`).
+ *
+ * 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/description';
+ * ```
+ *
+ * @see https://www.mediawiki.org/wiki/Extension:Wikibase_Client
+ */
+/** Where the description came from. Open union for forward compatibility. */
+export type DescriptionSource = "local" | "central" | (string & {});
+declare module "types-mediawiki-response" {
+    interface ApiPage {
+        description?: string;
+        descriptionsource?: DescriptionSource;
+    }
+}