openreport-sdk 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,117 @@
-# Temporary Holding Version
+# openreport-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+TypeScript and JavaScript clients for OpenReport. Node.js >= 20, with no runtime
+dependencies. Keep application and bot keys server side.
+
+```sh
+npm install openreport-sdk
+```
+
+## Application client
+
+Third-party integrations use an application API key and the `/v1` routes.
+
+```ts
+import { OpenReport, levelAtLeast } from 'openreport-sdk';
+
+const api = new OpenReport(process.env.OPENREPORT_API_KEY!);
+const status = await api.lookup('123456789012345678');
+if (status.blacklisted && status.level && levelAtLeast(status.level, 'medium')) {
+    console.log(status.level, status.since);
+}
+console.log(status.staffRole); // 'jury', 'admin' or null, even if not listed.
+const members = await api.lookupMany(['123456789012345678', '987654321098765432']);
+console.log(members.get('123456789012345678'));
+
+const receipt = await api.report({
+    userIds: ['123456789012345678'],
+    reason: 'Describe what happened with enough context for the jury.',
+    evidence: [{ name: 'capture.png', data: screenshotBytes, type: 'image/png' }],
+});
+console.log(receipt.reference);
+```
+
+`screenshotBytes` is a `Uint8Array`, `ArrayBuffer` or `Blob` containing the evidence.
+The API validates report contents and evidence. `lookupMany` deduplicates IDs,
+requests batches of at most 100, and returns a `Map<string, Status>`. An empty
+list makes no request. Lookup and report IDs must have 17 to 20 digits or the
+SDK rejects with `TypeError`. Levels are `low`, `medium`, `high`, mildest first.
+Staff roles identify active staff; they do not attest to NDA acceptance.
+
+CommonJS consumers can use `const { OpenReport } = require('openreport-sdk')`.
+The same compiled CommonJS package supports named ESM imports and includes types.
+
+## Official bot client
+
+`OpenReportBot` is reserved to the official OpenReport bot. Third-party bots must
+use `OpenReport`, and cannot act on behalf of users with an application key.
+
+```ts
+import { OpenReportBot } from 'openreport-sdk';
+
+const bot = new OpenReportBot(process.env.OPENREPORT_BOT_KEY!);
+const actingUserId = '123456789012345678';
+const cases = await bot.cases('open'); // Or 'recent'.
+if (cases[0]) {
+    const detail = await bot.caseDetail(actingUserId, cases[0].id);
+    const tally = await bot.vote(actingUserId, detail.id, {
+        approve: true,
+        level: 'medium',
+    });
+    console.log(tally.quorumReached);
+}
+const record = await bot.record(actingUserId);
+const status = await bot.lookup(actingUserId);
+// bot.report(actingUserId, input) accepts the same ReportInput as api.report().
+```
+
+The bot authenticates with `Authorization: Bot <key>` and sends the acting user
+in `X-OpenReport-User` for report, detail, vote and record calls. The backend
+checks juror/admin permissions and NDA acceptance for details and votes. Show
+case reasons only to authorized jurors in ephemeral messages. Evidence must
+never pass through Discord.
+
+## Options and errors
+
+Both constructors accept `{ baseUrl, timeoutMs, fetch, userAgent }`. The default
+base URL is `https://api-openreport.chell.fr`; the default timeout is 10 seconds.
+Supply `fetch` to inject a compatible transport for tests. Requests use
+`AbortSignal.timeout`; timeout errors retain the native `TimeoutError` name.
+Network errors propagate, with no automatic retry of reports or votes.
+
+Wire fields are snake_case; SDK fields are camelCase. Dates become `Date`
+objects, including lookup timestamps supplied as Unix seconds. Absent lookup
+role, level and date fields become `null` for compatibility with older servers.
+
+API errors extend `OpenReportError` with `status` and `detail`:
+
+| Error | Status | Extra |
+| --- | --- | --- |
+| `Unauthorized` | 401, 403 | Invalid key or acting user not authorized |
+| `NotFound` | 404 | Unknown resource |
+| `RateLimited` | 429 | `retryAfter`: seconds, or `null` if missing/invalid |
+| `OpenReportError` | Other failures | Original error detail |
+
+`Retry-After` accepts seconds or an HTTP date. Error detail retains structured
+validation errors; plain text gateway responses are also preserved.
+
+## Notice obligation
+
+GDPR article 14 requires your bot to inform a person when it uses registry data
+to restrict them in a server, at the latest at their first interaction. Explain
+the restriction and link to `https://openreport.chell.fr/notice` and their record
+on the OpenReport site. Do not sanction someone for a pending accusation.
+
+## Development
+
+```sh
+npm install
+npm run build
+npm test
+npm pack --dry-run
+```
+
+`build` compiles strict TypeScript to CommonJS and declarations in `dist/`.
+`test` runs `node:test` through `tsx` with injected fake fetch implementations.
+`prepublishOnly` runs the build and tests. Only `dist/`, this README and package
+metadata are published. License: MIT.

package/dist/bot-client.d.ts

@@ -0,0 +1,12 @@
+import type { CaseDetail, CaseSummary, ClientOptions, ReportInput, ReportReceipt, SelfRecord, Status, Tally, VoteInput } from './types';
+/** Reserved for the official OpenReport bot and its single bot key. */
+export declare class OpenReportBot {
+    private readonly http;
+    constructor(botKey: string, options?: ClientOptions);
+    lookup(userId: string): Promise<Status>;
+    report(actingUserId: string, input: ReportInput): Promise<ReportReceipt>;
+    cases(state: 'open' | 'recent'): Promise<CaseSummary[]>;
+    caseDetail(actingUserId: string, caseId: string): Promise<CaseDetail>;
+    vote(actingUserId: string, caseId: string, vote: VoteInput): Promise<Tally>;
+    record(actingUserId: string): Promise<SelfRecord>;
+}

package/dist/bot-client.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenReportBot = void 0;
+const http_1 = require("./http");
+const mapping_1 = require("./mapping");
+/** Reserved for the official OpenReport bot and its single bot key. */
+class OpenReportBot {
+    http;
+    constructor(botKey, options) {
+        this.http = new http_1.Http(`Bot ${botKey}`, options);
+    }
+    async lookup(userId) {
+        (0, http_1.validateUserId)(userId);
+        return (0, mapping_1.status)(userId, await this.http.request(`/bot/lookup/${userId}`));
+    }
+    async report(actingUserId, input) {
+        return this.http.request('/bot/reports', 'POST', (0, http_1.reportForm)(input), actingUserId);
+    }
+    async cases(state) {
+        const cases = await this.http.request(`/bot/cases?state=${encodeURIComponent(state)}`);
+        return cases.map(mapping_1.caseSummary);
+    }
+    async caseDetail(actingUserId, caseId) {
+        return (0, mapping_1.caseDetail)(await this.http.request(`/bot/cases/${encodeURIComponent(caseId)}`, 'GET', undefined, actingUserId));
+    }
+    async vote(actingUserId, caseId, vote) {
+        return (0, mapping_1.tally)(await this.http.request(`/bot/cases/${encodeURIComponent(caseId)}/vote`, 'POST', {
+            approve: vote.approve,
+            danger_level: vote.level,
+            note: vote.note,
+        }, actingUserId));
+    }
+    async record(actingUserId) {
+        return (0, mapping_1.record)(await this.http.request('/bot/me/record', 'GET', undefined, actingUserId));
+    }
+}
+exports.OpenReportBot = OpenReportBot;

package/dist/client.d.ts

@@ -0,0 +1,9 @@
+import type { ClientOptions, ReportInput, ReportReceipt, Status } from './types';
+/** Application API key client for third-party integrations. */
+export declare class OpenReport {
+    private readonly http;
+    constructor(apiKey: string, options?: ClientOptions);
+    lookup(userId: string): Promise<Status>;
+    lookupMany(userIds: string[]): Promise<Map<string, Status>>;
+    report(input: ReportInput): Promise<ReportReceipt>;
+}

package/dist/client.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenReport = void 0;
+const http_1 = require("./http");
+const mapping_1 = require("./mapping");
+/** Application API key client for third-party integrations. */
+class OpenReport {
+    http;
+    constructor(apiKey, options) {
+        this.http = new http_1.Http(`Bearer ${apiKey}`, options);
+    }
+    async lookup(userId) {
+        (0, http_1.validateUserId)(userId);
+        return (0, mapping_1.status)(userId, await this.http.request(`/v1/lookup/${userId}`));
+    }
+    async lookupMany(userIds) {
+        const ids = [...new Set(userIds)];
+        ids.forEach(http_1.validateUserId);
+        const result = new Map();
+        for (let start = 0; start < ids.length; start += 100) {
+            const chunk = ids.slice(start, start + 100);
+            const entries = await this.http.request('/v1/lookup', 'POST', { ids: chunk });
+            for (const userId of chunk) {
+                const entry = entries[userId];
+                if (entry === undefined) {
+                    throw new TypeError(`Lookup response missing ${userId}`);
+                }
+                result.set(userId, (0, mapping_1.status)(userId, entry));
+            }
+        }
+        return result;
+    }
+    async report(input) {
+        return this.http.request('/v1/reports', 'POST', (0, http_1.reportForm)(input));
+    }
+}
+exports.OpenReport = OpenReport;

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+export declare class OpenReportError extends Error {
+    readonly status: number;
+    readonly detail: unknown;
+    constructor(status: number, detail: unknown);
+}
+export declare class Unauthorized extends OpenReportError {
+}
+export declare class NotFound extends OpenReportError {
+}
+export declare class RateLimited extends OpenReportError {
+    readonly retryAfter: number | null;
+    constructor(detail: unknown, retryAfter: number | null);
+}
+export declare function responseError(response: Response, body: unknown): OpenReportError;

package/dist/errors.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimited = exports.NotFound = exports.Unauthorized = exports.OpenReportError = void 0;
+exports.responseError = responseError;
+class OpenReportError extends Error {
+    status;
+    detail;
+    constructor(status, detail) {
+        super(typeof detail === 'string' ? detail : `OpenReport request failed (${status})`);
+        this.status = status;
+        this.detail = detail;
+        this.name = new.target.name;
+    }
+}
+exports.OpenReportError = OpenReportError;
+class Unauthorized extends OpenReportError {
+}
+exports.Unauthorized = Unauthorized;
+class NotFound extends OpenReportError {
+}
+exports.NotFound = NotFound;
+class RateLimited extends OpenReportError {
+    retryAfter;
+    constructor(detail, retryAfter) {
+        super(429, detail);
+        this.retryAfter = retryAfter;
+    }
+}
+exports.RateLimited = RateLimited;
+function responseError(response, body) {
+    const detail = typeof body === 'object' && body !== null && 'detail' in body
+        ? body.detail : body;
+    if (response.status === 401 || response.status === 403) {
+        return new Unauthorized(response.status, detail);
+    }
+    if (response.status === 404) {
+        return new NotFound(response.status, detail);
+    }
+    if (response.status === 429) {
+        const header = response.headers.get('Retry-After');
+        let retryAfter = null;
+        if (header !== null && /^\d+(?:\.\d+)?$/.test(header.trim())) {
+            retryAfter = Number(header);
+        }
+        else if (header !== null) {
+            const date = Date.parse(header);
+            if (Number.isFinite(date)) {
+                retryAfter = Math.max(0, Math.ceil((date - Date.now()) / 1000));
+            }
+        }
+        return new RateLimited(detail, retryAfter);
+    }
+    return new OpenReportError(response.status, detail);
+}

package/dist/http.d.ts

@@ -0,0 +1,11 @@
+import type { ClientOptions, ReportInput } from './types';
+export declare function validateUserId(userId: string): void;
+export declare function reportForm(input: ReportInput): FormData;
+export declare class Http {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly fetcher;
+    private readonly headers;
+    constructor(authorization: string, options?: ClientOptions);
+    request<T>(path: string, method?: string, body?: FormData | object, actingUserId?: string): Promise<T>;
+}

package/dist/http.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Http = void 0;
+exports.validateUserId = validateUserId;
+exports.reportForm = reportForm;
+const errors_1 = require("./errors");
+function validateUserId(userId) {
+    if (typeof userId !== 'string' || !/^\d{17,20}$/.test(userId)) {
+        throw new TypeError('Expected a Discord snowflake with 17 to 20 digits');
+    }
+}
+function reportForm(input) {
+    input.userIds.forEach(validateUserId);
+    const form = new FormData();
+    form.append('reason', input.reason);
+    for (const userId of input.userIds) {
+        form.append('discord_ids', userId);
+    }
+    for (const evidence of input.evidence) {
+        const data = evidence.data instanceof Uint8Array
+            ? new Uint8Array(evidence.data).buffer : evidence.data;
+        const blob = data instanceof Blob && evidence.type === undefined
+            ? data : new Blob([data], { type: evidence.type });
+        form.append('files', blob, evidence.name);
+    }
+    return form;
+}
+class Http {
+    baseUrl;
+    timeoutMs;
+    fetcher;
+    headers;
+    constructor(authorization, options = {}) {
+        this.baseUrl = (options.baseUrl ?? 'https://api-openreport.chell.fr').replace(/\/+$/, '');
+        this.timeoutMs = options.timeoutMs ?? 10_000;
+        this.fetcher = options.fetch ?? globalThis.fetch;
+        this.headers = new Headers({ Authorization: authorization });
+        if (options.userAgent !== undefined) {
+            this.headers.set('User-Agent', options.userAgent);
+        }
+    }
+    async request(path, method = 'GET', body, actingUserId) {
+        const headers = new Headers(this.headers);
+        if (actingUserId !== undefined) {
+            validateUserId(actingUserId);
+            headers.set('X-OpenReport-User', actingUserId);
+        }
+        const multipart = body instanceof FormData;
+        if (body !== undefined && !multipart) {
+            headers.set('Content-Type', 'application/json');
+        }
+        const response = await this.fetcher(`${this.baseUrl}${path}`, {
+            method,
+            headers,
+            body: multipart ? body : body === undefined ? undefined : JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            let detail = text;
+            try {
+                detail = JSON.parse(text);
+            }
+            catch {
+                // Gateways can return plain text instead of the API's JSON errors.
+            }
+            throw (0, errors_1.responseError)(response, detail);
+        }
+        return await response.json();
+    }
+}
+exports.Http = Http;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { OpenReport } from './client';
+export { OpenReportBot } from './bot-client';
+export { OpenReportError, Unauthorized, NotFound, RateLimited } from './errors';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimited = exports.NotFound = exports.Unauthorized = exports.OpenReportError = exports.OpenReportBot = exports.OpenReport = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "OpenReport", { enumerable: true, get: function () { return client_1.OpenReport; } });
+var bot_client_1 = require("./bot-client");
+Object.defineProperty(exports, "OpenReportBot", { enumerable: true, get: function () { return bot_client_1.OpenReportBot; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "OpenReportError", { enumerable: true, get: function () { return errors_1.OpenReportError; } });
+Object.defineProperty(exports, "Unauthorized", { enumerable: true, get: function () { return errors_1.Unauthorized; } });
+Object.defineProperty(exports, "NotFound", { enumerable: true, get: function () { return errors_1.NotFound; } });
+Object.defineProperty(exports, "RateLimited", { enumerable: true, get: function () { return errors_1.RateLimited; } });
+__exportStar(require("./types"), exports);

package/dist/mapping.d.ts

@@ -0,0 +1,51 @@
+import type { CaseDetail, CaseSummary, SelfRecord, Status, Tally } from './types';
+export interface WireStatus {
+    blacklisted: boolean;
+    blacklistlevel?: Status['level'];
+    blacklistdate?: number | null;
+    staff_role?: Status['staffRole'];
+}
+export declare function status(userId: string, wire: WireStatus): Status;
+export interface WireTally {
+    jury_size: number;
+    cast: number;
+    approvals: number;
+    refusals: number;
+    quorum_needed: number;
+    quorum_reached: boolean;
+    approval_ratio: number;
+    admin_required: boolean;
+}
+export declare function tally(wire: WireTally): Tally;
+export interface WireCase {
+    id: string;
+    reference: string;
+    kind: CaseSummary['kind'];
+    status: CaseSummary['status'];
+    opened_at: string;
+    expires_at: string | null;
+    subject_discord_id: string;
+    subject_display: string;
+    danger_level: CaseSummary['level'];
+    tally: WireTally;
+}
+export declare function caseSummary(wire: WireCase): CaseSummary;
+export interface WireCaseDetail extends WireCase {
+    reason: string | null;
+    evidence_count: number;
+    my_vote: boolean | null;
+}
+export declare function caseDetail(wire: WireCaseDetail): CaseDetail;
+export interface WireRecord {
+    discord_id: string;
+    blacklisted: boolean;
+    level: SelfRecord['level'];
+    blacklisted_at: string | null;
+    expires_at: string | null;
+    grounds_count: number;
+    open_cases: number;
+    can_appeal: boolean;
+    appeal_status: SelfRecord['appealStatus'];
+    informed_at: string | null;
+}
+export declare function record(wire: WireRecord): SelfRecord;

package/dist/mapping.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = status;
+exports.tally = tally;
+exports.caseSummary = caseSummary;
+exports.caseDetail = caseDetail;
+exports.record = record;
+function status(userId, wire) {
+    return {
+        userId,
+        blacklisted: wire.blacklisted,
+        level: wire.blacklistlevel ?? null,
+        since: wire.blacklistdate == null ? null : new Date(wire.blacklistdate * 1000),
+        staffRole: wire.staff_role ?? null,
+    };
+}
+function tally(wire) {
+    return {
+        jurySize: wire.jury_size,
+        cast: wire.cast,
+        approvals: wire.approvals,
+        refusals: wire.refusals,
+        quorumNeeded: wire.quorum_needed,
+        quorumReached: wire.quorum_reached,
+        approvalRatio: wire.approval_ratio,
+        adminRequired: wire.admin_required,
+    };
+}
+function caseSummary(wire) {
+    return {
+        id: wire.id,
+        reference: wire.reference,
+        kind: wire.kind,
+        status: wire.status,
+        openedAt: new Date(wire.opened_at),
+        expiresAt: wire.expires_at === null ? null : new Date(wire.expires_at),
+        subjectId: wire.subject_discord_id,
+        subjectDisplay: wire.subject_display,
+        level: wire.danger_level,
+        tally: tally(wire.tally),
+    };
+}
+function caseDetail(wire) {
+    return {
+        ...caseSummary(wire),
+        reason: wire.reason,
+        evidenceCount: wire.evidence_count,
+        myVote: wire.my_vote,
+    };
+}
+function record(wire) {
+    return {
+        userId: wire.discord_id,
+        blacklisted: wire.blacklisted,
+        level: wire.level,
+        blacklistedAt: wire.blacklisted_at === null ? null : new Date(wire.blacklisted_at),
+        expiresAt: wire.expires_at === null ? null : new Date(wire.expires_at),
+        groundsCount: wire.grounds_count,
+        openCases: wire.open_cases,
+        canAppeal: wire.can_appeal,
+        appealStatus: wire.appeal_status,
+        informedAt: wire.informed_at === null ? null : new Date(wire.informed_at),
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+export type Level = 'low' | 'medium' | 'high';
+export declare const LEVELS: readonly Level[];
+export declare function levelAtLeast(level: Level, minimum: Level): boolean;
+export type StaffRole = 'jury' | 'admin';
+export interface Status {
+    userId: string;
+    blacklisted: boolean;
+    level: Level | null;
+    since: Date | null;
+    staffRole: StaffRole | null;
+}
+export interface Evidence {
+    name: string;
+    data: Uint8Array | ArrayBuffer | Blob;
+    type?: string;
+}
+export interface ReportInput {
+    userIds: string[];
+    reason: string;
+    evidence: Evidence[];
+}
+export interface ReportReceipt {
+    reference: string;
+    targets: number;
+    message: string;
+}
+export interface ClientOptions {
+    baseUrl?: string;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+    userAgent?: string;
+}
+export type CaseKind = 'blacklist' | 'unblacklist';
+export type CaseStatus = 'open' | 'accepted' | 'rejected' | 'escalated' | 'expired' | 'withdrawn' | 'ignored';
+export interface Tally {
+    jurySize: number;
+    cast: number;
+    approvals: number;
+    refusals: number;
+    quorumNeeded: number;
+    quorumReached: boolean;
+    approvalRatio: number;
+    adminRequired: boolean;
+}
+export interface CaseSummary {
+    id: string;
+    reference: string;
+    kind: CaseKind;
+    status: CaseStatus;
+    openedAt: Date;
+    expiresAt: Date | null;
+    subjectId: string;
+    subjectDisplay: string;
+    level: Level | null;
+    tally: Tally;
+}
+export interface CaseDetail extends CaseSummary {
+    reason: string | null;
+    evidenceCount: number;
+    myVote: boolean | null;
+}
+export interface VoteInput {
+    approve: boolean;
+    level?: Level;
+    note?: string;
+}
+export interface SelfRecord {
+    userId: string;
+    blacklisted: boolean;
+    level: Level | null;
+    blacklistedAt: Date | null;
+    expiresAt: Date | null;
+    groundsCount: number;
+    openCases: number;
+    canAppeal: boolean;
+    appealStatus: 'open' | 'accepted' | 'rejected' | null;
+    informedAt: Date | null;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEVELS = void 0;
+exports.levelAtLeast = levelAtLeast;
+exports.LEVELS = Object.freeze(['low', 'medium', 'high']);
+function levelAtLeast(level, minimum) {
+    return exports.LEVELS.indexOf(level) >= exports.LEVELS.indexOf(minimum);
+}

package/package.json

@@ -1,6 +1,20 @@
 {
-  "name": "openreport-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "openreport-sdk",
+    "version": "0.2.0",
+    "description": "OpenReport application and official bot clients",
+    "license": "MIT",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": ["dist", "README.md"],
+    "engines": { "node": ">=20" },
+    "scripts": {
+        "build": "tsc",
+        "test": "node --import tsx --test test/*.test.ts",
+        "prepublishOnly": "npm run build && npm test"
+    },
+    "devDependencies": {
+        "@types/node": "^22.0.0",
+        "tsx": "^4.0.0",
+        "typescript": "^5.0.0"
+    }
+}