@ichinese/open-sdk 0.0.0-stage → 1.0.0-rc.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Center for Language Education and Cooperation (CLEC)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# iChinese Open Platform SDK for Node.js
 
-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.
+> **Prerelease 1.0.0-rc.2.** 这是预发布版，开放平台还没有正式开放，SDK 的默认地址可能连不上。This is a prerelease: the open platform is not open to the public yet, so the SDK's default address may not answer.
+
+爱中文开放平台的 Node.js 服务端 SDK：开放接口（`/open-apis/v1`）的每个接口都是一个方法，并处理令牌、重试、分页和事件推送。
+
+The server SDK of the iChinese open platform. Every operation of the open API is a method on `Client`
+(generated from the contract), plus what each app would otherwise write itself: getting the app and
+tenant tokens and renewing them before they expire, retrying after rate limits and server errors with
+backoff, paging through lists, typed errors, exchanging the web login's codes, and verifying and
+decrypting event pushes. No runtime dependencies.
+
+## Install
+
+```sh
+npm install @ichinese/open-sdk
+```
+
+Requires Node.js 20 or newer. ESM and CommonJS are both supported, with type declarations.
+
+## Quick start
+
+List an institution's members with a tenant token:
+
+```ts
+import { Client, isOpenApiError } from '@ichinese/open-sdk';
+
+const client = new Client({ appId: process.env.APP_ID!, appSecret: process.env.APP_SECRET! });
+
+try {
+  const tenant = await client.getTenant({ tenantKey });
+  console.log(`${tenant.name} (${tenant.rating})`);
+  for await (const m of client.listTenantMembersAll({}, { tenantKey })) {
+    console.log(`${m.open_id}  ${m.name}  ${m.roles.join(',')}`);
+  }
+} catch (e) {
+  // The institution's admin may have refused this scope.
+  if (isOpenApiError(e) && e.isScopeError) console.log(`not allowed (${e.reason})`);
+  else throw e;
+}
+```
+
+The `examples` directory has this one in full, a backend for the web login and a server for event pushes.
+
+## Documentation
+
+Guides and the API reference: <https://open.ichinese.cn>
+
+This repository is generated from the platform's monorepo at each release, so a change made here would be
+overwritten; please open an issue instead.
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,53 @@
+import { Operations } from './gen/operations.ts';
+import type { CallSpec, ClientOptions, RequestOptions, TokenType, UserAccessToken } from './types.ts';
+export declare class Client extends Operations {
+    readonly appId: string;
+    readonly baseUrl: string;
+    private readonly appSecret;
+    private readonly maxRetries;
+    private readonly timeoutMs;
+    private readonly fetchFn;
+    private readonly refreshBefore;
+    private readonly userAgent;
+    /** Base of the retry backoff in ms (tests make it small). */
+    retryBaseMs: number;
+    private readonly tokens;
+    private readonly inflight;
+    constructor(options: ClientOptions);
+    /** The app token (cached, renewed before it expires). */
+    appAccessToken(): Promise<string>;
+    /** The tenant token of an institution that installed the app (cached per institution, renewed). */
+    tenantAccessToken(tenantKey: string): Promise<string>;
+    /**
+     * The web login (免登): exchanges the code your page got from the JS SDK's `requestAuthCode()` for a
+     * user token and the user's `open_id`. A code from the plain-browser fallback (standard OIDC) also
+     * needs the `redirectUri` and `codeVerifier` the JS SDK returned with it. Exchange codes on your
+     * backend only: the App Secret never goes to the page.
+     */
+    exchangeAuthCode(code: string, opts?: {
+        redirectUri?: string;
+        codeVerifier?: string;
+    }): Promise<UserAccessToken>;
+    /** A new pair for a refresh token (the old one stops working). */
+    refreshUserToken(refreshToken: string): Promise<UserAccessToken>;
+    /** Revokes a user or refresh token (when the user signs out of your app). */
+    revokeToken(token: string): Promise<void>;
+    /** Forgets the cached app and tenant tokens (they are fetched again when next needed). */
+    clearTokenCache(): void;
+    /** Any open API call by method and path (`/tenant/members`), for what the generated methods do not cover. */
+    request<T = unknown>(method: CallSpec['method'], path: string, init?: {
+        query?: Record<string, unknown>;
+        body?: unknown;
+        tokenTypes?: TokenType[];
+    }, options?: RequestOptions): Promise<T>;
+    protected call<T>(spec: CallSpec, options?: RequestOptions): Promise<T>;
+    protected iterate<T>(spec: CallSpec, options?: RequestOptions): AsyncIterable<T>;
+    private credentials;
+    private cached;
+    /** The token for a call, and the cache key it came from (dropped and fetched again after a 401). */
+    private tokenFor;
+    private url;
+    private sleep;
+    private backoff;
+    private send;
+}

package/dist/errors.d.ts

@@ -0,0 +1,33 @@
+import type { ErrorReason } from './gen/meta.ts';
+/**
+ * An error answer of the open API (`{"error": {"code", "message", "request_id", "details"}}`), or a
+ * failure before one came (`code` NETWORK / TIMEOUT, `status` 0).
+ */
+export declare class OpenApiError extends Error {
+    readonly name = "OpenApiError";
+    /** HTTP status (0: no answer). */
+    readonly status: number;
+    /** Stable error code: UNAUTHENTICATED, FORBIDDEN, NOT_FOUND, VALIDATION_FAILED, CONFLICT, RATE_LIMITED, … */
+    readonly code: string;
+    readonly requestId: string | null;
+    /** `details.reason`, e.g. `scope_denied`, `token_expired`, `code_used`. */
+    readonly reason: ErrorReason | (string & {}) | null;
+    readonly details: Record<string, unknown>;
+    /** Seconds to wait (429), from Retry-After. */
+    readonly retryAfter: number | null;
+    constructor(init: {
+        status: number;
+        code: string;
+        message: string;
+        requestId?: string | null;
+        details?: Record<string, unknown>;
+        retryAfter?: number | null;
+    });
+    /** The scope the user or institution refused (`scope_denied`): the app should do without it. */
+    get scope(): string | null;
+    /** The user chose「不再询问」for the refused scope: do not ask again. */
+    get neverAsk(): boolean;
+    /** A refused, not yet asked or undeclared scope (403): degrade gracefully. */
+    get isScopeError(): boolean;
+}
+export declare const isOpenApiError: (e: unknown) => e is OpenApiError;

package/dist/events.d.ts

@@ -0,0 +1,70 @@
+import type { EventType } from './gen/meta.ts';
+export interface EventEnvelope<E = Record<string, unknown>> {
+    schema: '1.0';
+    header: {
+        event_id: string;
+        event_type: EventType;
+        create_time: string;
+        app_id: string;
+        tenant_key?: string | null;
+    };
+    event: E;
+}
+export interface UrlVerification {
+    type: 'url_verification';
+    challenge: string;
+}
+export interface CardAction {
+    schema: '1.0';
+    header: {
+        event_id: string;
+        app_id: string;
+        tenant_key?: string | null;
+        create_time: string;
+    };
+    operator?: {
+        open_id?: string;
+    };
+    action: {
+        value: Record<string, unknown>;
+    };
+    /** The conversation the card is in. */
+    chat_id?: string;
+    message_id?: string;
+}
+export type Headers = Record<string, string | string[] | undefined> | globalThis.Headers;
+/** The signature the platform puts in `X-Ich-Signature` for these values. */
+export declare function sign(signingSecret: string, timestamp: string, nonce: string, body: string | Buffer): string;
+/**
+ * Checks a push's signature and age (default: at most 5 minutes off). Throws `OpenApiError` with
+ * code `INVALID_SIGNATURE` otherwise.
+ */
+export declare function verifySignature(headers: Headers, rawBody: string | Buffer, signingSecret: string, opts?: {
+    toleranceSeconds?: number;
+    now?: number;
+}): void;
+/** Decrypts an `{"encrypt": …}` body with the app's encrypt key. */
+export declare function decrypt(encrypted: string, encryptKey: string): string;
+/**
+ * Verifies, decrypts and parses a push. Answer a `url_verification` with `{ challenge }`
+ * (`challengeResponse`), and an event with any 2xx within 5 seconds (dedupe by `header.event_id`:
+ * retries keep it).
+ */
+export declare function parseEvent<E = Record<string, unknown>>(headers: Headers, rawBody: string | Buffer, opts: {
+    signingSecret: string;
+    encryptKey?: string;
+    toleranceSeconds?: number;
+    now?: number;
+}): EventEnvelope<E> | UrlVerification;
+/** A card callback (a button of a bot's card was clicked): same signature and encryption as events. */
+export declare function parseCardAction(headers: Headers, rawBody: string | Buffer, opts: {
+    signingSecret: string;
+    encryptKey?: string;
+    toleranceSeconds?: number;
+    now?: number;
+}): CardAction | UrlVerification;
+export declare const isUrlVerification: (x: unknown) => x is UrlVerification;
+/** The answer to the address check. */
+export declare const challengeResponse: (v: UrlVerification) => {
+    challenge: string;
+};

package/dist/gen/meta.d.ts

@@ -0,0 +1,44 @@
+/** The SDK's version (it follows the open API's). */
+export declare const VERSION = "1.0.0-rc.2";
+/** The open API's address from the release configuration (sdks/release.json); `baseUrl` overrides it. */
+export declare const DEFAULT_BASE_URL = "https://open.ichinese.cn";
+export declare const API_PREFIX = "/open-apis/v1";
+/** Every scope (permission code) of the open API. */
+export declare const SCOPES: readonly ["openid", "profile", "org:member:readonly", "org:member", "class:readonly", "class:member", "schedule:readonly", "schedule", "attendance:readonly", "coursework", "grade:readonly", "course", "learning:progress:readonly", "im:message:send_as_bot", "im:chat:readonly", "notify:send", "live:recording:readonly", "event", "event:registration:readonly", "job", "job:candidate:readonly", "trial", "trade:order:readonly", "review", "profile:interest:readonly", "profile:interest", "profile:learning:readonly", "report:create"];
+export type Scope = (typeof SCOPES)[number];
+/** The events an app can subscribe to. */
+export declare const EVENT_TYPES: readonly ["app.installed", "app.uninstalled", "app.scopes_changed", "coursework.submitted", "grade.published", "schedule.session_changed", "event.registered", "job.candidate_applied", "trade.order_paid", "review.created", "trial.booked", "im.message_received"];
+export type EventType = (typeof EVENT_TYPES)[number];
+/** `error.details.reason` values. */
+export declare const ERROR_REASONS: readonly ["invalid_credentials", "invalid_token", "token_expired", "token_type", "app_disabled", "not_installed", "not_available", "scope_denied", "scope_pending", "scope_not_declared", "gold_only", "rate_limited", "daily_quota_exceeded", "code_expired", "code_used", "code_invalid", "redirect_uri_mismatch", "origin_not_trusted", "ip_not_allowed"];
+export type ErrorReason = (typeof ERROR_REASONS)[number];
+/** Token types each operation accepts (the client picks the token by them). */
+export declare const OPERATION_TOKENS: Record<string, readonly ('app' | 'tenant' | 'user')[]>;
+export declare const SCOPE_OPENID = "openid";
+export declare const SCOPE_PROFILE = "profile";
+export declare const SCOPE_ORG_MEMBER_READONLY = "org:member:readonly";
+export declare const SCOPE_ORG_MEMBER = "org:member";
+export declare const SCOPE_CLASS_READONLY = "class:readonly";
+export declare const SCOPE_CLASS_MEMBER = "class:member";
+export declare const SCOPE_SCHEDULE_READONLY = "schedule:readonly";
+export declare const SCOPE_SCHEDULE = "schedule";
+export declare const SCOPE_ATTENDANCE_READONLY = "attendance:readonly";
+export declare const SCOPE_COURSEWORK = "coursework";
+export declare const SCOPE_GRADE_READONLY = "grade:readonly";
+export declare const SCOPE_COURSE = "course";
+export declare const SCOPE_LEARNING_PROGRESS_READONLY = "learning:progress:readonly";
+export declare const SCOPE_IM_MESSAGE_SEND_AS_BOT = "im:message:send_as_bot";
+export declare const SCOPE_IM_CHAT_READONLY = "im:chat:readonly";
+export declare const SCOPE_NOTIFY_SEND = "notify:send";
+export declare const SCOPE_LIVE_RECORDING_READONLY = "live:recording:readonly";
+export declare const SCOPE_EVENT = "event";
+export declare const SCOPE_EVENT_REGISTRATION_READONLY = "event:registration:readonly";
+export declare const SCOPE_JOB = "job";
+export declare const SCOPE_JOB_CANDIDATE_READONLY = "job:candidate:readonly";
+export declare const SCOPE_TRIAL = "trial";
+export declare const SCOPE_TRADE_ORDER_READONLY = "trade:order:readonly";
+export declare const SCOPE_REVIEW = "review";
+export declare const SCOPE_PROFILE_INTEREST_READONLY = "profile:interest:readonly";
+export declare const SCOPE_PROFILE_INTEREST = "profile:interest";
+export declare const SCOPE_PROFILE_LEARNING_READONLY = "profile:learning:readonly";
+export declare const SCOPE_REPORT_CREATE = "report:create";

package/dist/gen/operations.d.ts

@@ -0,0 +1,177 @@
+import type { CallSpec, RequestOptions } from '../types.ts';
+import type { operations } from './schema.ts';
+type Op = keyof operations;
+/** The query parameters of an operation. */
+export type QueryOf<K extends Op> = operations[K] extends {
+    parameters: {
+        query?: infer P;
+    };
+} ? NonNullable<P> : never;
+/** The JSON request body of an operation. */
+export type BodyOf<K extends Op> = operations[K] extends {
+    requestBody: {
+        content: {
+            'application/json': infer T;
+        };
+    };
+} ? T : never;
+/** What an operation answers (its 2xx JSON body; `void` for 204). */
+export type ResultOf<K extends Op> = operations[K]['responses'] extends infer R ? R extends {
+    200: {
+        content: {
+            'application/json': infer T;
+        };
+    };
+} ? T : R extends {
+    201: {
+        content: {
+            'application/json': infer T;
+        };
+    };
+} ? T : void : never;
+/** One item of a paged list. */
+export type ItemOf<K extends Op> = ResultOf<K> extends {
+    items: (infer I)[];
+} ? I : never;
+/** Every operation of the open API as a method; the client (client.ts) supplies tokens, retries and paging. */
+export declare abstract class Operations {
+    protected abstract call<T>(spec: CallSpec, options?: RequestOptions): Promise<T>;
+    protected abstract iterate<T>(spec: CallSpec, options?: RequestOptions): AsyncIterable<T>;
+    /** The current user (user token) (`GET /user/info`; user token; scopes: openid) */
+    getUserInfo(options?: RequestOptions): Promise<ResultOf<'getUserInfo'>>;
+    /** The institution that installed the app (tenant token) (`GET /tenant`; tenant token) */
+    getTenant(options?: RequestOptions): Promise<ResultOf<'getTenant'>>;
+    /** The institution's members (directory); members in all regions are listed together, without revealing regions (`GET /tenant/members`; tenant token; scopes: org:member:readonly, org:member) */
+    listTenantMembers(query?: QueryOf<'listTenantMembers'>, options?: RequestOptions): Promise<ResultOf<'listTenantMembers'>>;
+    /** Every item of `listTenantMembers`, page after page. */
+    listTenantMembersAll(query?: Omit<QueryOf<'listTenantMembers'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listTenantMembers'>>;
+    /** Invite a member (they join only after accepting, the same as inviting in the institution admin) (`POST /tenant/invitations`; tenant token; scopes: org:member) */
+    inviteTenantMember(body: BodyOf<'inviteTenantMember'>, options?: RequestOptions): Promise<ResultOf<'inviteTenantMember'>>;
+    /** Classes: with a tenant token, all of the institution's classes; with a user token, the classes this user teaches (`GET /classes`; tenant / user token; scopes: class:readonly, class:member) */
+    listClasses(query?: QueryOf<'listClasses'>, options?: RequestOptions): Promise<ResultOf<'listClasses'>>;
+    /** Every item of `listClasses`, page after page. */
+    listClassesAll(query?: Omit<QueryOf<'listClasses'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listClasses'>>;
+    /** A class (`GET /classes/{class_id}`; tenant / user token; scopes: class:readonly, class:member) */
+    getClass(classId: string, options?: RequestOptions): Promise<ResultOf<'getClass'>>;
+    /** Roster (teachers and learners) (`GET /classes/{class_id}/members`; tenant / user token; scopes: class:readonly, class:member) */
+    listClassMembers(classId: string, query?: QueryOf<'listClassMembers'>, options?: RequestOptions): Promise<ResultOf<'listClassMembers'>>;
+    /** Every item of `listClassMembers`, page after page. */
+    listClassMembersAll(classId: string, query?: Omit<QueryOf<'listClassMembers'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listClassMembers'>>;
+    /** Add one of the institution's members to a class (as a learner) (`POST /classes/{class_id}/members`; tenant / user token; scopes: class:member) */
+    addClassMember(classId: string, body: BodyOf<'addClassMember'>, options?: RequestOptions): Promise<ResultOf<'addClassMember'>>;
+    /** Remove a learner from a class (`DELETE /classes/{class_id}/members/{open_id}`; tenant / user token; scopes: class:member) */
+    removeClassMember(classId: string, openId: string, options?: RequestOptions): Promise<ResultOf<'removeClassMember'>>;
+    /** A class's sessions (within a time range of at most 100 days) (`GET /classes/{class_id}/sessions`; tenant / user token; scopes: schedule:readonly, schedule) */
+    listClassSessions(classId: string, query: QueryOf<'listClassSessions'>, options?: RequestOptions): Promise<ResultOf<'listClassSessions'>>;
+    /** Every item of `listClassSessions`, page after page. */
+    listClassSessionsAll(classId: string, query?: Omit<QueryOf<'listClassSessions'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listClassSessions'>>;
+    /** Cancel a class session (members are notified, the same as cancelling in the timetable) (`POST /classes/{class_id}/sessions/{session_id}/cancel`; tenant / user token; scopes: schedule) */
+    cancelClassSession(classId: string, sessionId: string, options?: RequestOptions): Promise<ResultOf<'cancelClassSession'>>;
+    /** Reschedule a class session (`POST /classes/{class_id}/sessions/{session_id}/reschedule`; tenant / user token; scopes: schedule) */
+    rescheduleClassSession(classId: string, sessionId: string, body: BodyOf<'rescheduleClassSession'>, options?: RequestOptions): Promise<ResultOf<'rescheduleClassSession'>>;
+    /** Attendance of a class session (who came, and how long they stayed in the classroom) (`GET /classes/{class_id}/sessions/{session_id}/attendance`; tenant / user token; scopes: attendance:readonly) */
+    getSessionAttendance(classId: string, sessionId: string, options?: RequestOptions): Promise<ResultOf<'getSessionAttendance'>>;
+    /** A class's assignments and exams (`GET /classes/{class_id}/assignments`; tenant / user token; scopes: coursework, grade:readonly) */
+    listAssignments(classId: string, query?: QueryOf<'listAssignments'>, options?: RequestOptions): Promise<ResultOf<'listAssignments'>>;
+    /** Every item of `listAssignments`, page after page. */
+    listAssignmentsAll(classId: string, query?: Omit<QueryOf<'listAssignments'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listAssignments'>>;
+    /** Create an assignment (text instructions + due time; questions are edited in the platform). With a user token, the user must be a teacher of this class (`POST /classes/{class_id}/assignments`; tenant / user token; scopes: coursework) */
+    createAssignment(classId: string, body: BodyOf<'createAssignment'>, options?: RequestOptions): Promise<ResultOf<'createAssignment'>>;
+    /** An assignment's submissions and scores (`GET /classes/{class_id}/assignments/{assignment_id}/submissions`; tenant / user token; scopes: grade:readonly) */
+    listSubmissions(classId: string, assignmentId: string, query?: QueryOf<'listSubmissions'>, options?: RequestOptions): Promise<ResultOf<'listSubmissions'>>;
+    /** Every item of `listSubmissions`, page after page. */
+    listSubmissionsAll(classId: string, assignmentId: string, query?: Omit<QueryOf<'listSubmissions'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listSubmissions'>>;
+    /** Write back a score (the result of external grading); the learner is notified that grades are published (`PUT /classes/{class_id}/assignments/{assignment_id}/submissions/{open_id}/score`; tenant / user token; scopes: coursework) */
+    setSubmissionScore(classId: string, assignmentId: string, openId: string, body: BodyOf<'setSubmissionScore'>, options?: RequestOptions): Promise<ResultOf<'setSubmissionScore'>>;
+    /** Export grades (one row per learner per assignment) (`GET /classes/{class_id}/grades`; tenant / user token; scopes: grade:readonly) */
+    exportClassGrades(classId: string, query?: QueryOf<'exportClassGrades'>, options?: RequestOptions): Promise<ResultOf<'exportClassGrades'>>;
+    /** Every item of `exportClassGrades`, page after page. */
+    exportClassGradesAll(classId: string, query?: Omit<QueryOf<'exportClassGrades'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'exportClassGrades'>>;
+    /** The institution's recorded courses (tenant token) or the courses this user authored (user token) (`GET /courses`; tenant / user token; scopes: course, learning:progress:readonly) */
+    listCourses(query?: QueryOf<'listCourses'>, options?: RequestOptions): Promise<ResultOf<'listCourses'>>;
+    /** Every item of `listCourses`, page after page. */
+    listCoursesAll(query?: Omit<QueryOf<'listCourses'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listCourses'>>;
+    /** Course outline (titles and order of chapters and lessons) (`GET /courses/{course_id}`; tenant / user token; scopes: course) */
+    getCourseOutline(courseId: string, options?: RequestOptions): Promise<ResultOf<'getCourseOutline'>>;
+    /** Change a course's title and introduction; a published course that is changed goes through review again as usual (`PATCH /courses/{course_id}`; tenant / user token; scopes: course) */
+    updateCourseOutline(courseId: string, body: BodyOf<'updateCourseOutline'>, options?: RequestOptions): Promise<ResultOf<'updateCourseOutline'>>;
+    /** Learners' learning progress (number of lessons completed). A user token can only see its own (`GET /courses/{course_id}/progress`; tenant / user token; scopes: learning:progress:readonly) */
+    listCourseProgress(courseId: string, query?: QueryOf<'listCourseProgress'>, options?: RequestOptions): Promise<ResultOf<'listCourseProgress'>>;
+    /** Every item of `listCourseProgress`, page after page. */
+    listCourseProgressAll(courseId: string, query?: Omit<QueryOf<'listCourseProgress'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listCourseProgress'>>;
+    /** Send a bot message (text or card) to a group chat the bot is in, or privately to a user who installed the app (`POST /im/messages`; tenant / app token; scopes: im:message:send_as_bot) */
+    sendBotMessage(body: BodyOf<'sendBotMessage'>, options?: RequestOptions): Promise<ResultOf<'sendBotMessage'>>;
+    /** Group chats the bot is in (`GET /im/chats`; tenant / app token; scopes: im:chat:readonly) */
+    listBotChats(query?: QueryOf<'listBotChats'>, options?: RequestOptions): Promise<ResultOf<'listBotChats'>>;
+    /** Every item of `listBotChats`, page after page. */
+    listBotChatsAll(query?: Omit<QueryOf<'listBotChats'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listBotChats'>>;
+    /** Send a notification to members of this institution (it goes to "System notifications" and is pushed according to each recipient's notification settings and quiet hours) (`POST /notifications`; tenant token; scopes: notify:send) */
+    sendNotification(body: BodyOf<'sendNotification'>, options?: RequestOptions): Promise<ResultOf<'sendNotification'>>;
+    /** Replays and post-class summaries of a class's live sessions (no playback URL; `watch_url` opens the replay page in the platform) (`GET /classes/{class_id}/recordings`; tenant / user token; scopes: live:recording:readonly) */
+    listClassRecordings(classId: string, query?: QueryOf<'listClassRecordings'>, options?: RequestOptions): Promise<ResultOf<'listClassRecordings'>>;
+    /** Every item of `listClassRecordings`, page after page. */
+    listClassRecordingsAll(classId: string, query?: Omit<QueryOf<'listClassRecordings'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listClassRecordings'>>;
+    /** The institution's events (including drafts and those pending review) (`GET /events`; tenant token; scopes: event, event:registration:readonly) */
+    listTenantEvents(query?: QueryOf<'listTenantEvents'>, options?: RequestOptions): Promise<ResultOf<'listTenantEvents'>>;
+    /** Every item of `listTenantEvents`, page after page. */
+    listTenantEventsAll(query?: Omit<QueryOf<'listTenantEvents'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listTenantEvents'>>;
+    /** Create an event (a draft; the institution publishes it in its console, moderated as usual) (`POST /events`; tenant token; scopes: event) */
+    createTenantEvent(body: BodyOf<'createTenantEvent'>, options?: RequestOptions): Promise<ResultOf<'createTenantEvent'>>;
+    /** Change an event (the same fields as event editing in the platform's institution console) (`PATCH /events/{event_id}`; tenant token; scopes: event) */
+    updateTenantEvent(eventId: string, body: BodyOf<'updateTenantEvent'>, options?: RequestOptions): Promise<ResultOf<'updateTenantEvent'>>;
+    /** An event's registrations and check-ins (`GET /events/{event_id}/registrations`; tenant token; scopes: event:registration:readonly) */
+    listEventRegistrations(eventId: string, query?: QueryOf<'listEventRegistrations'>, options?: RequestOptions): Promise<ResultOf<'listEventRegistrations'>>;
+    /** Every item of `listEventRegistrations`, page after page. */
+    listEventRegistrationsAll(eventId: string, query?: Omit<QueryOf<'listEventRegistrations'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listEventRegistrations'>>;
+    /** The institution's job postings (including drafts and those pending review) (`GET /jobs`; tenant token; scopes: job, job:candidate:readonly) */
+    listTenantJobs(query?: QueryOf<'listTenantJobs'>, options?: RequestOptions): Promise<ResultOf<'listTenantJobs'>>;
+    /** Every item of `listTenantJobs`, page after page. */
+    listTenantJobsAll(query?: Omit<QueryOf<'listTenantJobs'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listTenantJobs'>>;
+    /** Sync in a job posting (as a draft; submitting and publishing still go through the institution's review and NetEase Yidun automatic review) (`POST /jobs`; tenant token; scopes: job) */
+    createTenantJob(body: BodyOf<'createTenantJob'>, options?: RequestOptions): Promise<ResultOf<'createTenantJob'>>;
+    /** A job's candidates (the fields they agreed to give the institution when applying) (`GET /jobs/{job_id}/candidates`; tenant token; scopes: job:candidate:readonly) */
+    listJobCandidates(jobId: string, query?: QueryOf<'listJobCandidates'>, options?: RequestOptions): Promise<ResultOf<'listJobCandidates'>>;
+    /** Every item of `listJobCandidates`, page after page. */
+    listJobCandidatesAll(jobId: string, query?: Omit<QueryOf<'listJobCandidates'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listJobCandidates'>>;
+    /** The institution's teaching sites (use their venue_id to schedule trial slots) (`GET /trial/venues`; tenant token; scopes: trial) */
+    listTrialVenues(query?: QueryOf<'listTrialVenues'>, options?: RequestOptions): Promise<ResultOf<'listTrialVenues'>>;
+    /** Every item of `listTrialVenues`, page after page. */
+    listTrialVenuesAll(query?: Omit<QueryOf<'listTrialVenues'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listTrialVenues'>>;
+    /** Trial lesson slots (by default only those not over yet, by time) (`GET /trial/slots`; tenant token; scopes: trial) */
+    listTrialSlots(query?: QueryOf<'listTrialSlots'>, options?: RequestOptions): Promise<ResultOf<'listTrialSlots'>>;
+    /** Every item of `listTrialSlots`, page after page. */
+    listTrialSlotsAll(query?: Omit<QueryOf<'listTrialSlots'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listTrialSlots'>>;
+    /** Schedule trial lesson slots (they can repeat weekly); the teaching site must be published (`POST /trial/slots`; tenant token; scopes: trial) */
+    createTrialSlots(body: BodyOf<'createTrialSlots'>, options?: RequestOptions): Promise<ResultOf<'createTrialSlots'>>;
+    /** Cancel a trial lesson slot (whoever booked it is notified as usual; the booking is cancelled with it) (`POST /trial/slots/{slot_id}/cancel`; tenant token; scopes: trial) */
+    cancelTrialSlot(slotId: string, body?: BodyOf<'cancelTrialSlot'>, options?: RequestOptions): Promise<ResultOf<'cancelTrialSlot'>>;
+    /** Trial lesson bookings at the institution's teaching sites (`GET /trial/bookings`; tenant token; scopes: trial) */
+    listTrialBookings(query?: QueryOf<'listTrialBookings'>, options?: RequestOptions): Promise<ResultOf<'listTrialBookings'>>;
+    /** Every item of `listTrialBookings`, page after page. */
+    listTrialBookingsAll(query?: Omit<QueryOf<'listTrialBookings'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listTrialBookings'>>;
+    /** Confirm a trial lesson booking (`POST /trial/bookings/{booking_id}/confirm`; tenant token; scopes: trial) */
+    confirmTrialBooking(bookingId: string, options?: RequestOptions): Promise<ResultOf<'confirmTrialBooking'>>;
+    /** The institution's orders (read-only, for reconciliation). Write operations involving money are not open (`GET /trade/orders`; tenant token; scopes: trade:order:readonly) */
+    listTradeOrders(query?: QueryOf<'listTradeOrders'>, options?: RequestOptions): Promise<ResultOf<'listTradeOrders'>>;
+    /** Every item of `listTradeOrders`, page after page. */
+    listTradeOrdersAll(query?: Omit<QueryOf<'listTradeOrders'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listTradeOrders'>>;
+    /** Reviews of this institution (and its courses and teaching sites) (`GET /reviews`; tenant token; scopes: review) */
+    listTenantReviews(query?: QueryOf<'listTenantReviews'>, options?: RequestOptions): Promise<ResultOf<'listTenantReviews'>>;
+    /** Every item of `listTenantReviews`, page after page. */
+    listTenantReviewsAll(query?: Omit<QueryOf<'listTenantReviews'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listTenantReviews'>>;
+    /** Reply to a review on behalf of the institution (one reply per review; the content is moderated as usual) (`POST /reviews/{review_id}/reply`; tenant token; scopes: review) */
+    replyReview(reviewId: string, body: BodyOf<'replyReview'>, options?: RequestOptions): Promise<ResultOf<'replyReview'>>;
+    /** Public courses, events and jobs shown in this region (`GET /public/{kind}`; app / tenant / user token) */
+    listPublicContent(kind: string, query?: QueryOf<'listPublicContent'>, options?: RequestOptions): Promise<ResultOf<'listPublicContent'>>;
+    /** Every item of `listPublicContent`, page after page. */
+    listPublicContentAll(kind: string, query?: Omit<QueryOf<'listPublicContent'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listPublicContent'>>;
+    /** The user's interest profile (weighted tags of topics and content types; raw browsing and interaction records are not given) (`GET /user/profile/interests`; user token; scopes: profile:interest:readonly) */
+    getUserInterests(options?: RequestOptions): Promise<ResultOf<'getUserInterests'>>;
+    /** Add an interest signal with its source (`POST /user/profile/interest_signals`; user token; scopes: profile:interest) */
+    addInterestSignal(body: BodyOf<'addInterestSignal'>, options?: RequestOptions): Promise<ResultOf<'addInterestSignal'>>;
+    /** The user's learning profile (level, goals, languages being learned) (`GET /user/profile/learning`; user token; scopes: profile:learning:readonly) */
+    getUserLearningProfile(options?: RequestOptions): Promise<ResultOf<'getUserLearningProfile'>>;
+    /** Report a piece of public content on behalf of a user (it enters the platform's moderation queue; the user can see it in their own report history) (`POST /reports`; user token; scopes: report:create) */
+    reportOnBehalf(body: BodyOf<'reportOnBehalf'>, options?: RequestOptions): Promise<ResultOf<'reportOnBehalf'>>;
+}
+export {};