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

package/dist/index.js

@@ -0,0 +1,820 @@
+// src/errors.ts
+var OpenApiError = class extends Error {
+  name = "OpenApiError";
+  /** HTTP status (0: no answer). */
+  status;
+  /** Stable error code: UNAUTHENTICATED, FORBIDDEN, NOT_FOUND, VALIDATION_FAILED, CONFLICT, RATE_LIMITED, … */
+  code;
+  requestId;
+  /** `details.reason`, e.g. `scope_denied`, `token_expired`, `code_used`. */
+  reason;
+  details;
+  /** Seconds to wait (429), from Retry-After. */
+  retryAfter;
+  constructor(init) {
+    super(init.message || init.code);
+    this.status = init.status;
+    this.code = init.code;
+    this.requestId = init.requestId ?? null;
+    this.details = init.details ?? {};
+    this.reason = typeof this.details.reason === "string" ? this.details.reason : null;
+    this.retryAfter = init.retryAfter ?? null;
+  }
+  /** The scope the user or institution refused (`scope_denied`): the app should do without it. */
+  get scope() {
+    return typeof this.details.scope === "string" ? this.details.scope : null;
+  }
+  /** The user chose「不再询问」for the refused scope: do not ask again. */
+  get neverAsk() {
+    return this.details.never_ask === true;
+  }
+  /** A refused, not yet asked or undeclared scope (403): degrade gracefully. */
+  get isScopeError() {
+    return this.status === 403 && ["scope_denied", "scope_pending", "scope_not_declared", "gold_only"].includes(String(this.reason));
+  }
+};
+var isOpenApiError = (e) => e instanceof OpenApiError;
+
+// src/gen/meta.ts
+var VERSION = "1.0.0-rc.2";
+var DEFAULT_BASE_URL = "https://open.ichinese.cn";
+var API_PREFIX = "/open-apis/v1";
+var SCOPES = [
+  "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"
+];
+var EVENT_TYPES = [
+  "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"
+];
+var ERROR_REASONS = [
+  "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"
+];
+var OPERATION_TOKENS = {
+  getUserInfo: ["user"],
+  getTenant: ["tenant"],
+  listTenantMembers: ["tenant"],
+  inviteTenantMember: ["tenant"],
+  listClasses: ["tenant", "user"],
+  getClass: ["tenant", "user"],
+  listClassMembers: ["tenant", "user"],
+  addClassMember: ["tenant", "user"],
+  removeClassMember: ["tenant", "user"],
+  listClassSessions: ["tenant", "user"],
+  cancelClassSession: ["tenant", "user"],
+  rescheduleClassSession: ["tenant", "user"],
+  getSessionAttendance: ["tenant", "user"],
+  listAssignments: ["tenant", "user"],
+  createAssignment: ["tenant", "user"],
+  listSubmissions: ["tenant", "user"],
+  setSubmissionScore: ["tenant", "user"],
+  exportClassGrades: ["tenant", "user"],
+  listCourses: ["tenant", "user"],
+  getCourseOutline: ["tenant", "user"],
+  updateCourseOutline: ["tenant", "user"],
+  listCourseProgress: ["tenant", "user"],
+  sendBotMessage: ["tenant", "app"],
+  listBotChats: ["tenant", "app"],
+  sendNotification: ["tenant"],
+  listClassRecordings: ["tenant", "user"],
+  listTenantEvents: ["tenant"],
+  createTenantEvent: ["tenant"],
+  updateTenantEvent: ["tenant"],
+  listEventRegistrations: ["tenant"],
+  listTenantJobs: ["tenant"],
+  createTenantJob: ["tenant"],
+  listJobCandidates: ["tenant"],
+  listTrialVenues: ["tenant"],
+  listTrialSlots: ["tenant"],
+  createTrialSlots: ["tenant"],
+  cancelTrialSlot: ["tenant"],
+  listTrialBookings: ["tenant"],
+  confirmTrialBooking: ["tenant"],
+  listTradeOrders: ["tenant"],
+  listTenantReviews: ["tenant"],
+  replyReview: ["tenant"],
+  listPublicContent: ["app", "tenant", "user"],
+  getUserInterests: ["user"],
+  addInterestSignal: ["user"],
+  getUserLearningProfile: ["user"],
+  reportOnBehalf: ["user"]
+};
+var SCOPE_OPENID = "openid";
+var SCOPE_PROFILE = "profile";
+var SCOPE_ORG_MEMBER_READONLY = "org:member:readonly";
+var SCOPE_ORG_MEMBER = "org:member";
+var SCOPE_CLASS_READONLY = "class:readonly";
+var SCOPE_CLASS_MEMBER = "class:member";
+var SCOPE_SCHEDULE_READONLY = "schedule:readonly";
+var SCOPE_SCHEDULE = "schedule";
+var SCOPE_ATTENDANCE_READONLY = "attendance:readonly";
+var SCOPE_COURSEWORK = "coursework";
+var SCOPE_GRADE_READONLY = "grade:readonly";
+var SCOPE_COURSE = "course";
+var SCOPE_LEARNING_PROGRESS_READONLY = "learning:progress:readonly";
+var SCOPE_IM_MESSAGE_SEND_AS_BOT = "im:message:send_as_bot";
+var SCOPE_IM_CHAT_READONLY = "im:chat:readonly";
+var SCOPE_NOTIFY_SEND = "notify:send";
+var SCOPE_LIVE_RECORDING_READONLY = "live:recording:readonly";
+var SCOPE_EVENT = "event";
+var SCOPE_EVENT_REGISTRATION_READONLY = "event:registration:readonly";
+var SCOPE_JOB = "job";
+var SCOPE_JOB_CANDIDATE_READONLY = "job:candidate:readonly";
+var SCOPE_TRIAL = "trial";
+var SCOPE_TRADE_ORDER_READONLY = "trade:order:readonly";
+var SCOPE_REVIEW = "review";
+var SCOPE_PROFILE_INTEREST_READONLY = "profile:interest:readonly";
+var SCOPE_PROFILE_INTEREST = "profile:interest";
+var SCOPE_PROFILE_LEARNING_READONLY = "profile:learning:readonly";
+var SCOPE_REPORT_CREATE = "report:create";
+
+// src/gen/operations.ts
+var Operations = class {
+  /** The current user (user token) (`GET /user/info`; user token; scopes: openid) */
+  getUserInfo(options) {
+    return this.call({ id: "getUserInfo", method: "GET", path: "/user/info", pathParams: {}, tokenTypes: ["user"] }, options);
+  }
+  /** The institution that installed the app (tenant token) (`GET /tenant`; tenant token) */
+  getTenant(options) {
+    return this.call({ id: "getTenant", method: "GET", path: "/tenant", pathParams: {}, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "listTenantMembers", method: "GET", path: "/tenant/members", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listTenantMembers`, page after page. */
+  listTenantMembersAll(query, options) {
+    return this.iterate({ id: "listTenantMembers", method: "GET", path: "/tenant/members", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "inviteTenantMember", method: "POST", path: "/tenant/invitations", pathParams: {}, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "listClasses", method: "GET", path: "/classes", pathParams: {}, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listClasses`, page after page. */
+  listClassesAll(query, options) {
+    return this.iterate({ id: "listClasses", method: "GET", path: "/classes", pathParams: {}, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** A class (`GET /classes/{class_id}`; tenant / user token; scopes: class:readonly, class:member) */
+  getClass(classId, options) {
+    return this.call({ id: "getClass", method: "GET", path: "/classes/{class_id}", pathParams: { class_id: classId }, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Roster (teachers and learners) (`GET /classes/{class_id}/members`; tenant / user token; scopes: class:readonly, class:member) */
+  listClassMembers(classId, query, options) {
+    return this.call({ id: "listClassMembers", method: "GET", path: "/classes/{class_id}/members", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listClassMembers`, page after page. */
+  listClassMembersAll(classId, query, options) {
+    return this.iterate({ id: "listClassMembers", method: "GET", path: "/classes/{class_id}/members", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, body, options) {
+    return this.call({ id: "addClassMember", method: "POST", path: "/classes/{class_id}/members", pathParams: { class_id: classId }, body, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Remove a learner from a class (`DELETE /classes/{class_id}/members/{open_id}`; tenant / user token; scopes: class:member) */
+  removeClassMember(classId, openId, options) {
+    return this.call({ id: "removeClassMember", method: "DELETE", path: "/classes/{class_id}/members/{open_id}", pathParams: { class_id: classId, open_id: openId }, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, query, options) {
+    return this.call({ id: "listClassSessions", method: "GET", path: "/classes/{class_id}/sessions", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listClassSessions`, page after page. */
+  listClassSessionsAll(classId, query, options) {
+    return this.iterate({ id: "listClassSessions", method: "GET", path: "/classes/{class_id}/sessions", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, sessionId, options) {
+    return this.call({ id: "cancelClassSession", method: "POST", path: "/classes/{class_id}/sessions/{session_id}/cancel", pathParams: { class_id: classId, session_id: sessionId }, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Reschedule a class session (`POST /classes/{class_id}/sessions/{session_id}/reschedule`; tenant / user token; scopes: schedule) */
+  rescheduleClassSession(classId, sessionId, body, options) {
+    return this.call({ id: "rescheduleClassSession", method: "POST", path: "/classes/{class_id}/sessions/{session_id}/reschedule", pathParams: { class_id: classId, session_id: sessionId }, body, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, sessionId, options) {
+    return this.call({ id: "getSessionAttendance", method: "GET", path: "/classes/{class_id}/sessions/{session_id}/attendance", pathParams: { class_id: classId, session_id: sessionId }, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** A class's assignments and exams (`GET /classes/{class_id}/assignments`; tenant / user token; scopes: coursework, grade:readonly) */
+  listAssignments(classId, query, options) {
+    return this.call({ id: "listAssignments", method: "GET", path: "/classes/{class_id}/assignments", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listAssignments`, page after page. */
+  listAssignmentsAll(classId, query, options) {
+    return this.iterate({ id: "listAssignments", method: "GET", path: "/classes/{class_id}/assignments", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, body, options) {
+    return this.call({ id: "createAssignment", method: "POST", path: "/classes/{class_id}/assignments", pathParams: { class_id: classId }, body, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** An assignment's submissions and scores (`GET /classes/{class_id}/assignments/{assignment_id}/submissions`; tenant / user token; scopes: grade:readonly) */
+  listSubmissions(classId, assignmentId, query, options) {
+    return this.call({ id: "listSubmissions", method: "GET", path: "/classes/{class_id}/assignments/{assignment_id}/submissions", pathParams: { class_id: classId, assignment_id: assignmentId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listSubmissions`, page after page. */
+  listSubmissionsAll(classId, assignmentId, query, options) {
+    return this.iterate({ id: "listSubmissions", method: "GET", path: "/classes/{class_id}/assignments/{assignment_id}/submissions", pathParams: { class_id: classId, assignment_id: assignmentId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, assignmentId, openId, body, options) {
+    return this.call({ id: "setSubmissionScore", method: "PUT", path: "/classes/{class_id}/assignments/{assignment_id}/submissions/{open_id}/score", pathParams: { class_id: classId, assignment_id: assignmentId, open_id: openId }, body, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Export grades (one row per learner per assignment) (`GET /classes/{class_id}/grades`; tenant / user token; scopes: grade:readonly) */
+  exportClassGrades(classId, query, options) {
+    return this.call({ id: "exportClassGrades", method: "GET", path: "/classes/{class_id}/grades", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `exportClassGrades`, page after page. */
+  exportClassGradesAll(classId, query, options) {
+    return this.iterate({ id: "exportClassGrades", method: "GET", path: "/classes/{class_id}/grades", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "listCourses", method: "GET", path: "/courses", pathParams: {}, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listCourses`, page after page. */
+  listCoursesAll(query, options) {
+    return this.iterate({ id: "listCourses", method: "GET", path: "/courses", pathParams: {}, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Course outline (titles and order of chapters and lessons) (`GET /courses/{course_id}`; tenant / user token; scopes: course) */
+  getCourseOutline(courseId, options) {
+    return this.call({ id: "getCourseOutline", method: "GET", path: "/courses/{course_id}", pathParams: { course_id: courseId }, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, body, options) {
+    return this.call({ id: "updateCourseOutline", method: "PATCH", path: "/courses/{course_id}", pathParams: { course_id: courseId }, body, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, query, options) {
+    return this.call({ id: "listCourseProgress", method: "GET", path: "/courses/{course_id}/progress", pathParams: { course_id: courseId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listCourseProgress`, page after page. */
+  listCourseProgressAll(courseId, query, options) {
+    return this.iterate({ id: "listCourseProgress", method: "GET", path: "/courses/{course_id}/progress", pathParams: { course_id: courseId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "sendBotMessage", method: "POST", path: "/im/messages", pathParams: {}, body, tokenTypes: ["tenant", "app"] }, options);
+  }
+  /** Group chats the bot is in (`GET /im/chats`; tenant / app token; scopes: im:chat:readonly) */
+  listBotChats(query, options) {
+    return this.call({ id: "listBotChats", method: "GET", path: "/im/chats", pathParams: {}, query, tokenTypes: ["tenant", "app"] }, options);
+  }
+  /** Every item of `listBotChats`, page after page. */
+  listBotChatsAll(query, options) {
+    return this.iterate({ id: "listBotChats", method: "GET", path: "/im/chats", pathParams: {}, query, tokenTypes: ["tenant", "app"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "sendNotification", method: "POST", path: "/notifications", pathParams: {}, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, query, options) {
+    return this.call({ id: "listClassRecordings", method: "GET", path: "/classes/{class_id}/recordings", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listClassRecordings`, page after page. */
+  listClassRecordingsAll(classId, query, options) {
+    return this.iterate({ id: "listClassRecordings", method: "GET", path: "/classes/{class_id}/recordings", pathParams: { class_id: classId }, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** The institution's events (including drafts and those pending review) (`GET /events`; tenant token; scopes: event, event:registration:readonly) */
+  listTenantEvents(query, options) {
+    return this.call({ id: "listTenantEvents", method: "GET", path: "/events", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listTenantEvents`, page after page. */
+  listTenantEventsAll(query, options) {
+    return this.iterate({ id: "listTenantEvents", method: "GET", path: "/events", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Create an event (a draft; the institution publishes it in its console, moderated as usual) (`POST /events`; tenant token; scopes: event) */
+  createTenantEvent(body, options) {
+    return this.call({ id: "createTenantEvent", method: "POST", path: "/events", pathParams: {}, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, body, options) {
+    return this.call({ id: "updateTenantEvent", method: "PATCH", path: "/events/{event_id}", pathParams: { event_id: eventId }, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** An event's registrations and check-ins (`GET /events/{event_id}/registrations`; tenant token; scopes: event:registration:readonly) */
+  listEventRegistrations(eventId, query, options) {
+    return this.call({ id: "listEventRegistrations", method: "GET", path: "/events/{event_id}/registrations", pathParams: { event_id: eventId }, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listEventRegistrations`, page after page. */
+  listEventRegistrationsAll(eventId, query, options) {
+    return this.iterate({ id: "listEventRegistrations", method: "GET", path: "/events/{event_id}/registrations", pathParams: { event_id: eventId }, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** The institution's job postings (including drafts and those pending review) (`GET /jobs`; tenant token; scopes: job, job:candidate:readonly) */
+  listTenantJobs(query, options) {
+    return this.call({ id: "listTenantJobs", method: "GET", path: "/jobs", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listTenantJobs`, page after page. */
+  listTenantJobsAll(query, options) {
+    return this.iterate({ id: "listTenantJobs", method: "GET", path: "/jobs", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "createTenantJob", method: "POST", path: "/jobs", pathParams: {}, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, query, options) {
+    return this.call({ id: "listJobCandidates", method: "GET", path: "/jobs/{job_id}/candidates", pathParams: { job_id: jobId }, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listJobCandidates`, page after page. */
+  listJobCandidatesAll(jobId, query, options) {
+    return this.iterate({ id: "listJobCandidates", method: "GET", path: "/jobs/{job_id}/candidates", pathParams: { job_id: jobId }, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** The institution's teaching sites (use their venue_id to schedule trial slots) (`GET /trial/venues`; tenant token; scopes: trial) */
+  listTrialVenues(query, options) {
+    return this.call({ id: "listTrialVenues", method: "GET", path: "/trial/venues", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listTrialVenues`, page after page. */
+  listTrialVenuesAll(query, options) {
+    return this.iterate({ id: "listTrialVenues", method: "GET", path: "/trial/venues", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Trial lesson slots (by default only those not over yet, by time) (`GET /trial/slots`; tenant token; scopes: trial) */
+  listTrialSlots(query, options) {
+    return this.call({ id: "listTrialSlots", method: "GET", path: "/trial/slots", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listTrialSlots`, page after page. */
+  listTrialSlotsAll(query, options) {
+    return this.iterate({ id: "listTrialSlots", method: "GET", path: "/trial/slots", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Schedule trial lesson slots (they can repeat weekly); the teaching site must be published (`POST /trial/slots`; tenant token; scopes: trial) */
+  createTrialSlots(body, options) {
+    return this.call({ id: "createTrialSlots", method: "POST", path: "/trial/slots", pathParams: {}, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, body, options) {
+    return this.call({ id: "cancelTrialSlot", method: "POST", path: "/trial/slots/{slot_id}/cancel", pathParams: { slot_id: slotId }, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** Trial lesson bookings at the institution's teaching sites (`GET /trial/bookings`; tenant token; scopes: trial) */
+  listTrialBookings(query, options) {
+    return this.call({ id: "listTrialBookings", method: "GET", path: "/trial/bookings", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listTrialBookings`, page after page. */
+  listTrialBookingsAll(query, options) {
+    return this.iterate({ id: "listTrialBookings", method: "GET", path: "/trial/bookings", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Confirm a trial lesson booking (`POST /trial/bookings/{booking_id}/confirm`; tenant token; scopes: trial) */
+  confirmTrialBooking(bookingId, options) {
+    return this.call({ id: "confirmTrialBooking", method: "POST", path: "/trial/bookings/{booking_id}/confirm", pathParams: { booking_id: bookingId }, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "listTradeOrders", method: "GET", path: "/trade/orders", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listTradeOrders`, page after page. */
+  listTradeOrdersAll(query, options) {
+    return this.iterate({ id: "listTradeOrders", method: "GET", path: "/trade/orders", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Reviews of this institution (and its courses and teaching sites) (`GET /reviews`; tenant token; scopes: review) */
+  listTenantReviews(query, options) {
+    return this.call({ id: "listTenantReviews", method: "GET", path: "/reviews", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listTenantReviews`, page after page. */
+  listTenantReviewsAll(query, options) {
+    return this.iterate({ id: "listTenantReviews", method: "GET", path: "/reviews", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** 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, body, options) {
+    return this.call({ id: "replyReview", method: "POST", path: "/reviews/{review_id}/reply", pathParams: { review_id: reviewId }, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** Public courses, events and jobs shown in this region (`GET /public/{kind}`; app / tenant / user token) */
+  listPublicContent(kind, query, options) {
+    return this.call({ id: "listPublicContent", method: "GET", path: "/public/{kind}", pathParams: { kind }, query, tokenTypes: ["app", "tenant", "user"] }, options);
+  }
+  /** Every item of `listPublicContent`, page after page. */
+  listPublicContentAll(kind, query, options) {
+    return this.iterate({ id: "listPublicContent", method: "GET", path: "/public/{kind}", pathParams: { kind }, query, tokenTypes: ["app", "tenant", "user"] }, options);
+  }
+  /** 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) {
+    return this.call({ id: "getUserInterests", method: "GET", path: "/user/profile/interests", pathParams: {}, tokenTypes: ["user"] }, options);
+  }
+  /** Add an interest signal with its source (`POST /user/profile/interest_signals`; user token; scopes: profile:interest) */
+  addInterestSignal(body, options) {
+    return this.call({ id: "addInterestSignal", method: "POST", path: "/user/profile/interest_signals", pathParams: {}, body, tokenTypes: ["user"] }, options);
+  }
+  /** The user's learning profile (level, goals, languages being learned) (`GET /user/profile/learning`; user token; scopes: profile:learning:readonly) */
+  getUserLearningProfile(options) {
+    return this.call({ id: "getUserLearningProfile", method: "GET", path: "/user/profile/learning", pathParams: {}, tokenTypes: ["user"] }, options);
+  }
+  /** 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, options) {
+    return this.call({ id: "reportOnBehalf", method: "POST", path: "/reports", pathParams: {}, body, tokenTypes: ["user"] }, options);
+  }
+};
+
+// src/client.ts
+var RETRY_STATUSES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+var IDEMPOTENT = /* @__PURE__ */ new Set(["GET", "PUT", "DELETE"]);
+var Client = class extends Operations {
+  appId;
+  baseUrl;
+  appSecret;
+  maxRetries;
+  timeoutMs;
+  fetchFn;
+  refreshBefore;
+  userAgent;
+  /** Base of the retry backoff in ms (tests make it small). */
+  retryBaseMs = 500;
+  tokens = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super();
+    if (!options.appId || !options.appSecret) throw new TypeError("appId and appSecret are required");
+    this.appId = options.appId;
+    this.appSecret = options.appSecret;
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "").replace(/\/open-apis\/v1$/, "");
+    this.maxRetries = options.maxRetries ?? 3;
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.fetchFn = options.fetch ?? fetch;
+    this.refreshBefore = options.refreshBeforeSeconds ?? 300;
+    this.userAgent = `ichinese-open-sdk-node/${VERSION}${options.userAgent ? ` ${options.userAgent}` : ""}`;
+  }
+  // ── tokens ────────────────────────────────────────────────────────────────
+  /** The app token (cached, renewed before it expires). */
+  async appAccessToken() {
+    return (await this.cached("app", async () => {
+      const r = await this.send("POST", "/auth/app_access_token", {
+        body: this.credentials()
+      });
+      return { token: r.app_access_token, expiresIn: r.expires_in };
+    })).token;
+  }
+  /** The tenant token of an institution that installed the app (cached per institution, renewed). */
+  async tenantAccessToken(tenantKey) {
+    return (await this.cached(`tenant:${tenantKey}`, async () => {
+      const r = await this.send("POST", "/auth/tenant_access_token", {
+        body: { ...this.credentials(), tenant_key: tenantKey }
+      });
+      return { token: r.tenant_access_token, expiresIn: r.expires_in };
+    })).token;
+  }
+  /**
+   * 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, opts = {}) {
+    return this.send("POST", "/auth/exchange_auth_code", {
+      body: {
+        ...this.credentials(),
+        code,
+        ...opts.redirectUri ? { redirect_uri: opts.redirectUri } : {},
+        ...opts.codeVerifier ? { code_verifier: opts.codeVerifier } : {}
+      },
+      retryPost: false
+    });
+  }
+  /** A new pair for a refresh token (the old one stops working). */
+  refreshUserToken(refreshToken) {
+    return this.send("POST", "/auth/refresh_user_token", {
+      body: { ...this.credentials(), refresh_token: refreshToken },
+      retryPost: false
+    });
+  }
+  /** Revokes a user or refresh token (when the user signs out of your app). */
+  async revokeToken(token) {
+    await this.send("POST", "/auth/revoke", { body: { ...this.credentials(), token } });
+  }
+  /** Forgets the cached app and tenant tokens (they are fetched again when next needed). */
+  clearTokenCache() {
+    this.tokens.clear();
+  }
+  // ── calls ─────────────────────────────────────────────────────────────────
+  /** Any open API call by method and path (`/tenant/members`), for what the generated methods do not cover. */
+  request(method, path, init = {}, options) {
+    return this.call(
+      {
+        id: path,
+        method,
+        path,
+        pathParams: {},
+        query: init.query,
+        body: init.body,
+        tokenTypes: init.tokenTypes ?? ["app", "tenant", "user"]
+      },
+      options
+    );
+  }
+  async call(spec, options = {}) {
+    const path = spec.path.replace(/\{(\w+)\}/g, (_, name) => {
+      const v = spec.pathParams[name];
+      if (v === void 0 || v === null || v === "") throw new TypeError(`${spec.id}: ${name} is required`);
+      return encodeURIComponent(String(v));
+    });
+    return this.send(spec.method, path, { query: spec.query, body: spec.body, auth: { spec, options } });
+  }
+  async *iterate(spec, options = {}) {
+    let pageToken;
+    const query = { ...spec.query ?? {} };
+    if (query.page_size === void 0) query.page_size = 100;
+    do {
+      const page = await this.call(
+        { ...spec, query: { ...query, ...pageToken ? { page_token: pageToken } : {} } },
+        options
+      );
+      for (const item of page.items ?? []) yield item;
+      pageToken = page.has_more ? page.page_token : null;
+    } while (pageToken);
+  }
+  // ── internals ─────────────────────────────────────────────────────────────
+  credentials() {
+    return { app_id: this.appId, app_secret: this.appSecret };
+  }
+  async cached(key, fetchToken) {
+    const hit = this.tokens.get(key);
+    if (hit && hit.expiresAt - this.refreshBefore * 1e3 > Date.now()) return hit;
+    const running = this.inflight.get(key);
+    if (running) return running;
+    const p = fetchToken().then((r) => {
+      const c = { token: r.token, expiresAt: Date.now() + r.expiresIn * 1e3 };
+      this.tokens.set(key, c);
+      return c;
+    }).finally(() => this.inflight.delete(key));
+    this.inflight.set(key, p);
+    return p;
+  }
+  /** The token for a call, and the cache key it came from (dropped and fetched again after a 401). */
+  async tokenFor(spec, o) {
+    if (o.accessToken) return { token: o.accessToken };
+    if (o.userAccessToken) return { token: o.userAccessToken };
+    if (o.tenantKey) return { token: await this.tenantAccessToken(o.tenantKey), cacheKey: `tenant:${o.tenantKey}` };
+    if (spec.tokenTypes.includes("app")) return { token: await this.appAccessToken(), cacheKey: "app" };
+    throw new OpenApiError({
+      status: 0,
+      code: "TOKEN_REQUIRED",
+      message: `${spec.id} takes a ${spec.tokenTypes.join(" or ")} token: pass { tenantKey } or { userAccessToken }`
+    });
+  }
+  url(path, query) {
+    const u = new URL(`${this.baseUrl}${API_PREFIX}${path}`);
+    for (const [k, v] of Object.entries(query ?? {})) {
+      if (v === void 0 || v === null || v === "") continue;
+      if (Array.isArray(v)) for (const x of v) u.searchParams.append(k, String(x));
+      else u.searchParams.set(k, String(v));
+    }
+    return u.toString();
+  }
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      const t = setTimeout(resolve, ms);
+      signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(t);
+          reject(signal.reason);
+        },
+        { once: true }
+      );
+    });
+  }
+  backoff(attempt) {
+    const base = this.retryBaseMs * 2 ** attempt;
+    return Math.min(3e4, base + Math.random() * base * 0.25);
+  }
+  async send(method, path, init) {
+    const options = init.auth?.options ?? {};
+    let refreshed = false;
+    for (let attempt = 0; ; attempt++) {
+      const headers = {
+        accept: "application/json",
+        "user-agent": this.userAgent,
+        ...options.headers
+      };
+      let cacheKey;
+      if (init.auth) {
+        const t = await this.tokenFor(init.auth.spec, options);
+        headers.authorization = `Bearer ${t.token}`;
+        cacheKey = t.cacheKey;
+      }
+      if (init.body !== void 0) headers["content-type"] = "application/json";
+      const timeout = AbortSignal.timeout(this.timeoutMs);
+      const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+      const canRetry = attempt < this.maxRetries;
+      const idempotent = IDEMPOTENT.has(method) || method === "POST" && init.retryPost !== false && !init.auth;
+      let res;
+      try {
+        res = await this.fetchFn(this.url(path, init.query), {
+          method,
+          headers,
+          body: init.body === void 0 ? void 0 : JSON.stringify(init.body),
+          signal
+        });
+      } catch (err) {
+        if (options.signal?.aborted) throw err;
+        const timedOut = timeout.aborted;
+        if (canRetry && idempotent) {
+          await this.sleep(this.backoff(attempt), options.signal);
+          continue;
+        }
+        throw new OpenApiError({
+          status: 0,
+          code: timedOut ? "TIMEOUT" : "NETWORK",
+          message: `${method} ${path}: ${err.message}`
+        });
+      }
+      if (res.ok) {
+        if (res.status === 204) return void 0;
+        const text = await res.text();
+        return text ? JSON.parse(text) : void 0;
+      }
+      const error = await toError(res);
+      if (res.status === 429 && canRetry) {
+        const reset = Number(res.headers.get("x-ratelimit-reset"));
+        const wait = error.retryAfter ?? (Number.isFinite(reset) && reset > 0 ? reset : null);
+        if (error.reason !== "daily_quota_exceeded") {
+          await this.sleep(wait !== null ? wait * 1e3 : this.backoff(attempt), options.signal);
+          continue;
+        }
+      }
+      if (RETRY_STATUSES.has(res.status) && canRetry && idempotent) {
+        await this.sleep(this.backoff(attempt), options.signal);
+        continue;
+      }
+      if (res.status === 401 && cacheKey && !refreshed && (error.reason === "token_expired" || error.reason === "invalid_token")) {
+        this.tokens.delete(cacheKey);
+        refreshed = true;
+        attempt--;
+        continue;
+      }
+      throw error;
+    }
+  }
+};
+async function toError(res) {
+  let body = {};
+  try {
+    body = await res.json();
+  } catch {
+    body = {};
+  }
+  const retryAfter = Number(res.headers.get("retry-after"));
+  return new OpenApiError({
+    status: res.status,
+    code: body.error?.code ?? `HTTP_${res.status}`,
+    message: body.error?.message ?? res.statusText,
+    requestId: body.error?.request_id ?? res.headers.get("x-request-id"),
+    details: body.error?.details ?? {},
+    retryAfter: Number.isFinite(retryAfter) && res.headers.has("retry-after") ? retryAfter : null
+  });
+}
+
+// src/events.ts
+import { createDecipheriv, createHash, createHmac, timingSafeEqual } from "node:crypto";
+var header = (h, name) => {
+  if (typeof h.get === "function") return h.get(name) ?? void 0;
+  const rec = h;
+  const v = rec[name] ?? rec[name.toLowerCase()] ?? Object.entries(rec).find(([k]) => k.toLowerCase() === name.toLowerCase())?.[1];
+  return Array.isArray(v) ? v[0] : v;
+};
+function sign(signingSecret, timestamp, nonce, body) {
+  return `v1=${createHmac("sha256", signingSecret).update(`${timestamp}.${nonce}.`).update(body).digest("hex")}`;
+}
+function verifySignature(headers, rawBody, signingSecret, opts = {}) {
+  const fail = (message) => new OpenApiError({ status: 401, code: "INVALID_SIGNATURE", message });
+  const timestamp = header(headers, "x-ich-timestamp");
+  const nonce = header(headers, "x-ich-nonce");
+  const signature = header(headers, "x-ich-signature");
+  if (!timestamp || !nonce || !signature) throw fail("missing X-Ich-Timestamp, X-Ich-Nonce or X-Ich-Signature");
+  const now = Math.floor((opts.now ?? Date.now()) / 1e3);
+  if (!/^\d+$/.test(timestamp) || Math.abs(now - Number(timestamp)) > (opts.toleranceSeconds ?? 300)) {
+    throw fail("the timestamp is too far from now");
+  }
+  const expected = Buffer.from(sign(signingSecret, timestamp, nonce, rawBody));
+  const given = Buffer.from(signature);
+  if (expected.length !== given.length || !timingSafeEqual(expected, given)) throw fail("the signature does not match");
+}
+function decrypt(encrypted, encryptKey) {
+  const data = Buffer.from(encrypted, "base64");
+  if (data.length < 12 + 16) throw new OpenApiError({ status: 400, code: "INVALID_PAYLOAD", message: "too short" });
+  const key = createHash("sha256").update(encryptKey).digest();
+  const iv = data.subarray(0, 12);
+  const tag = data.subarray(data.length - 16);
+  const d = createDecipheriv("aes-256-gcm", key, iv);
+  d.setAuthTag(tag);
+  try {
+    return Buffer.concat([d.update(data.subarray(12, data.length - 16)), d.final()]).toString("utf8");
+  } catch {
+    throw new OpenApiError({ status: 400, code: "INVALID_PAYLOAD", message: "cannot decrypt (wrong encrypt key?)" });
+  }
+}
+function parseEvent(headers, rawBody, opts) {
+  verifySignature(headers, rawBody, opts.signingSecret, opts);
+  let json = JSON.parse(typeof rawBody === "string" ? rawBody : rawBody.toString("utf8"));
+  if (typeof json.encrypt === "string") {
+    if (!opts.encryptKey) {
+      throw new OpenApiError({ status: 400, code: "INVALID_PAYLOAD", message: "encrypted push but no encryptKey" });
+    }
+    json = JSON.parse(decrypt(json.encrypt, opts.encryptKey));
+  }
+  return json;
+}
+function parseCardAction(headers, rawBody, opts) {
+  return parseEvent(headers, rawBody, opts);
+}
+var isUrlVerification = (x) => typeof x === "object" && x !== null && x.type === "url_verification";
+var challengeResponse = (v) => ({ challenge: v.challenge });
+export {
+  API_PREFIX,
+  Client,
+  DEFAULT_BASE_URL,
+  ERROR_REASONS,
+  EVENT_TYPES,
+  OPERATION_TOKENS,
+  OpenApiError,
+  SCOPES,
+  SCOPE_ATTENDANCE_READONLY,
+  SCOPE_CLASS_MEMBER,
+  SCOPE_CLASS_READONLY,
+  SCOPE_COURSE,
+  SCOPE_COURSEWORK,
+  SCOPE_EVENT,
+  SCOPE_EVENT_REGISTRATION_READONLY,
+  SCOPE_GRADE_READONLY,
+  SCOPE_IM_CHAT_READONLY,
+  SCOPE_IM_MESSAGE_SEND_AS_BOT,
+  SCOPE_JOB,
+  SCOPE_JOB_CANDIDATE_READONLY,
+  SCOPE_LEARNING_PROGRESS_READONLY,
+  SCOPE_LIVE_RECORDING_READONLY,
+  SCOPE_NOTIFY_SEND,
+  SCOPE_OPENID,
+  SCOPE_ORG_MEMBER,
+  SCOPE_ORG_MEMBER_READONLY,
+  SCOPE_PROFILE,
+  SCOPE_PROFILE_INTEREST,
+  SCOPE_PROFILE_INTEREST_READONLY,
+  SCOPE_PROFILE_LEARNING_READONLY,
+  SCOPE_REPORT_CREATE,
+  SCOPE_REVIEW,
+  SCOPE_SCHEDULE,
+  SCOPE_SCHEDULE_READONLY,
+  SCOPE_TRADE_ORDER_READONLY,
+  SCOPE_TRIAL,
+  VERSION,
+  challengeResponse,
+  decrypt,
+  isOpenApiError,
+  isUrlVerification,
+  parseCardAction,
+  parseEvent,
+  sign,
+  verifySignature
+};