@easecation/ecapi-sdk 0.1.0

package/README.md

@@ -0,0 +1,112 @@
+# @easecation/ecapi-sdk
+
+ECAPI 的 Node.js / TypeScript SDK，封装了常用接口，并内置两种鉴权方式：
+
+- `X-API-Key`（IAM API Key）
+- `X-App-Session-Token`（App Session Token）
+
+## 安装
+
+```bash
+npm install @easecation/ecapi-sdk
+```
+
+## 快速开始
+
+```ts
+import { ECAPIClient } from "@easecation/ecapi-sdk";
+
+const client = new ECAPIClient({
+  baseUrl: "https://your-ecapi-host",
+  auth: { type: "apiKey", apiKey: process.env.EC_API_KEY! },
+});
+
+const me = await client.user.getMe();
+const player = await client.player.getInfo({ name: "player123" });
+```
+
+切换为 App Session Token：
+
+```ts
+client.setAppSessionToken(process.env.EC_APP_SESSION_TOKEN!);
+```
+
+## 客户端能力
+
+- 统一请求入口：`client.request(method, path, options)`
+- 默认超时：15s（可在构造时 `timeoutMs` 覆盖）
+- 支持 per-request 覆盖鉴权：`options.auth`
+- 非 2xx 响应抛出 `ECAPIError`（包含 `status`、`payload`、`url`）
+
+## API 覆盖
+
+> 下列为 SDK 已封装的主要接口，未覆盖部分可通过 `client.request(...)` 直接调用。
+
+### 用户
+
+- `client.user.getMe()` → `GET /user/me`
+- `client.user.loginByPassword(payload)` → `POST /user/auth`
+- `client.user.loginByOauth2(payload)` → `POST /user/oauth2`
+- `client.user.refreshToken(payload)` → `POST /user/refresh`
+- `client.user.getOpenId()` → `GET /user/openid`
+- `client.user.listAll()` → `GET /user/all`
+- `client.user.updatePermissions(payload)` → `PUT /user/permissions`
+- `client.user.getById(id)` → `GET /user/:id`
+
+### 玩家
+
+- `client.player.getInfo()` → `GET /player/info`
+- `client.player.searchEcid()` → `GET /player/searchecid`
+- `client.player.getUserData()` → `GET /player/userdata`
+- `client.player.queryNetease()` → `GET /player/querynetease`
+- `client.player.setRankLevel(payload)` → `POST /player/ranklevel`
+- `client.player.clearRespackCache()` → `DELETE /player/respack/cache`
+- `client.player.getWallet()` → `GET /player/wallet`
+- `client.player.listGamingTags()` / `operateGamingTag(payload)` → `GET/POST /player/gaming-tag`
+- `client.player.getLastPlayed()` → `GET /player/last-played`
+- `client.player.getStageRecord()` → `GET /player/stage/record`
+- `client.player.getHeadicon()` / `getSkin()` → `GET /player/headicon|skin`（返回 `ArrayBuffer`）
+- `client.player.batchNeteaseNicknames(payload)` → `POST /player/neteasenicknames`
+- `client.player.getBinding()` / `resetBinding(payload)` / `updateBinding(payload)`
+- `client.player.updateUserData(nick, payload)` → `POST /player/update/:nick`
+- `client.player.updatePassword(ecid, payload)` / `getPasswordHash(ecid)`
+
+#### 玩家子模块
+
+- `client.player.score.*` → `/player/score*`
+- `client.player.tasks.*` → `/player/:ecid/tasks*`
+- `client.player.merchandise.*` → `/player/:ecid/merchandise*`
+- `client.player.yearSummary.*` → `/player/year-summary/*`
+- `client.player.vote.processRewards()` → `GET /player/vote`
+
+### 管理与处罚
+
+- `client.admin.*` → `/admin/*`
+- `client.punish.*` → `/punish/*`
+- `client.ban.*` → `/ban/*`
+- `client.permission.*` → `/permission`
+
+### 日志与审计
+
+- `client.log.*` → `/log/*`
+- `client.audit.*` → `/audit/*`
+
+### 配置与内容
+
+- `client.stage.*`（含 `stage.logs.*`）→ `/stage/*`
+- `client.item.getCommodity()` → `/item/commodity`
+- `client.cfglang.*` → `/cfglang*`
+- `client.globalkv.*` → `/globalkv*`
+- `client.broadcast.*` → `/broadcast*`
+- `client.pullConfig.pull()` → `/pull-config`
+
+### 运营与系统
+
+- `client.order.*` → `/order/*`
+- `client.count.*` → `/count/*`
+- `client.servers.*` → `/servers*`
+- `client.lobby.list()` → `/lobby/list`
+- `client.easechat.*` → `/easechat/*`
+- `client.monitor.spamDetector.*` → `/monitor/spam-detector/*`
+- `client.system.getHealth()` → `/health`
+

package/dist/apis.d.ts

@@ -0,0 +1,213 @@
+import { ECAPIHttpClient } from "./http";
+import { QueryParams, RequestOptions } from "./types";
+type NonBodyOptions = Omit<RequestOptions, "query" | "body">;
+declare class BaseApi {
+    protected readonly http: ECAPIHttpClient;
+    constructor(http: ECAPIHttpClient);
+    protected get<T = unknown>(path: string, query?: QueryParams, options?: NonBodyOptions): Promise<T>;
+    protected post<T = unknown>(path: string, body?: unknown, options?: Omit<RequestOptions, "body">): Promise<T>;
+    protected put<T = unknown>(path: string, body?: unknown, options?: Omit<RequestOptions, "body">): Promise<T>;
+    protected patch<T = unknown>(path: string, body?: unknown, options?: Omit<RequestOptions, "body">): Promise<T>;
+    protected delete<T = unknown>(path: string, query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<T>;
+}
+export declare class UserApi extends BaseApi {
+    getMe(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    loginByPassword(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    loginByOauth2(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    refreshToken(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getOpenId(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    listAll(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    updatePermissions(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getById(id: string, query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class PlayerScoreApi extends BaseApi {
+    getScore(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getStages(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getTop(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    deleteTop(query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<unknown>;
+    getConfig(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getLeaderboard(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class PlayerTasksApi extends BaseApi {
+    list(ecid: string, query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    create(ecid: string, payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    update(ecid: string, taskId: string, payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    deleteOne(ecid: string, taskId: string, query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<unknown>;
+}
+export declare class PlayerMerchandiseApi extends BaseApi {
+    list(ecid: string, query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    create(ecid: string, payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    update(ecid: string, idItem: string, payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    deleteOne(ecid: string, idItem: string, query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<unknown>;
+}
+export declare class PlayerYearSummaryApi extends BaseApi {
+    getBasicInfo(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getLoginStats(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getGameStats(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getRankData(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getCurrencyData(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getSocialData(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class PlayerVoteApi extends BaseApi {
+    processRewards(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class PlayerApi extends BaseApi {
+    readonly score: PlayerScoreApi;
+    readonly tasks: PlayerTasksApi;
+    readonly merchandise: PlayerMerchandiseApi;
+    readonly yearSummary: PlayerYearSummaryApi;
+    readonly vote: PlayerVoteApi;
+    constructor(http: ECAPIHttpClient);
+    getInfo(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    searchEcid(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getUserData(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    queryNetease(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    setRankLevel(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    clearRespackCache(query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<unknown>;
+    getWallet(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    listGamingTags(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    operateGamingTag(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getLastPlayed(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getStageRecord(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getHeadicon(query?: QueryParams, options?: Omit<RequestOptions, "query" | "responseType">): Promise<ArrayBuffer>;
+    getSkin(query?: QueryParams, options?: Omit<RequestOptions, "query" | "responseType">): Promise<ArrayBuffer>;
+    batchNeteaseNicknames(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getBinding(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    resetBinding(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    updateBinding(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    updateUserData(nick: string, payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    updatePassword(ecid: string, payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getPasswordHash(ecid: string, query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class AdminApi extends BaseApi {
+    sendMail(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    prismDeviceBan(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getPrismDeviceBanLog(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    upsertOverwatchCase(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getOverwatchCase(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getOperationLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getOperationStatistics(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class PunishApi extends BaseApi {
+    hack(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    ban(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    unban(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    mute(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    unmute(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    warn(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    kick(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    clearDegree(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    overwatch(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+}
+export declare class BanApi extends BaseApi {
+    ban(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    clearDegree(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    parkourPunish(query?: QueryParams, payload?: Record<string, unknown>, options?: Omit<RequestOptions, "query" | "body">): Promise<unknown>;
+}
+export declare class PermissionApi extends BaseApi {
+    getPermission(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    upsert(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    deleteOne(query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<unknown>;
+}
+export declare class LogApi extends BaseApi {
+    getAction(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getChat(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getAuth(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getTeaming(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getLatestTeaming(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getCommand(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getMail(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class OrderApi extends BaseApi {
+    getDeliver(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getExchangeLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getDownloadCount(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    createDownloadTask(query?: QueryParams, payload?: Record<string, unknown>, options?: Omit<RequestOptions, "query" | "body">): Promise<unknown>;
+    getDownloadStatus(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    listDownloadTasks(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class StageLogApi extends BaseApi {
+    list(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    query(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class StageApi extends BaseApi {
+    readonly logs: StageLogApi;
+    constructor(http: ECAPIHttpClient);
+    getTypes(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    create(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getInfo(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getDbId(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class ItemApi extends BaseApi {
+    getCommodity(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class CountApi extends BaseApi {
+    getHistory(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getLatest(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getTypes(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class ServersApi extends BaseApi {
+    list(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getStatistics(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getMainstackEvent(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class LobbyApi extends BaseApi {
+    list(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class CfgLangApi extends BaseApi {
+    list(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    compare(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    deploy(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    create(query: QueryParams | undefined, payload: Record<string, unknown>, options?: Omit<RequestOptions, "query" | "body">): Promise<unknown>;
+    update(query: QueryParams | undefined, payload: Record<string, unknown>, options?: Omit<RequestOptions, "query" | "body">): Promise<unknown>;
+    deleteOne(query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<unknown>;
+}
+export declare class GlobalKVApi extends BaseApi {
+    list(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getOne(key: string, query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    create(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    update(key: string, payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    deleteOne(key: string, query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<unknown>;
+    deleteBatch(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+}
+export declare class BroadcastApi extends BaseApi {
+    list(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    compare(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    deploy(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getOne(msg: string, query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    create(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    update(msg: string, payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    deleteOne(msg: string, payload?: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+}
+export declare class EaseChatApi extends BaseApi {
+    sendHlaba(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    listSubscriptions(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    createSubscription(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    deleteSubscription(query?: QueryParams, options?: Omit<RequestOptions, "query">): Promise<unknown>;
+}
+export declare class AuditApi extends BaseApi {
+    getAuthLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getPlayerLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getPunishmentLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getPermissionLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getAdminLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getConfigLogs(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class SpamDetectorApi extends BaseApi {
+    getStatus(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    control(payload: Record<string, unknown>, options?: Omit<RequestOptions, "body">): Promise<unknown>;
+    getStats(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class MonitorApi extends BaseApi {
+    readonly spamDetector: SpamDetectorApi;
+    constructor(http: ECAPIHttpClient);
+}
+export declare class PullConfigApi extends BaseApi {
+    pull(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export declare class SystemApi extends BaseApi {
+    getRoot(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+    getHealth(query?: QueryParams, options?: NonBodyOptions): Promise<unknown>;
+}
+export {};

package/dist/apis.js

@@ -0,0 +1,544 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemApi = exports.PullConfigApi = exports.MonitorApi = exports.SpamDetectorApi = exports.AuditApi = exports.EaseChatApi = exports.BroadcastApi = exports.GlobalKVApi = exports.CfgLangApi = exports.LobbyApi = exports.ServersApi = exports.CountApi = exports.ItemApi = exports.StageApi = exports.StageLogApi = exports.OrderApi = exports.LogApi = exports.PermissionApi = exports.BanApi = exports.PunishApi = exports.AdminApi = exports.PlayerApi = exports.PlayerVoteApi = exports.PlayerYearSummaryApi = exports.PlayerMerchandiseApi = exports.PlayerTasksApi = exports.PlayerScoreApi = exports.UserApi = void 0;
+class BaseApi {
+    constructor(http) {
+        this.http = http;
+    }
+    get(path, query, options) {
+        return this.http.request("GET", path, { ...options, query });
+    }
+    post(path, body, options) {
+        return this.http.request("POST", path, { ...options, body });
+    }
+    put(path, body, options) {
+        return this.http.request("PUT", path, { ...options, body });
+    }
+    patch(path, body, options) {
+        return this.http.request("PATCH", path, { ...options, body });
+    }
+    delete(path, query, options) {
+        return this.http.request("DELETE", path, { ...options, query });
+    }
+}
+class UserApi extends BaseApi {
+    getMe(query, options) {
+        return this.get("/user/me", query, options);
+    }
+    loginByPassword(payload, options) {
+        return this.post("/user/auth", payload, options);
+    }
+    loginByOauth2(payload, options) {
+        return this.post("/user/oauth2", payload, options);
+    }
+    refreshToken(payload, options) {
+        return this.post("/user/refresh", payload, options);
+    }
+    getOpenId(query, options) {
+        return this.get("/user/openid", query, options);
+    }
+    listAll(query, options) {
+        return this.get("/user/all", query, options);
+    }
+    updatePermissions(payload, options) {
+        return this.put("/user/permissions", payload, options);
+    }
+    getById(id, query, options) {
+        return this.get(`/user/${encodeURIComponent(id)}`, query, options);
+    }
+}
+exports.UserApi = UserApi;
+class PlayerScoreApi extends BaseApi {
+    getScore(query, options) {
+        return super.get("/player/score", query, options);
+    }
+    getStages(query, options) {
+        return super.get("/player/score/stages", query, options);
+    }
+    getTop(query, options) {
+        return super.get("/player/score/top", query, options);
+    }
+    deleteTop(query, options) {
+        return super.delete("/player/score/top", query, options);
+    }
+    getConfig(query, options) {
+        return super.get("/player/score/config", query, options);
+    }
+    getLeaderboard(query, options) {
+        return super.get("/player/score/leaderboard", query, options);
+    }
+}
+exports.PlayerScoreApi = PlayerScoreApi;
+class PlayerTasksApi extends BaseApi {
+    list(ecid, query, options) {
+        return this.get(`/player/${encodeURIComponent(ecid)}/tasks`, query, options);
+    }
+    create(ecid, payload, options) {
+        return this.post(`/player/${encodeURIComponent(ecid)}/tasks`, payload, options);
+    }
+    update(ecid, taskId, payload, options) {
+        return this.put(`/player/${encodeURIComponent(ecid)}/tasks/${encodeURIComponent(taskId)}`, payload, options);
+    }
+    deleteOne(ecid, taskId, query, options) {
+        return this.delete(`/player/${encodeURIComponent(ecid)}/tasks/${encodeURIComponent(taskId)}`, query, options);
+    }
+}
+exports.PlayerTasksApi = PlayerTasksApi;
+class PlayerMerchandiseApi extends BaseApi {
+    list(ecid, query, options) {
+        return this.get(`/player/${encodeURIComponent(ecid)}/merchandise`, query, options);
+    }
+    create(ecid, payload, options) {
+        return this.post(`/player/${encodeURIComponent(ecid)}/merchandise`, payload, options);
+    }
+    update(ecid, idItem, payload, options) {
+        return this.put(`/player/${encodeURIComponent(ecid)}/merchandise/${encodeURIComponent(idItem)}`, payload, options);
+    }
+    deleteOne(ecid, idItem, query, options) {
+        return this.delete(`/player/${encodeURIComponent(ecid)}/merchandise/${encodeURIComponent(idItem)}`, query, options);
+    }
+}
+exports.PlayerMerchandiseApi = PlayerMerchandiseApi;
+class PlayerYearSummaryApi extends BaseApi {
+    getBasicInfo(query, options) {
+        return this.get("/player/year-summary/basic-info", query, options);
+    }
+    getLoginStats(query, options) {
+        return this.get("/player/year-summary/login-stats", query, options);
+    }
+    getGameStats(query, options) {
+        return this.get("/player/year-summary/game-stats", query, options);
+    }
+    getRankData(query, options) {
+        return this.get("/player/year-summary/rank-data", query, options);
+    }
+    getCurrencyData(query, options) {
+        return this.get("/player/year-summary/currency-data", query, options);
+    }
+    getSocialData(query, options) {
+        return this.get("/player/year-summary/social-data", query, options);
+    }
+}
+exports.PlayerYearSummaryApi = PlayerYearSummaryApi;
+class PlayerVoteApi extends BaseApi {
+    processRewards(query, options) {
+        return this.get("/player/vote", query, options);
+    }
+}
+exports.PlayerVoteApi = PlayerVoteApi;
+class PlayerApi extends BaseApi {
+    constructor(http) {
+        super(http);
+        this.score = new PlayerScoreApi(http);
+        this.tasks = new PlayerTasksApi(http);
+        this.merchandise = new PlayerMerchandiseApi(http);
+        this.yearSummary = new PlayerYearSummaryApi(http);
+        this.vote = new PlayerVoteApi(http);
+    }
+    getInfo(query, options) {
+        return this.get("/player/info", query, options);
+    }
+    searchEcid(query, options) {
+        return this.get("/player/searchecid", query, options);
+    }
+    getUserData(query, options) {
+        return this.get("/player/userdata", query, options);
+    }
+    queryNetease(query, options) {
+        return this.get("/player/querynetease", query, options);
+    }
+    setRankLevel(payload, options) {
+        return this.post("/player/ranklevel", payload, options);
+    }
+    clearRespackCache(query, options) {
+        return this.delete("/player/respack/cache", query, options);
+    }
+    getWallet(query, options) {
+        return this.get("/player/wallet", query, options);
+    }
+    listGamingTags(query, options) {
+        return this.get("/player/gaming-tag", query, options);
+    }
+    operateGamingTag(payload, options) {
+        return this.post("/player/gaming-tag", payload, options);
+    }
+    getLastPlayed(query, options) {
+        return this.get("/player/last-played", query, options);
+    }
+    getStageRecord(query, options) {
+        return this.get("/player/stage/record", query, options);
+    }
+    getHeadicon(query, options) {
+        return this.http.request("GET", "/player/headicon", {
+            ...options,
+            query,
+            responseType: "arrayBuffer",
+        });
+    }
+    getSkin(query, options) {
+        return this.http.request("GET", "/player/skin", {
+            ...options,
+            query,
+            responseType: "arrayBuffer",
+        });
+    }
+    batchNeteaseNicknames(payload, options) {
+        return this.post("/player/neteasenicknames", payload, options);
+    }
+    getBinding(query, options) {
+        return this.get("/player/binding", query, options);
+    }
+    resetBinding(payload, options) {
+        return this.post("/player/reset-binding", payload, options);
+    }
+    updateBinding(payload, options) {
+        return this.post("/player/update-binding", payload, options);
+    }
+    updateUserData(nick, payload, options) {
+        return this.post(`/player/update/${encodeURIComponent(nick)}`, payload, options);
+    }
+    updatePassword(ecid, payload, options) {
+        return this.post(`/player/password/${encodeURIComponent(ecid)}`, payload, options);
+    }
+    getPasswordHash(ecid, query, options) {
+        return this.get(`/player/password/${encodeURIComponent(ecid)}`, query, options);
+    }
+}
+exports.PlayerApi = PlayerApi;
+class AdminApi extends BaseApi {
+    sendMail(payload, options) {
+        return this.post("/admin/mail", payload, options);
+    }
+    prismDeviceBan(payload, options) {
+        return this.post("/admin/prism-device-ban", payload, options);
+    }
+    getPrismDeviceBanLog(query, options) {
+        return this.get("/admin/prism-device-ban-log", query, options);
+    }
+    upsertOverwatchCase(payload, options) {
+        return this.post("/admin/overwatch", payload, options);
+    }
+    getOverwatchCase(query, options) {
+        return this.get("/admin/overwatch", query, options);
+    }
+    getOperationLogs(query, options) {
+        return this.get("/admin/operation", query, options);
+    }
+    getOperationStatistics(query, options) {
+        return this.get("/admin/operation/statistic", query, options);
+    }
+}
+exports.AdminApi = AdminApi;
+class PunishApi extends BaseApi {
+    hack(payload, options) {
+        return this.post("/punish/hack", payload, options);
+    }
+    ban(payload, options) {
+        return this.post("/punish/ban", payload, options);
+    }
+    unban(payload, options) {
+        return this.post("/punish/unban", payload, options);
+    }
+    mute(payload, options) {
+        return this.post("/punish/mute", payload, options);
+    }
+    unmute(payload, options) {
+        return this.post("/punish/unmute", payload, options);
+    }
+    warn(payload, options) {
+        return this.post("/punish/warn", payload, options);
+    }
+    kick(payload, options) {
+        return this.post("/punish/kick", payload, options);
+    }
+    clearDegree(payload, options) {
+        return this.post("/punish/clear-degree", payload, options);
+    }
+    overwatch(payload, options) {
+        return this.post("/punish/overwatch", payload, options);
+    }
+}
+exports.PunishApi = PunishApi;
+class BanApi extends BaseApi {
+    ban(payload, options) {
+        return this.post("/ban", payload, options);
+    }
+    clearDegree(payload, options) {
+        return this.post("/ban/clear-degree", payload, options);
+    }
+    parkourPunish(query, payload, options) {
+        return this.http.request("POST", "/ban/parkour-punish", {
+            ...options,
+            query,
+            body: payload,
+        });
+    }
+}
+exports.BanApi = BanApi;
+class PermissionApi extends BaseApi {
+    getPermission(query, options) {
+        return super.get("/permission", query, options);
+    }
+    upsert(payload, options) {
+        return this.post("/permission", payload, options);
+    }
+    deleteOne(query, options) {
+        return this.delete("/permission", query, options);
+    }
+}
+exports.PermissionApi = PermissionApi;
+class LogApi extends BaseApi {
+    getAction(query, options) {
+        return this.get("/log/action", query, options);
+    }
+    getChat(query, options) {
+        return this.get("/log/chat", query, options);
+    }
+    getAuth(query, options) {
+        return this.get("/log/auth", query, options);
+    }
+    getTeaming(query, options) {
+        return this.get("/log/teaming", query, options);
+    }
+    getLatestTeaming(query, options) {
+        return this.get("/log/latestTeaming", query, options);
+    }
+    getCommand(query, options) {
+        return this.get("/log/command", query, options);
+    }
+    getMail(query, options) {
+        return this.get("/log/mail", query, options);
+    }
+}
+exports.LogApi = LogApi;
+class OrderApi extends BaseApi {
+    getDeliver(query, options) {
+        return this.get("/order/deliver", query, options);
+    }
+    getLogs(query, options) {
+        return this.get("/order/logs", query, options);
+    }
+    getExchangeLogs(query, options) {
+        return this.get("/order/exchange-logs", query, options);
+    }
+    getDownloadCount(query, options) {
+        return this.get("/order/download/count", query, options);
+    }
+    createDownloadTask(query, payload, options) {
+        return this.http.request("POST", "/order/download/create", {
+            ...options,
+            query,
+            body: payload,
+        });
+    }
+    getDownloadStatus(query, options) {
+        return this.get("/order/download/status", query, options);
+    }
+    listDownloadTasks(query, options) {
+        return this.get("/order/download/list", query, options);
+    }
+}
+exports.OrderApi = OrderApi;
+class StageLogApi extends BaseApi {
+    list(query, options) {
+        return this.get("/stage/log/list", query, options);
+    }
+    query(query, options) {
+        return this.get("/stage/log/query", query, options);
+    }
+}
+exports.StageLogApi = StageLogApi;
+class StageApi extends BaseApi {
+    constructor(http) {
+        super(http);
+        this.logs = new StageLogApi(http);
+    }
+    getTypes(query, options) {
+        return this.get("/stage/types", query, options);
+    }
+    create(payload, options) {
+        return this.post("/stage/create", payload, options);
+    }
+    getInfo(query, options) {
+        return this.get("/stage/info", query, options);
+    }
+    getDbId(query, options) {
+        return this.get("/stage/db-id", query, options);
+    }
+}
+exports.StageApi = StageApi;
+class ItemApi extends BaseApi {
+    getCommodity(query, options) {
+        return this.get("/item/commodity", query, options);
+    }
+}
+exports.ItemApi = ItemApi;
+class CountApi extends BaseApi {
+    getHistory(query, options) {
+        return this.get("/count/history", query, options);
+    }
+    getLatest(query, options) {
+        return this.get("/count/latest", query, options);
+    }
+    getTypes(query, options) {
+        return this.get("/count/types", query, options);
+    }
+}
+exports.CountApi = CountApi;
+class ServersApi extends BaseApi {
+    list(query, options) {
+        return this.get("/servers", query, options);
+    }
+    getStatistics(query, options) {
+        return this.get("/servers/statistics", query, options);
+    }
+    getMainstackEvent(query, options) {
+        return this.get("/servers/mainstack-event", query, options);
+    }
+}
+exports.ServersApi = ServersApi;
+class LobbyApi extends BaseApi {
+    list(query, options) {
+        return this.get("/lobby/list", query, options);
+    }
+}
+exports.LobbyApi = LobbyApi;
+class CfgLangApi extends BaseApi {
+    list(query, options) {
+        return this.get("/cfglang", query, options);
+    }
+    compare(query, options) {
+        return this.get("/cfglang/compare", query, options);
+    }
+    deploy(payload, options) {
+        return this.post("/cfglang/deploy", payload, options);
+    }
+    create(query, payload, options) {
+        return this.http.request("POST", "/cfglang", { ...options, query, body: payload });
+    }
+    update(query, payload, options) {
+        return this.http.request("PATCH", "/cfglang", { ...options, query, body: payload });
+    }
+    deleteOne(query, options) {
+        return this.delete("/cfglang", query, options);
+    }
+}
+exports.CfgLangApi = CfgLangApi;
+class GlobalKVApi extends BaseApi {
+    list(query, options) {
+        return this.get("/globalkv", query, options);
+    }
+    getOne(key, query, options) {
+        return this.get(`/globalkv/${encodeURIComponent(key)}`, query, options);
+    }
+    create(payload, options) {
+        return this.post("/globalkv", payload, options);
+    }
+    update(key, payload, options) {
+        return this.put(`/globalkv/${encodeURIComponent(key)}`, payload, options);
+    }
+    deleteOne(key, query, options) {
+        return this.delete(`/globalkv/${encodeURIComponent(key)}`, query, options);
+    }
+    deleteBatch(payload, options) {
+        return this.http.request("DELETE", "/globalkv", { ...options, body: payload });
+    }
+}
+exports.GlobalKVApi = GlobalKVApi;
+class BroadcastApi extends BaseApi {
+    list(query, options) {
+        return this.get("/broadcast", query, options);
+    }
+    compare(query, options) {
+        return this.get("/broadcast/compare", query, options);
+    }
+    deploy(payload, options) {
+        return this.post("/broadcast/deploy", payload, options);
+    }
+    getOne(msg, query, options) {
+        return this.get(`/broadcast/${encodeURIComponent(msg)}`, query, options);
+    }
+    create(payload, options) {
+        return this.post("/broadcast", payload, options);
+    }
+    update(msg, payload, options) {
+        return this.put(`/broadcast/${encodeURIComponent(msg)}`, payload, options);
+    }
+    deleteOne(msg, payload, options) {
+        return this.http.request("DELETE", `/broadcast/${encodeURIComponent(msg)}`, {
+            ...options,
+            body: payload,
+        });
+    }
+}
+exports.BroadcastApi = BroadcastApi;
+class EaseChatApi extends BaseApi {
+    sendHlaba(payload, options) {
+        return this.post("/easechat/hlaba", payload, options);
+    }
+    listSubscriptions(query, options) {
+        return this.get("/easechat/subscriptions", query, options);
+    }
+    createSubscription(payload, options) {
+        return this.post("/easechat/subscriptions", payload, options);
+    }
+    deleteSubscription(query, options) {
+        return this.delete("/easechat/subscriptions", query, options);
+    }
+}
+exports.EaseChatApi = EaseChatApi;
+class AuditApi extends BaseApi {
+    getAuthLogs(query, options) {
+        return this.get("/audit/auth", query, options);
+    }
+    getPlayerLogs(query, options) {
+        return this.get("/audit/player", query, options);
+    }
+    getPunishmentLogs(query, options) {
+        return this.get("/audit/punishment", query, options);
+    }
+    getPermissionLogs(query, options) {
+        return this.get("/audit/permission", query, options);
+    }
+    getAdminLogs(query, options) {
+        return this.get("/audit/admin", query, options);
+    }
+    getConfigLogs(query, options) {
+        return this.get("/audit/config", query, options);
+    }
+}
+exports.AuditApi = AuditApi;
+class SpamDetectorApi extends BaseApi {
+    getStatus(query, options) {
+        return this.get("/monitor/spam-detector/status", query, options);
+    }
+    control(payload, options) {
+        return this.post("/monitor/spam-detector/control", payload, options);
+    }
+    getStats(query, options) {
+        return this.get("/monitor/spam-detector/stats", query, options);
+    }
+}
+exports.SpamDetectorApi = SpamDetectorApi;
+class MonitorApi extends BaseApi {
+    constructor(http) {
+        super(http);
+        this.spamDetector = new SpamDetectorApi(http);
+    }
+}
+exports.MonitorApi = MonitorApi;
+class PullConfigApi extends BaseApi {
+    pull(query, options) {
+        return this.get("/pull-config", query, options);
+    }
+}
+exports.PullConfigApi = PullConfigApi;
+class SystemApi extends BaseApi {
+    getRoot(query, options) {
+        return this.get("/", query, { ...options, responseType: "text" });
+    }
+    getHealth(query, options) {
+        return this.get("/health", query, options);
+    }
+}
+exports.SystemApi = SystemApi;

package/dist/http.d.ts

@@ -0,0 +1,21 @@
+import { AuthCredentials, ClientOptions, RequestOptions } from "./types";
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export declare class ECAPIError extends Error {
+    readonly status: number;
+    readonly payload: unknown;
+    readonly url: string;
+    constructor(message: string, status: number, payload: unknown, url: string);
+}
+export declare class ECAPIHttpClient {
+    private readonly baseUrl;
+    private readonly defaultHeaders;
+    private readonly timeoutMs;
+    private auth?;
+    constructor(options: ClientOptions);
+    setAuth(auth?: AuthCredentials): void;
+    clearAuth(): void;
+    setApiKey(apiKey: string): void;
+    setAppSessionToken(appSessionToken: string): void;
+    request<T = unknown>(method: HttpMethod, path: string, options?: RequestOptions): Promise<T>;
+}
+export {};

package/dist/http.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECAPIHttpClient = exports.ECAPIError = void 0;
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+function toQueryString(query) {
+    if (!query) {
+        return "";
+    }
+    const params = new URLSearchParams();
+    for (const [key, rawValue] of Object.entries(query)) {
+        if (rawValue === undefined || rawValue === null) {
+            continue;
+        }
+        if (Array.isArray(rawValue)) {
+            for (const item of rawValue) {
+                if (item !== undefined && item !== null) {
+                    params.append(key, String(item));
+                }
+            }
+            continue;
+        }
+        params.append(key, String(rawValue));
+    }
+    const value = params.toString();
+    return value ? `?${value}` : "";
+}
+function createAbortSignal(timeoutMs, signal) {
+    if (!timeoutMs || timeoutMs <= 0) {
+        return {
+            signal,
+            cleanup: () => undefined,
+        };
+    }
+    const timeoutController = new AbortController();
+    const timeoutId = setTimeout(() => timeoutController.abort(), timeoutMs);
+    if (signal) {
+        const onAbort = () => timeoutController.abort();
+        signal.addEventListener("abort", onAbort, { once: true });
+        return {
+            signal: timeoutController.signal,
+            cleanup: () => {
+                clearTimeout(timeoutId);
+                signal.removeEventListener("abort", onAbort);
+            },
+        };
+    }
+    return {
+        signal: timeoutController.signal,
+        cleanup: () => clearTimeout(timeoutId),
+    };
+}
+function applyAuth(headers, auth) {
+    if (!auth) {
+        return;
+    }
+    if (auth.type === "apiKey") {
+        headers["X-API-Key"] = auth.apiKey;
+        return;
+    }
+    headers["X-App-Session-Token"] = auth.appSessionToken;
+}
+async function parseBody(response, responseType) {
+    if (responseType === "raw") {
+        return response;
+    }
+    if (responseType === "arrayBuffer") {
+        return response.arrayBuffer();
+    }
+    if (responseType === "text") {
+        return response.text();
+    }
+    if (response.status === 204) {
+        return null;
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+        return response.json();
+    }
+    const text = await response.text();
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+class ECAPIError extends Error {
+    constructor(message, status, payload, url) {
+        super(message);
+        this.name = "ECAPIError";
+        this.status = status;
+        this.payload = payload;
+        this.url = url;
+    }
+}
+exports.ECAPIError = ECAPIError;
+class ECAPIHttpClient {
+    constructor(options) {
+        this.baseUrl = normalizeBaseUrl(options.baseUrl);
+        this.defaultHeaders = { ...(options.defaultHeaders || {}) };
+        this.timeoutMs = options.timeoutMs ?? 15000;
+        this.auth = options.auth;
+    }
+    setAuth(auth) {
+        this.auth = auth;
+    }
+    clearAuth() {
+        this.auth = undefined;
+    }
+    setApiKey(apiKey) {
+        this.auth = { type: "apiKey", apiKey };
+    }
+    setAppSessionToken(appSessionToken) {
+        this.auth = { type: "appSessionToken", appSessionToken };
+    }
+    async request(method, path, options = {}) {
+        const requestPath = path.startsWith("/") ? path : `/${path}`;
+        const queryString = toQueryString(options.query);
+        const url = `${this.baseUrl}${requestPath}${queryString}`;
+        const headers = {
+            Accept: "application/json",
+            ...this.defaultHeaders,
+            ...(options.headers || {}),
+        };
+        applyAuth(headers, options.auth === undefined ? this.auth : options.auth);
+        const init = {
+            method,
+            headers,
+        };
+        if (options.body !== undefined) {
+            if (!headers["Content-Type"]) {
+                headers["Content-Type"] = "application/json";
+            }
+            init.body =
+                headers["Content-Type"].includes("application/json") &&
+                    typeof options.body !== "string"
+                    ? JSON.stringify(options.body)
+                    : options.body;
+        }
+        const { signal, cleanup } = createAbortSignal(this.timeoutMs, options.signal);
+        init.signal = signal;
+        let response;
+        try {
+            response = await fetch(url, init);
+        }
+        catch (error) {
+            cleanup();
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new ECAPIError("Request timeout or aborted", 0, null, url);
+            }
+            throw new ECAPIError("Network request failed", 0, error, url);
+        }
+        cleanup();
+        const responseType = options.responseType ?? "json";
+        const payload = await parseBody(response, responseType);
+        if (!response.ok) {
+            throw new ECAPIError(`Request failed with status ${response.status}`, response.status, payload, url);
+        }
+        return payload;
+    }
+}
+exports.ECAPIHttpClient = ECAPIHttpClient;

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { ECAPIError } from "./http";
+import { AdminApi, AuditApi, BanApi, BroadcastApi, CfgLangApi, CountApi, EaseChatApi, GlobalKVApi, ItemApi, LobbyApi, LogApi, MonitorApi, OrderApi, PermissionApi, PlayerApi, PullConfigApi, PunishApi, ServersApi, StageApi, SystemApi, UserApi } from "./apis";
+import { AuthCredentials, ClientOptions, RequestOptions } from "./types";
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export declare class ECAPIClient {
+    private readonly http;
+    readonly user: UserApi;
+    readonly player: PlayerApi;
+    readonly admin: AdminApi;
+    readonly punish: PunishApi;
+    readonly ban: BanApi;
+    readonly permission: PermissionApi;
+    readonly log: LogApi;
+    readonly order: OrderApi;
+    readonly stage: StageApi;
+    readonly item: ItemApi;
+    readonly count: CountApi;
+    readonly servers: ServersApi;
+    readonly lobby: LobbyApi;
+    readonly cfglang: CfgLangApi;
+    readonly globalkv: GlobalKVApi;
+    readonly broadcast: BroadcastApi;
+    readonly easechat: EaseChatApi;
+    readonly audit: AuditApi;
+    readonly monitor: MonitorApi;
+    readonly pullConfig: PullConfigApi;
+    readonly system: SystemApi;
+    constructor(options: ClientOptions);
+    setAuth(auth?: AuthCredentials): void;
+    setApiKey(apiKey: string): void;
+    setAppSessionToken(appSessionToken: string): void;
+    clearAuth(): void;
+    request<T = unknown>(method: HttpMethod, path: string, options?: RequestOptions): Promise<T>;
+}
+export * from "./types";
+export { ECAPIError };

package/dist/index.js

@@ -0,0 +1,63 @@
+"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.ECAPIError = exports.ECAPIClient = void 0;
+const http_1 = require("./http");
+Object.defineProperty(exports, "ECAPIError", { enumerable: true, get: function () { return http_1.ECAPIError; } });
+const apis_1 = require("./apis");
+class ECAPIClient {
+    constructor(options) {
+        this.http = new http_1.ECAPIHttpClient(options);
+        this.user = new apis_1.UserApi(this.http);
+        this.player = new apis_1.PlayerApi(this.http);
+        this.admin = new apis_1.AdminApi(this.http);
+        this.punish = new apis_1.PunishApi(this.http);
+        this.ban = new apis_1.BanApi(this.http);
+        this.permission = new apis_1.PermissionApi(this.http);
+        this.log = new apis_1.LogApi(this.http);
+        this.order = new apis_1.OrderApi(this.http);
+        this.stage = new apis_1.StageApi(this.http);
+        this.item = new apis_1.ItemApi(this.http);
+        this.count = new apis_1.CountApi(this.http);
+        this.servers = new apis_1.ServersApi(this.http);
+        this.lobby = new apis_1.LobbyApi(this.http);
+        this.cfglang = new apis_1.CfgLangApi(this.http);
+        this.globalkv = new apis_1.GlobalKVApi(this.http);
+        this.broadcast = new apis_1.BroadcastApi(this.http);
+        this.easechat = new apis_1.EaseChatApi(this.http);
+        this.audit = new apis_1.AuditApi(this.http);
+        this.monitor = new apis_1.MonitorApi(this.http);
+        this.pullConfig = new apis_1.PullConfigApi(this.http);
+        this.system = new apis_1.SystemApi(this.http);
+    }
+    setAuth(auth) {
+        this.http.setAuth(auth);
+    }
+    setApiKey(apiKey) {
+        this.http.setApiKey(apiKey);
+    }
+    setAppSessionToken(appSessionToken) {
+        this.http.setAppSessionToken(appSessionToken);
+    }
+    clearAuth() {
+        this.http.clearAuth();
+    }
+    request(method, path, options) {
+        return this.http.request(method, path, options);
+    }
+}
+exports.ECAPIClient = ECAPIClient;
+__exportStar(require("./types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export type Primitive = string | number | boolean | null | undefined;
+export type QueryValue = Primitive | Primitive[];
+export type QueryParams = Record<string, QueryValue>;
+export type HeaderMap = Record<string, string>;
+export type ResponseType = "json" | "text" | "arrayBuffer" | "raw";
+export type AuthCredentials = {
+    type: "apiKey";
+    apiKey: string;
+} | {
+    type: "appSessionToken";
+    appSessionToken: string;
+};
+export interface ClientOptions {
+    baseUrl: string;
+    auth?: AuthCredentials;
+    timeoutMs?: number;
+    defaultHeaders?: HeaderMap;
+}
+export interface RequestOptions {
+    query?: QueryParams;
+    body?: unknown;
+    headers?: HeaderMap;
+    signal?: AbortSignal;
+    responseType?: ResponseType;
+    auth?: AuthCredentials | null;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@easecation/ecapi-sdk",
+  "version": "0.1.0",
+  "description": "ECAPI SDK for JavaScript and TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "keywords": [
+    "ecapi",
+    "easecation",
+    "sdk",
+    "typescript"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}