@ichinese/open-sdk 1.0.0-rc.2 → 1.0.0-rc.4

package/dist/index.js

@@ -28,6 +28,13 @@ var OpenApiError = class extends Error {
   get neverAsk() {
     return this.details.never_ask === true;
   }
+  /**
+   * Where the person agrees to show their name on posts (409 `consent_required`): send them there, an
+   * app cannot agree for them.
+   */
+  get consentUrl() {
+    return typeof this.details.consent_url === "string" ? this.details.consent_url : null;
+  }
   /** 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));
@@ -36,7 +43,7 @@ var OpenApiError = class extends Error {
 var isOpenApiError = (e) => e instanceof OpenApiError;
 
 // src/gen/meta.ts
-var VERSION = "1.0.0-rc.2";
+var VERSION = "1.0.0-rc.4";
 var DEFAULT_BASE_URL = "https://open.ichinese.cn";
 var API_PREFIX = "/open-apis/v1";
 var SCOPES = [
@@ -63,11 +70,21 @@ var SCOPES = [
   "job:candidate:readonly",
   "trial",
   "trade:order:readonly",
+  "trade:booking:readonly",
+  "venue:readonly",
+  "venue",
+  "opening:readonly",
   "review",
   "profile:interest:readonly",
   "profile:interest",
   "profile:learning:readonly",
-  "report:create"
+  "report:create",
+  "community:post",
+  "me:schedule:readonly",
+  "me:learning:readonly",
+  "me:words:readonly",
+  "me:words",
+  "insights:readonly"
 ];
 var EVENT_TYPES = [
   "app.installed",
@@ -81,7 +98,18 @@ var EVENT_TYPES = [
   "trade.order_paid",
   "review.created",
   "trial.booked",
-  "im.message_received"
+  "im.message_received",
+  "class.member_changed",
+  "course.completed",
+  "exam.results_released",
+  "event.checked_in",
+  "live.recording_ready",
+  "trade.order_refunded",
+  "trial.confirmed",
+  "trial.cancelled",
+  "community.post_reviewed",
+  "community.video_ready",
+  "booking.changed"
 ];
 var ERROR_REASONS = [
   "invalid_credentials",
@@ -102,7 +130,30 @@ var ERROR_REASONS = [
   "code_invalid",
   "redirect_uri_mismatch",
   "origin_not_trusted",
-  "ip_not_allowed"
+  "ip_not_allowed",
+  "org_not_installed",
+  "minor_not_allowed",
+  "birth_year_required",
+  "feature_disabled",
+  "app_post_stopped",
+  "consent_required",
+  "video_not_ready",
+  "video_failed",
+  "post_rate_limited",
+  "app_user_daily_limit",
+  "post_in_progress",
+  "no_org_account",
+  "teacher_busy",
+  "online_only",
+  "venue_unavailable",
+  "venue_not_found",
+  "slot_overlap",
+  "slot_taken",
+  "not_draft",
+  "not_editable",
+  "org_not_verified",
+  "opening_ended",
+  "opening_incomplete"
 ];
 var OPERATION_TOKENS = {
   getUserInfo: ["user"],
@@ -115,6 +166,8 @@ var OPERATION_TOKENS = {
   addClassMember: ["tenant", "user"],
   removeClassMember: ["tenant", "user"],
   listClassSessions: ["tenant", "user"],
+  createClassSessions: ["tenant", "user"],
+  setClassSessionPlace: ["tenant", "user"],
   cancelClassSession: ["tenant", "user"],
   rescheduleClassSession: ["tenant", "user"],
   getSessionAttendance: ["tenant", "user"],
@@ -142,16 +195,40 @@ var OPERATION_TOKENS = {
   listTrialSlots: ["tenant"],
   createTrialSlots: ["tenant"],
   cancelTrialSlot: ["tenant"],
+  setTrialTeacher: ["tenant"],
   listTrialBookings: ["tenant"],
   confirmTrialBooking: ["tenant"],
+  listVenues: ["tenant"],
+  createVenue: ["tenant"],
+  getVenue: ["tenant"],
+  listOpenings: ["tenant", "user"],
+  getOpening: ["tenant", "user"],
+  getInsights: ["tenant"],
   listTradeOrders: ["tenant"],
+  listBookings: ["tenant"],
+  getBooking: ["tenant"],
   listTenantReviews: ["tenant"],
   replyReview: ["tenant"],
   listPublicContent: ["app", "tenant", "user"],
   getUserInterests: ["user"],
   addInterestSignal: ["user"],
   getUserLearningProfile: ["user"],
-  reportOnBehalf: ["user"]
+  reportOnBehalf: ["user"],
+  createCommunityImageUpload: ["user", "tenant"],
+  createCommunityVideoUpload: ["user", "tenant"],
+  completeCommunityVideoUpload: ["user", "tenant"],
+  getCommunityVideo: ["user", "tenant"],
+  listCommunityPosts: ["user", "tenant"],
+  createCommunityPost: ["user", "tenant"],
+  getCommunityPost: ["user", "tenant"],
+  deleteCommunityPost: ["user", "tenant"],
+  listCommunityCategories: ["user", "tenant"],
+  getMySchedule: ["user"],
+  listMyCourses: ["user"],
+  listMyWords: ["user"],
+  addMyWord: ["user"],
+  listClassExams: ["tenant"],
+  listClassExamResults: ["tenant"]
 };
 var SCOPE_OPENID = "openid";
 var SCOPE_PROFILE = "profile";
@@ -176,11 +253,21 @@ 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_TRADE_BOOKING_READONLY = "trade:booking:readonly";
+var SCOPE_VENUE_READONLY = "venue:readonly";
+var SCOPE_VENUE = "venue";
+var SCOPE_OPENING_READONLY = "opening: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";
+var SCOPE_COMMUNITY_POST = "community:post";
+var SCOPE_ME_SCHEDULE_READONLY = "me:schedule:readonly";
+var SCOPE_ME_LEARNING_READONLY = "me:learning:readonly";
+var SCOPE_ME_WORDS_READONLY = "me:words:readonly";
+var SCOPE_ME_WORDS = "me:words";
+var SCOPE_INSIGHTS_READONLY = "insights:readonly";
 
 // src/gen/operations.ts
 var Operations = class {
@@ -240,6 +327,14 @@ var Operations = class {
   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);
   }
+  /** Schedule a class's sessions (once, or repeating weekly), online or at one of the institution's teaching sites (`POST /classes/{class_id}/sessions`; tenant / user token; scopes: schedule) */
+  createClassSessions(classId, body, options) {
+    return this.call({ id: "createClassSessions", method: "POST", path: "/classes/{class_id}/sessions", pathParams: { class_id: classId }, body, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Change where one session (or this one and the later ones of its series) is held (`PUT /classes/{class_id}/sessions/{session_id}/place`; tenant / user token; scopes: schedule) */
+  setClassSessionPlace(classId, sessionId, body, options) {
+    return this.call({ id: "setClassSessionPlace", method: "PUT", path: "/classes/{class_id}/sessions/{session_id}/place", pathParams: { class_id: classId, session_id: sessionId }, body, 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);
@@ -384,7 +479,7 @@ var Operations = class {
   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) */
+  /** Trial times (a trial lesson's own times at teaching sites; 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);
   }
@@ -392,14 +487,18 @@ var Operations = class {
   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) */
+  /** Open trial times (they can repeat weekly): add them to an existing trial lesson, or open a new trial draft (`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) */
+  /** Close a trial time (no more bookings; bookings already made stay as they are, and nobody is notified) (`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);
   }
+  /** Fill in (or change) the teacher of a trial draft (`PUT /trial/openings/{opening_id}/teacher`; tenant token; scopes: trial) */
+  setTrialTeacher(openingId, body, options) {
+    return this.call({ id: "setTrialTeacher", method: "PUT", path: "/trial/openings/{opening_id}/teacher", pathParams: { opening_id: openingId }, 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);
@@ -412,6 +511,38 @@ var Operations = class {
   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 teaching sites (campuses), newest first (`GET /venues`; tenant token; scopes: venue:readonly, venue, trial) */
+  listVenues(query, options) {
+    return this.call({ id: "listVenues", method: "GET", path: "/venues", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listVenues`, page after page. */
+  listVenuesAll(query, options) {
+    return this.iterate({ id: "listVenues", method: "GET", path: "/venues", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Create a draft teaching site (campus); it is published in the platform and reviewed as usual (`POST /venues`; tenant token; scopes: venue) */
+  createVenue(body, options) {
+    return this.call({ id: "createVenue", method: "POST", path: "/venues", pathParams: {}, body, tokenTypes: ["tenant"] }, options);
+  }
+  /** One teaching site (of this institution only) (`GET /venues/{venue_id}`; tenant token; scopes: venue:readonly, venue, trial) */
+  getVenue(venueId, options) {
+    return this.call({ id: "getVenue", method: "GET", path: "/venues/{venue_id}", pathParams: { venue_id: venueId }, tokenTypes: ["tenant"] }, options);
+  }
+  /** Openings: every class and course opened (group classes, one-to-ones, open classes, trial lessons, video courses), newest first (`GET /openings`; tenant / user token; scopes: opening:readonly) */
+  listOpenings(query, options) {
+    return this.call({ id: "listOpenings", method: "GET", path: "/openings", pathParams: {}, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** Every item of `listOpenings`, page after page. */
+  listOpeningsAll(query, options) {
+    return this.iterate({ id: "listOpenings", method: "GET", path: "/openings", pathParams: {}, query, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** One opening (`GET /openings/{opening_id}`; tenant / user token; scopes: opening:readonly) */
+  getOpening(openingId, options) {
+    return this.call({ id: "getOpening", method: "GET", path: "/openings/{opening_id}", pathParams: { opening_id: openingId }, tokenTypes: ["tenant", "user"] }, options);
+  }
+  /** One page of the institution's dashboard (read only): enrolment, teaching, teaching sites, income, community and events (`GET /insights`; tenant token; scopes: insights:readonly) */
+  getInsights(query, options) {
+    return this.call({ id: "getInsights", method: "GET", path: "/insights", pathParams: {}, query, 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);
@@ -420,6 +551,18 @@ var Operations = class {
   listTradeOrdersAll(query, options) {
     return this.iterate({ id: "listTradeOrders", method: "GET", path: "/trade/orders", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
   }
+  /** The institution's bookings (one-to-ones and trial lessons, read only for reconciliation), latest lesson first (`GET /bookings`; tenant token; scopes: trade:booking:readonly) */
+  listBookings(query, options) {
+    return this.call({ id: "listBookings", method: "GET", path: "/bookings", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listBookings`, page after page. */
+  listBookingsAll(query, options) {
+    return this.iterate({ id: "listBookings", method: "GET", path: "/bookings", pathParams: {}, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** One booked lesson (`GET /bookings/{booking_id}`; tenant token; scopes: trade:booking:readonly) */
+  getBooking(bookingId, options) {
+    return this.call({ id: "getBooking", method: "GET", path: "/bookings/{booking_id}", pathParams: { booking_id: bookingId }, 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);
@@ -456,6 +599,90 @@ var Operations = class {
   reportOnBehalf(body, options) {
     return this.call({ id: "reportOnBehalf", method: "POST", path: "/reports", pathParams: {}, body, tokenTypes: ["user"] }, options);
   }
+  /** Get an upload URL for an image (it is re-encoded and its EXIF removed when the post is made) (`POST /community/images`; user / tenant token; scopes: community:post) */
+  createCommunityImageUpload(body, options) {
+    return this.call({ id: "createCommunityImageUpload", method: "POST", path: "/community/images", pathParams: {}, body, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** Get an upload URL for a video (up to 4 GB, 1 hour) (`POST /community/videos`; user / tenant token; scopes: community:post) */
+  createCommunityVideoUpload(body, options) {
+    return this.call({ id: "createCommunityVideoUpload", method: "POST", path: "/community/videos", pathParams: {}, body, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** The upload is done; start transcoding (calling it again has no side effects) (`POST /community/videos/{asset_id}/complete`; user / tenant token; scopes: community:post) */
+  completeCommunityVideoUpload(assetId, options) {
+    return this.call({ id: "completeCommunityVideoUpload", method: "POST", path: "/community/videos/{asset_id}/complete", pathParams: { asset_id: assetId }, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** Transcoding status (only for videos this app uploaded for this person) (`GET /community/videos/{asset_id}`; user / tenant token; scopes: community:post) */
+  getCommunityVideo(assetId, options) {
+    return this.call({ id: "getCommunityVideo", method: "GET", path: "/community/videos/{asset_id}", pathParams: { asset_id: assetId }, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** Posts this app made in this person's name (the person's own posts and other apps' posts are not visible) (`GET /community/posts`; user / tenant token; scopes: community:post) */
+  listCommunityPosts(query, options) {
+    return this.call({ id: "listCommunityPosts", method: "GET", path: "/community/posts", pathParams: {}, query, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** Every item of `listCommunityPosts`, page after page. */
+  listCommunityPostsAll(query, options) {
+    return this.iterate({ id: "listCommunityPosts", method: "GET", path: "/community/posts", pathParams: {}, query, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** Publish a public post in this person's name (text, up to 9 images or 1 video, up to 10 topics) (`POST /community/posts`; user / tenant token; scopes: community:post) */
+  createCommunityPost(body, options) {
+    return this.call({ id: "createCommunityPost", method: "POST", path: "/community/posts", pathParams: {}, body, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** The status of one post (only posts this app made; anything else is 404) (`GET /community/posts/{post_id}`; user / tenant token; scopes: community:post) */
+  getCommunityPost(postId, options) {
+    return this.call({ id: "getCommunityPost", method: "GET", path: "/community/posts/{post_id}", pathParams: { post_id: postId }, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** Delete a post (only posts this app made; anything else is 404) (`DELETE /community/posts/{post_id}`; user / tenant token; scopes: community:post) */
+  deleteCommunityPost(postId, options) {
+    return this.call({ id: "deleteCommunityPost", method: "DELETE", path: "/community/posts/{post_id}", pathParams: { post_id: postId }, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** Categories a post can be filed under (those enabled in this region) (`GET /community/categories`; user / tenant token; scopes: community:post) */
+  listCommunityCategories(options) {
+    return this.call({ id: "listCommunityCategories", method: "GET", path: "/community/categories", pathParams: {}, tokenTypes: ["user", "tenant"] }, options);
+  }
+  /** This person's timetable: their sessions, the events they signed up for, confirmed trial lessons and exams (for calendar apps; read-only) (`GET /me/schedule`; user token; scopes: me:schedule:readonly) */
+  getMySchedule(query, options) {
+    return this.call({ id: "getMySchedule", method: "GET", path: "/me/schedule", pathParams: {}, query, tokenTypes: ["user"] }, options);
+  }
+  /** Every item of `getMySchedule`, page after page. */
+  getMyScheduleAll(query, options) {
+    return this.iterate({ id: "getMySchedule", method: "GET", path: "/me/schedule", pathParams: {}, query, tokenTypes: ["user"] }, options);
+  }
+  /** The courses this person is studying and their progress (lessons completed, last studied; level and goals belong to the gold-only profile and are not here) (`GET /me/courses`; user token; scopes: me:learning:readonly) */
+  listMyCourses(query, options) {
+    return this.call({ id: "listMyCourses", method: "GET", path: "/me/courses", pathParams: {}, query, tokenTypes: ["user"] }, options);
+  }
+  /** Every item of `listMyCourses`, page after page. */
+  listMyCoursesAll(query, options) {
+    return this.iterate({ id: "listMyCourses", method: "GET", path: "/me/courses", pathParams: {}, query, tokenTypes: ["user"] }, options);
+  }
+  /** This person's word bank: words, pinyin, review state (no meanings, and review records cannot be changed) (`GET /me/words`; user token; scopes: me:words:readonly, me:words) */
+  listMyWords(query, options) {
+    return this.call({ id: "listMyWords", method: "GET", path: "/me/words", pathParams: {}, query, tokenTypes: ["user"] }, options);
+  }
+  /** Every item of `listMyWords`, page after page. */
+  listMyWordsAll(query, options) {
+    return this.iterate({ id: "listMyWords", method: "GET", path: "/me/words", pathParams: {}, query, tokenTypes: ["user"] }, options);
+  }
+  /** Add a word to this person's word bank (unchanged if it is already there; its source is recorded as this app) (`POST /me/words`; user token; scopes: me:words) */
+  addMyWord(body, options) {
+    return this.call({ id: "addMyWord", method: "POST", path: "/me/words", pathParams: {}, body, tokenTypes: ["user"] }, options);
+  }
+  /** A class's exams (tenant tokens only, own institution) (`GET /classes/{class_id}/exams`; tenant token; scopes: grade:readonly) */
+  listClassExams(classId, query, options) {
+    return this.call({ id: "listClassExams", method: "GET", path: "/classes/{class_id}/exams", pathParams: { class_id: classId }, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listClassExams`, page after page. */
+  listClassExamsAll(classId, query, options) {
+    return this.iterate({ id: "listClassExams", method: "GET", path: "/classes/{class_id}/exams", pathParams: { class_id: classId }, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Each learner's result in one exam (scores only once released; tenant tokens only, own institution) (`GET /classes/{class_id}/exams/{exam_id}/results`; tenant token; scopes: grade:readonly) */
+  listClassExamResults(classId, examId, query, options) {
+    return this.call({ id: "listClassExamResults", method: "GET", path: "/classes/{class_id}/exams/{exam_id}/results", pathParams: { class_id: classId, exam_id: examId }, query, tokenTypes: ["tenant"] }, options);
+  }
+  /** Every item of `listClassExamResults`, page after page. */
+  listClassExamResultsAll(classId, examId, query, options) {
+    return this.iterate({ id: "listClassExamResults", method: "GET", path: "/classes/{class_id}/exams/{exam_id}/results", pathParams: { class_id: classId, exam_id: examId }, query, tokenTypes: ["tenant"] }, options);
+  }
 };
 
 // src/client.ts
@@ -537,6 +764,129 @@ var Client = class extends Operations {
   clearTokenCache() {
     this.tokens.clear();
   }
+  // ── posting in a person's name (D105), and as the institution (M6.21 K2) ─────
+  /**
+   * Uploads an image for a post: asks for an upload slot, PUTs the bytes there and returns the `key` to
+   * put in `images[].key`. Up to 10 MB; jpeg, png, webp or gif.
+   */
+  uploadImage(userAccessToken, data, contentType, options = {}) {
+    return this.uploadImageWith({ userAccessToken, signal: options.signal }, data, contentType);
+  }
+  /** `uploadImage` for a post of the institution (its tenant token, `community:post` granted by it). */
+  uploadImageAsOrg(tenantKey, data, contentType, options = {}) {
+    return this.uploadImageWith({ tenantKey, signal: options.signal }, data, contentType);
+  }
+  /**
+   * Uploads a video for a post (up to 4 GB, 1 hour): asks for an upload slot, PUTs the file there and
+   * starts transcoding. A large file goes as a Blob that reads from disk (`await fs.openAsBlob(path)`).
+   * Returns the video's status (`asset_id`); wait for `ready` with `waitVideoReady` before posting.
+   */
+  uploadVideo(userAccessToken, data, file, options = {}) {
+    return this.uploadVideoWith({ userAccessToken, signal: options.signal }, data, file);
+  }
+  /** `uploadVideo` for a post of the institution. */
+  uploadVideoAsOrg(tenantKey, data, file, options = {}) {
+    return this.uploadVideoWith({ tenantKey, signal: options.signal }, data, file);
+  }
+  /**
+   * Waits until a video has been transcoded and returns it (`status: ready`). A failed transcode throws
+   * an OpenApiError with reason `video_failed` (upload another file); running out of time throws one
+   * with code TIMEOUT (reason `video_not_ready`). You also get the `community.video_ready` event.
+   */
+  waitVideoReady(userAccessToken, assetId, options = {}) {
+    return this.waitVideoWith({ userAccessToken }, assetId, options);
+  }
+  /** `waitVideoReady` for a video uploaded for the institution. */
+  waitVideoReadyAsOrg(tenantKey, assetId, options = {}) {
+    return this.waitVideoWith({ tenantKey }, assetId, options);
+  }
+  /**
+   * Posts in the person's name. Without a `uuid` the SDK makes one, so its own retries never post twice;
+   * give your own `uuid` to make your retries safe too (one post per `uuid` within an hour). Errors keep the server's reason: `consent_required`
+   * (send the person to `error.consentUrl`), `video_not_ready`, `video_failed`, `post_rate_limited`,
+   * `app_user_daily_limit`, `daily_quota_exceeded`, `minor_not_allowed`, `app_post_stopped`, …
+   */
+  createPost(userAccessToken, post, options = {}) {
+    return this.createPostWith({ userAccessToken, signal: options.signal }, post);
+  }
+  /**
+   * Posts as the institution, with its community account (its name and logo; the post says it came from
+   * this app). The institution must have installed the app and granted `community:post`; before its
+   * homepage was first published there is no account yet (409 `no_org_account`). The same limits,
+   * review and `uuid` handling as `createPost`.
+   */
+  createPostAsOrg(tenantKey, post, options = {}) {
+    return this.createPostWith({ tenantKey, signal: options.signal }, post);
+  }
+  // ── the institution's dashboard (M6.21 K2) ────────────────────────────────
+  /**
+   * Every page of the institution's dashboard the API offers (`GET /insights`, `insights:readonly`): the
+   * default page first, then each other tab it lists, with the same query (range, dates, filters). Returns
+   * tab → page. Fewer than five people come back as `null` with `withheld: true`; money is per currency.
+   */
+  async getAllInsights(tenantKey, query = {}, options = {}) {
+    const who = { tenantKey, signal: options.signal };
+    const first = await this.getInsights(query, who);
+    const out = { [first.tab]: first };
+    for (const tab of first.tabs) {
+      if (out[tab]) continue;
+      out[tab] = await this.getInsights({ ...query, tab }, who);
+    }
+    return out;
+  }
+  async uploadImageWith(who, data, contentType) {
+    const slot = await this.createCommunityImageUpload({ content_type: contentType, size_bytes: sizeOf(data) }, who);
+    await this.putUpload(slot.upload_url, slot.headers, data, who.signal);
+    return slot.key;
+  }
+  async uploadVideoWith(who, data, file) {
+    const slot = await this.createCommunityVideoUpload(
+      { filename: file.filename, content_type: file.contentType, size_bytes: sizeOf(data) },
+      who
+    );
+    await this.putUpload(slot.upload.url, slot.upload.headers, data, who.signal);
+    return this.send(
+      "POST",
+      `/community/videos/${encodeURIComponent(slot.asset_id)}/complete`,
+      { auth: this.postingAuth("completeCommunityVideoUpload", who), retryPost: true }
+    );
+  }
+  async waitVideoWith(who, assetId, options) {
+    const deadline = Date.now() + (options.timeoutMs ?? 30 * 6e4);
+    let interval = options.intervalMs ?? 2e3;
+    const maxInterval = options.maxIntervalMs ?? 15e3;
+    for (; ; ) {
+      const video = await this.getCommunityVideo(assetId, { ...who, signal: options.signal });
+      if (video.status === "ready") return video;
+      if (video.status === "failed") {
+        throw new OpenApiError({
+          status: 409,
+          code: "CONFLICT",
+          message: `video ${assetId} could not be transcoded${video.error ? ` (${video.error})` : ""}`,
+          details: { reason: "video_failed", asset_id: assetId, error: video.error ?? null }
+        });
+      }
+      const left = deadline - Date.now();
+      if (left <= 0) {
+        throw new OpenApiError({
+          status: 0,
+          code: "TIMEOUT",
+          message: `video ${assetId} is not ready yet (${video.status})`,
+          details: { reason: "video_not_ready", asset_id: assetId, status: video.status }
+        });
+      }
+      await this.sleep(Math.min(interval, left), options.signal);
+      interval = Math.min(interval * 2, maxInterval);
+    }
+  }
+  createPostWith(who, post) {
+    const body = post.uuid ? post : { ...post, uuid: crypto.randomUUID() };
+    return this.send("POST", "/community/posts", {
+      body,
+      auth: this.postingAuth("createCommunityPost", who),
+      retryPost: true
+    });
+  }
   // ── calls ─────────────────────────────────────────────────────────────────
   /** Any open API call by method and path (`/tenant/members`), for what the generated methods do not cover. */
   request(method, path, init = {}, options) {
@@ -578,6 +928,31 @@ var Client = class extends Operations {
   credentials() {
     return { app_id: this.appId, app_secret: this.appSecret };
   }
+  postingAuth(id, who) {
+    const spec = { id, method: "POST", path: "", pathParams: {}, tokenTypes: ["user", "tenant"] };
+    return { spec, options: who };
+  }
+  /**
+   * PUTs an upload to the slot the platform gave (object storage, not the open API: no token, its own
+   * headers). Not limited by `timeoutMs`, a large video takes as long as it takes; cancel with the signal.
+   */
+  async putUpload(url, headers, data, signal) {
+    let res;
+    try {
+      res = await this.fetchFn(url, { method: "PUT", headers, body: data, signal });
+    } catch (err) {
+      if (signal?.aborted) throw err;
+      throw new OpenApiError({ status: 0, code: "NETWORK", message: `PUT upload: ${err.message}` });
+    }
+    if (!res.ok) {
+      throw new OpenApiError({
+        status: res.status,
+        code: "UPLOAD_FAILED",
+        message: `PUT upload: ${res.status} ${res.statusText}`,
+        details: { reason: "upload_failed", body: (await res.text().catch(() => "")).slice(0, 500) }
+      });
+    }
+  }
   async cached(key, fetchToken) {
     const hit = this.tokens.get(key);
     if (hit && hit.expiresAt - this.refreshBefore * 1e3 > Date.now()) return hit;
@@ -648,7 +1023,7 @@ var Client = class extends Operations {
       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;
+      const idempotent = IDEMPOTENT.has(method) || method === "POST" && (init.retryPost === true || init.retryPost !== false && !init.auth);
       let res;
       try {
         res = await this.fetchFn(this.url(path, init.query), {
@@ -698,6 +1073,7 @@ var Client = class extends Operations {
     }
   }
 };
+var sizeOf = (data) => data instanceof Uint8Array ? data.byteLength : data.size;
 async function toError(res) {
   let body = {};
   try {
@@ -783,6 +1159,7 @@ export {
   SCOPE_ATTENDANCE_READONLY,
   SCOPE_CLASS_MEMBER,
   SCOPE_CLASS_READONLY,
+  SCOPE_COMMUNITY_POST,
   SCOPE_COURSE,
   SCOPE_COURSEWORK,
   SCOPE_EVENT,
@@ -790,12 +1167,18 @@ export {
   SCOPE_GRADE_READONLY,
   SCOPE_IM_CHAT_READONLY,
   SCOPE_IM_MESSAGE_SEND_AS_BOT,
+  SCOPE_INSIGHTS_READONLY,
   SCOPE_JOB,
   SCOPE_JOB_CANDIDATE_READONLY,
   SCOPE_LEARNING_PROGRESS_READONLY,
   SCOPE_LIVE_RECORDING_READONLY,
+  SCOPE_ME_LEARNING_READONLY,
+  SCOPE_ME_SCHEDULE_READONLY,
+  SCOPE_ME_WORDS,
+  SCOPE_ME_WORDS_READONLY,
   SCOPE_NOTIFY_SEND,
   SCOPE_OPENID,
+  SCOPE_OPENING_READONLY,
   SCOPE_ORG_MEMBER,
   SCOPE_ORG_MEMBER_READONLY,
   SCOPE_PROFILE,
@@ -806,8 +1189,11 @@ export {
   SCOPE_REVIEW,
   SCOPE_SCHEDULE,
   SCOPE_SCHEDULE_READONLY,
+  SCOPE_TRADE_BOOKING_READONLY,
   SCOPE_TRADE_ORDER_READONLY,
   SCOPE_TRIAL,
+  SCOPE_VENUE,
+  SCOPE_VENUE_READONLY,
   VERSION,
   challengeResponse,
   decrypt,

package/dist/types.d.ts

@@ -42,6 +42,17 @@ export interface ClientOptions {
     /** Appended to the User-Agent header. */
     userAgent?: string;
 }
+/** How `waitVideoReady` polls a video's status. */
+export interface WaitVideoOptions {
+    /** Give up after this many milliseconds (an OpenApiError, code TIMEOUT). Default 30 minutes. */
+    timeoutMs?: number;
+    /** First wait between two looks, in milliseconds; it doubles up to `maxIntervalMs`. Default 2 000. */
+    intervalMs?: number;
+    /** Longest wait between two looks. Default 15 000. */
+    maxIntervalMs?: number;
+    /** Stops waiting. */
+    signal?: AbortSignal;
+}
 export interface UserAccessToken {
     access_token: string;
     token_type: 'Bearer';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ichinese/open-sdk",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.4",
   "description": "Server SDK for the iChinese open platform (open API, tokens, events, web login): Node.js 20+",
   "license": "MIT",
   "type": "module",