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

package/README.md

@@ -1,6 +1,6 @@
 # iChinese Open Platform SDK for Node.js
 
-> **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.
+> **Prerelease 1.0.0-rc.4.** 这是预发布版，开放平台还没有正式开放，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`）的每个接口都是一个方法，并处理令牌、重试、分页和事件推送。
 
@@ -42,6 +42,70 @@ try {
 
 The `examples` directory has this one in full, a backend for the web login and a server for event pushes.
 
+## Posting in a person's name
+
+With a user token that has the `community:post` scope, four methods do the uploads and the waiting:
+
+- `uploadImage(userToken, data, contentType)`: gets an upload slot, PUTs the image there, returns its `key`.
+- `uploadVideo(userToken, data, { filename, contentType })`: gets a slot, PUTs the video, starts transcoding;
+  returns the video (`asset_id`). Pass a large file as `await fs.openAsBlob(path)`.
+- `waitVideoReady(userToken, assetId, { timeoutMs, intervalMs })`: polls until the video is `ready`; throws
+  an `OpenApiError` with reason `video_failed`, or code `TIMEOUT`.
+- `createPost(userToken, post)`: posts; adds a `uuid` when you give none, so retries never post twice.
+
+```ts
+import { openAsBlob } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+
+try {
+  // A post with an image…
+  const key = await client.uploadImage(userToken, await readFile('photo.jpg'), 'image/jpeg');
+  const post = await client.createPost(userToken, { body: '今天学了新词 #HSK3', images: [{ key }] });
+  console.log(post.url, post.status);
+
+  // …or with a video, once it is transcoded.
+  const video = await client.uploadVideo(userToken, await openAsBlob('lesson.mp4'), {
+    filename: 'lesson.mp4',
+    contentType: 'video/mp4',
+  });
+  await client.waitVideoReady(userToken, video.asset_id);
+  await client.createPost(userToken, { title: '第一课', video: { asset_id: video.asset_id } });
+} catch (e) {
+  // The person has not agreed to show their name on posts: only they can, at this address.
+  if (isOpenApiError(e) && e.reason === 'consent_required') console.log(e.consentUrl);
+  else throw e;
+}
+```
+
+A post has either images (`images: [{ key }]`, up to 9) or one video. Errors keep the server's
+`reason`: `consent_required`, `video_not_ready`, `post_rate_limited`, `app_user_daily_limit`,
+`daily_quota_exceeded`, `minor_not_allowed`, `app_post_stopped`, …. `createPost` and completing a video
+upload are retried after server errors like a GET (the server makes them idempotent).
+
+### Posting as the institution (机构号)
+
+With the institution's tenant key the same helpers post as its community account (its name and logo, the
+post says it came from your app): `uploadImageAsOrg`, `uploadVideoAsOrg`, `waitVideoReadyAsOrg`,
+`createPostAsOrg`. 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`). Limits and review are the same.
+
+```ts
+const key = await client.uploadImageAsOrg(tenantKey, bytes, 'image/png');
+await client.createPostAsOrg(tenantKey, { body: '秋季班开始报名 #少儿中文', images: [{ key }] });
+```
+
+### The institution's dashboard
+
+`getAllInsights` reads every page of the institution's dashboard the API offers (`GET /insights`, scope
+`insights:readonly`, tenant token): the default page first, then each other tab it lists, with the same
+query. It returns tab → page. Fewer than five people come back as null with `withheld: true`; money is
+per currency, never converted.
+
+```ts
+const pages = await client.getAllInsights(tenantKey, { range: '30d' });
+console.log(pages.enrollment.tiles);
+```
+
 ## Documentation
 
 Guides and the API reference: <https://open.ichinese.cn>

package/dist/client.d.ts

@@ -1,5 +1,5 @@
-import { Operations } from './gen/operations.ts';
-import type { CallSpec, ClientOptions, RequestOptions, TokenType, UserAccessToken } from './types.ts';
+import { type BodyOf, Operations, type QueryOf, type ResultOf } from './gen/operations.ts';
+import type { CallSpec, ClientOptions, RequestOptions, TokenType, UserAccessToken, WaitVideoOptions } from './types.ts';
 export declare class Client extends Operations {
     readonly appId: string;
     readonly baseUrl: string;
@@ -34,6 +34,73 @@ export declare class Client extends Operations {
     revokeToken(token: string): Promise<void>;
     /** Forgets the cached app and tenant tokens (they are fetched again when next needed). */
     clearTokenCache(): void;
+    /**
+     * 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: string, data: Uint8Array | Blob, contentType: BodyOf<'createCommunityImageUpload'>['content_type'], options?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /** `uploadImage` for a post of the institution (its tenant token, `community:post` granted by it). */
+    uploadImageAsOrg(tenantKey: string, data: Uint8Array | Blob, contentType: BodyOf<'createCommunityImageUpload'>['content_type'], options?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+    /**
+     * 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: string, data: Uint8Array | Blob, file: {
+        filename: string;
+        contentType: string;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<ResultOf<'completeCommunityVideoUpload'>>;
+    /** `uploadVideo` for a post of the institution. */
+    uploadVideoAsOrg(tenantKey: string, data: Uint8Array | Blob, file: {
+        filename: string;
+        contentType: string;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<ResultOf<'completeCommunityVideoUpload'>>;
+    /**
+     * 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: string, assetId: string, options?: WaitVideoOptions): Promise<ResultOf<'getCommunityVideo'>>;
+    /** `waitVideoReady` for a video uploaded for the institution. */
+    waitVideoReadyAsOrg(tenantKey: string, assetId: string, options?: WaitVideoOptions): Promise<ResultOf<'getCommunityVideo'>>;
+    /**
+     * 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: string, post: BodyOf<'createCommunityPost'>, options?: {
+        signal?: AbortSignal;
+    }): Promise<ResultOf<'createCommunityPost'>>;
+    /**
+     * 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: string, post: BodyOf<'createCommunityPost'>, options?: {
+        signal?: AbortSignal;
+    }): Promise<ResultOf<'createCommunityPost'>>;
+    /**
+     * 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.
+     */
+    getAllInsights(tenantKey: string, query?: Omit<NonNullable<QueryOf<'getInsights'>>, 'tab'>, options?: {
+        signal?: AbortSignal;
+    }): Promise<Record<string, ResultOf<'getInsights'>>>;
+    private uploadImageWith;
+    private uploadVideoWith;
+    private waitVideoWith;
+    private createPostWith;
     /** 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>;
@@ -43,6 +110,12 @@ export declare class Client extends Operations {
     protected call<T>(spec: CallSpec, options?: RequestOptions): Promise<T>;
     protected iterate<T>(spec: CallSpec, options?: RequestOptions): AsyncIterable<T>;
     private credentials;
+    private postingAuth;
+    /**
+     * 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.
+     */
+    private putUpload;
     private cached;
     /** The token for a call, and the cache key it came from (dropped and fetched again after a 401). */
     private tokenFor;

package/dist/errors.d.ts

@@ -27,6 +27,11 @@ export declare class OpenApiError extends Error {
     get scope(): string | null;
     /** The user chose「不再询问」for the refused scope: do not ask again. */
     get neverAsk(): boolean;
+    /**
+     * Where the person agrees to show their name on posts (409 `consent_required`): send them there, an
+     * app cannot agree for them.
+     */
+    get consentUrl(): string | null;
     /** A refused, not yet asked or undeclared scope (403): degrade gracefully. */
     get isScopeError(): boolean;
 }

package/dist/gen/meta.d.ts

@@ -1,16 +1,16 @@
 /** The SDK's version (it follows the open API's). */
-export declare const VERSION = "1.0.0-rc.2";
+export declare const VERSION = "1.0.0-rc.4";
 /** 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 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", "trade:booking:readonly", "venue:readonly", "venue", "opening:readonly", "review", "profile:interest:readonly", "profile:interest", "profile:learning:readonly", "report:create", "community:post", "me:schedule:readonly", "me:learning:readonly", "me:words:readonly", "me:words", "insights:readonly"];
 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 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", "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"];
 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 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", "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"];
 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')[]>;
@@ -37,8 +37,18 @@ 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_TRADE_BOOKING_READONLY = "trade:booking:readonly";
+export declare const SCOPE_VENUE_READONLY = "venue:readonly";
+export declare const SCOPE_VENUE = "venue";
+export declare const SCOPE_OPENING_READONLY = "opening: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";
+export declare const SCOPE_COMMUNITY_POST = "community:post";
+export declare const SCOPE_ME_SCHEDULE_READONLY = "me:schedule:readonly";
+export declare const SCOPE_ME_LEARNING_READONLY = "me:learning:readonly";
+export declare const SCOPE_ME_WORDS_READONLY = "me:words:readonly";
+export declare const SCOPE_ME_WORDS = "me:words";
+export declare const SCOPE_INSIGHTS_READONLY = "insights:readonly";

package/dist/gen/operations.d.ts

@@ -65,6 +65,10 @@ export declare abstract class Operations {
     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'>>;
+    /** 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: string, body: BodyOf<'createClassSessions'>, options?: RequestOptions): Promise<ResultOf<'createClassSessions'>>;
+    /** 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: string, sessionId: string, body: BodyOf<'setClassSessionPlace'>, options?: RequestOptions): Promise<ResultOf<'setClassSessionPlace'>>;
     /** 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) */
@@ -137,24 +141,48 @@ export declare abstract class Operations {
     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) */
+    /** 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?: 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) */
+    /** 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: 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) */
+    /** 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: string, body?: BodyOf<'cancelTrialSlot'>, options?: RequestOptions): Promise<ResultOf<'cancelTrialSlot'>>;
+    /** Fill in (or change) the teacher of a trial draft (`PUT /trial/openings/{opening_id}/teacher`; tenant token; scopes: trial) */
+    setTrialTeacher(openingId: string, body: BodyOf<'setTrialTeacher'>, options?: RequestOptions): Promise<ResultOf<'setTrialTeacher'>>;
     /** 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 teaching sites (campuses), newest first (`GET /venues`; tenant token; scopes: venue:readonly, venue, trial) */
+    listVenues(query?: QueryOf<'listVenues'>, options?: RequestOptions): Promise<ResultOf<'listVenues'>>;
+    /** Every item of `listVenues`, page after page. */
+    listVenuesAll(query?: Omit<QueryOf<'listVenues'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listVenues'>>;
+    /** Create a draft teaching site (campus); it is published in the platform and reviewed as usual (`POST /venues`; tenant token; scopes: venue) */
+    createVenue(body: BodyOf<'createVenue'>, options?: RequestOptions): Promise<ResultOf<'createVenue'>>;
+    /** One teaching site (of this institution only) (`GET /venues/{venue_id}`; tenant token; scopes: venue:readonly, venue, trial) */
+    getVenue(venueId: string, options?: RequestOptions): Promise<ResultOf<'getVenue'>>;
+    /** 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?: QueryOf<'listOpenings'>, options?: RequestOptions): Promise<ResultOf<'listOpenings'>>;
+    /** Every item of `listOpenings`, page after page. */
+    listOpeningsAll(query?: Omit<QueryOf<'listOpenings'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listOpenings'>>;
+    /** One opening (`GET /openings/{opening_id}`; tenant / user token; scopes: opening:readonly) */
+    getOpening(openingId: string, options?: RequestOptions): Promise<ResultOf<'getOpening'>>;
+    /** 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?: QueryOf<'getInsights'>, options?: RequestOptions): Promise<ResultOf<'getInsights'>>;
     /** 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'>>;
+    /** 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?: QueryOf<'listBookings'>, options?: RequestOptions): Promise<ResultOf<'listBookings'>>;
+    /** Every item of `listBookings`, page after page. */
+    listBookingsAll(query?: Omit<QueryOf<'listBookings'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listBookings'>>;
+    /** One booked lesson (`GET /bookings/{booking_id}`; tenant token; scopes: trade:booking:readonly) */
+    getBooking(bookingId: string, options?: RequestOptions): Promise<ResultOf<'getBooking'>>;
     /** 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. */
@@ -173,5 +201,47 @@ export declare abstract class Operations {
     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'>>;
+    /** 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: BodyOf<'createCommunityImageUpload'>, options?: RequestOptions): Promise<ResultOf<'createCommunityImageUpload'>>;
+    /** Get an upload URL for a video (up to 4 GB, 1 hour) (`POST /community/videos`; user / tenant token; scopes: community:post) */
+    createCommunityVideoUpload(body: BodyOf<'createCommunityVideoUpload'>, options?: RequestOptions): Promise<ResultOf<'createCommunityVideoUpload'>>;
+    /** 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: string, options?: RequestOptions): Promise<ResultOf<'completeCommunityVideoUpload'>>;
+    /** Transcoding status (only for videos this app uploaded for this person) (`GET /community/videos/{asset_id}`; user / tenant token; scopes: community:post) */
+    getCommunityVideo(assetId: string, options?: RequestOptions): Promise<ResultOf<'getCommunityVideo'>>;
+    /** 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?: QueryOf<'listCommunityPosts'>, options?: RequestOptions): Promise<ResultOf<'listCommunityPosts'>>;
+    /** Every item of `listCommunityPosts`, page after page. */
+    listCommunityPostsAll(query?: Omit<QueryOf<'listCommunityPosts'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listCommunityPosts'>>;
+    /** 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: BodyOf<'createCommunityPost'>, options?: RequestOptions): Promise<ResultOf<'createCommunityPost'>>;
+    /** 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: string, options?: RequestOptions): Promise<ResultOf<'getCommunityPost'>>;
+    /** 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: string, options?: RequestOptions): Promise<ResultOf<'deleteCommunityPost'>>;
+    /** Categories a post can be filed under (those enabled in this region) (`GET /community/categories`; user / tenant token; scopes: community:post) */
+    listCommunityCategories(options?: RequestOptions): Promise<ResultOf<'listCommunityCategories'>>;
+    /** 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: QueryOf<'getMySchedule'>, options?: RequestOptions): Promise<ResultOf<'getMySchedule'>>;
+    /** Every item of `getMySchedule`, page after page. */
+    getMyScheduleAll(query?: Omit<QueryOf<'getMySchedule'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'getMySchedule'>>;
+    /** 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?: QueryOf<'listMyCourses'>, options?: RequestOptions): Promise<ResultOf<'listMyCourses'>>;
+    /** Every item of `listMyCourses`, page after page. */
+    listMyCoursesAll(query?: Omit<QueryOf<'listMyCourses'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listMyCourses'>>;
+    /** 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?: QueryOf<'listMyWords'>, options?: RequestOptions): Promise<ResultOf<'listMyWords'>>;
+    /** Every item of `listMyWords`, page after page. */
+    listMyWordsAll(query?: Omit<QueryOf<'listMyWords'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listMyWords'>>;
+    /** 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: BodyOf<'addMyWord'>, options?: RequestOptions): Promise<ResultOf<'addMyWord'>>;
+    /** A class's exams (tenant tokens only, own institution) (`GET /classes/{class_id}/exams`; tenant token; scopes: grade:readonly) */
+    listClassExams(classId: string, query?: QueryOf<'listClassExams'>, options?: RequestOptions): Promise<ResultOf<'listClassExams'>>;
+    /** Every item of `listClassExams`, page after page. */
+    listClassExamsAll(classId: string, query?: Omit<QueryOf<'listClassExams'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listClassExams'>>;
+    /** 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: string, examId: string, query?: QueryOf<'listClassExamResults'>, options?: RequestOptions): Promise<ResultOf<'listClassExamResults'>>;
+    /** Every item of `listClassExamResults`, page after page. */
+    listClassExamResultsAll(classId: string, examId: string, query?: Omit<QueryOf<'listClassExamResults'>, 'page_token'>, options?: RequestOptions): AsyncIterable<ItemOf<'listClassExamResults'>>;
 }
 export {};