@examplary/sdk 2.0.1 → 2.1.0

package/dist/{generated/types.d.ts → index.d.mts}

@@ -1,4 +1,18 @@
-export interface paths {
+import { AxiosRequestConfig, CreateAxiosDefaults, AxiosInstance, AxiosError, InternalAxiosRequestConfig, AxiosResponse } from 'axios';
+
+type ExamplaryDefaults = Omit<CreateAxiosDefaults, "baseURL">;
+interface ExamplaryClientOptions extends ExamplaryDefaults {
+    apiKey: string;
+    baseUrl?: string;
+}
+type ExamplaryRequestOptions = Omit<AxiosRequestConfig, "method" | "url" | "data" | "params" | "baseURL">;
+
+interface ClientContext {
+    axios: AxiosInstance;
+    apiKey: string;
+}
+
+interface paths {
     "/question-types/public": {
         parameters: {
             query?: never;
@@ -1910,8 +1924,7 @@ export interface paths {
         trace?: never;
     };
 }
-export type webhooks = Record<string, never>;
-export interface components {
+interface components {
     schemas: never;
     responses: never;
     parameters: never;
@@ -1919,8 +1932,7 @@ export interface components {
     headers: never;
     pathItems: never;
 }
-export type $defs = Record<string, never>;
-export interface operations {
+interface operations {
     "questionTypes.listPublic": {
         parameters: {
             query?: never;
@@ -5423,3 +5435,1533 @@ export interface operations {
         responses: never;
     };
 }
+
+interface _PathOverrides {
+    "questionTypes.get": {
+        id: string;
+    };
+    "questionTypes.delete": {
+        id: string;
+    };
+    "questionTypes.getQti3Pci": {
+        questionTypeId: string;
+    };
+    "questionTypes.enable": {
+        questionTypeId: string;
+    };
+    "questionTypes.disable": {
+        questionTypeId: string;
+    };
+    "library.publishers.items.list": {
+        publisherId: string;
+    };
+    "library.publishers.items.create": {
+        publisherId: string;
+    };
+    "library.items.update": {
+        itemId: string;
+    };
+    "library.items.delete": {
+        itemId: string;
+    };
+    "library.publishers.update": {
+        publisherId: string;
+    };
+    "library.publishers.delete": {
+        publisherId: string;
+    };
+    "embedSessions.get": {
+        id: string;
+    };
+    "embedSessions.revoke": {
+        id: string;
+    };
+    "attributes.update": {
+        id: string;
+    };
+    "attributes.delete": {
+        id: string;
+    };
+    "taxonomies.update": {
+        id: string;
+    };
+    "taxonomies.delete": {
+        id: string;
+    };
+    "permissions.list": {
+        resource: string;
+    };
+    "permissions.assign": {
+        resource: string;
+    };
+    "permissions.getActorRole": {
+        actor: string;
+        resource: string;
+    };
+    "permissions.delete": {
+        resource: string;
+        actor: string;
+    };
+    "users.update": {
+        id: string;
+    };
+    "users.delete": {
+        id: string;
+    };
+    "exams.sessions.list": {
+        examId: string;
+    };
+    "exams.sessions.import": {
+        examId: string;
+    };
+    "exams.sessions.scan": {
+        examId: string;
+    };
+    "exams.sessions.scanDocument": {
+        examId: string;
+    };
+    "exams.sessions.get": {
+        examId: string;
+        sessionId: string;
+    };
+    "exams.sessions.delete": {
+        examId: string;
+        sessionId: string;
+    };
+    "exams.sessions.saveFeedback": {
+        examId: string;
+        sessionId: string;
+    };
+    "exams.sessions.saveOverallFeedback": {
+        examId: string;
+        sessionId: string;
+    };
+    "exams.sessions.generateOverallFeedback": {
+        examId: string;
+        sessionId: string;
+    };
+    "exams.sessions.acceptAllSuggestions": {
+        examId: string;
+        sessionId: string;
+    };
+    "exams.sessions.acceptSuggestion": {
+        examId: string;
+        sessionId: string;
+        questionId: string;
+    };
+    "exams.sessions.editAnswer": {
+        examId: string;
+        sessionId: string;
+        questionId: string;
+    };
+    "exams.questions.import": {
+        examId: string;
+    };
+    "exams.questions.generate": {
+        examId: string;
+    };
+    "exams.questions.get": {
+        examId: string;
+        questionId: string;
+    };
+    "exams.questions.regenerate": {
+        examId: string;
+        questionId: string;
+    };
+    "exams.export.qti3Zip": {
+        examId: string;
+    };
+    "exams.export.qti21Zip": {
+        examId: string;
+    };
+    "exams.get": {
+        id: string;
+    };
+    "exams.update": {
+        id: string;
+    };
+    "exams.delete": {
+        id: string;
+    };
+    "exams.duplicate": {
+        examId: string;
+    };
+    "exams.print": {
+        examId: string;
+    };
+    "exams.startGeneration": {
+        examId: string;
+    };
+    "exams.cancelGeneration": {
+        examId: string;
+    };
+    "exams.getContextSuggestions": {
+        examId: string;
+    };
+    "practiceSpaces.get": {
+        id: string;
+    };
+    "practiceSpaces.update": {
+        id: string;
+    };
+    "practiceSpaces.delete": {
+        id: string;
+    };
+    "practiceSpaces.duplicate": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.generateTopics": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.cancelGenerateTopics": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.questionsPreview": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.getProgress": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.generateTopicFeedback": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.students.list": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.students.get": {
+        practiceSpaceId: string;
+        studentId: string;
+    };
+    "practiceSpaces.sessions.create": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.sessions.getMine": {
+        practiceSpaceId: string;
+    };
+    "practiceSpaces.sessions.get": {
+        practiceSpaceId: string;
+        sessionId: string;
+    };
+    "practiceSpaces.sessions.saveAnswer": {
+        practiceSpaceId: string;
+        sessionId: string;
+        questionId: string;
+    };
+    "sourceMaterials.get": {
+        id: string;
+    };
+    "sourceMaterials.update": {
+        id: string;
+    };
+    "sourceMaterials.delete": {
+        id: string;
+    };
+    "sourceMaterials.slice": {
+        sourceMaterialId: string;
+    };
+    "folders.update": {
+        id: string;
+    };
+    "folders.delete": {
+        id: string;
+    };
+    "groups.update": {
+        id: string;
+    };
+    "groups.delete": {
+        id: string;
+    };
+    "groups.listMembers": {
+        groupId: string;
+    };
+    "groups.addMember": {
+        groupId: string;
+    };
+    "groups.updateMember": {
+        groupId: string;
+        userId: string;
+    };
+    "groups.removeMember": {
+        groupId: string;
+        userId: string;
+    };
+    "questionBank.update": {
+        id: string;
+    };
+    "questionBank.delete": {
+        id: string;
+    };
+    "patchRubrics:id": {
+        id: string;
+    };
+    "deleteRubrics:id": {
+        id: string;
+    };
+    "jobs.get": {
+        id: string;
+    };
+    "jobs.cancel": {
+        id: string;
+    };
+}
+type _ToObject<T> = [Exclude<T, undefined>] extends [never] ? {} : Exclude<T, undefined> extends object ? Exclude<T, undefined> : {};
+type _Query<K extends keyof operations> = operations[K] extends {
+    parameters: {
+        query?: infer Q;
+    };
+} ? _ToObject<Q> : {};
+type _Body<K extends keyof operations> = operations[K] extends {
+    requestBody?: infer R;
+} ? Exclude<R, undefined> extends {
+    content: {
+        "application/json": infer B;
+    };
+} ? _ToObject<B> : {} : {};
+type _SuccessShape<R> = [R] extends [never] ? never : R extends {
+    200: infer T;
+} ? T : R extends {
+    201: infer T;
+} ? T : R extends {
+    202: infer T;
+} ? T : R extends {
+    204: infer T;
+} ? T : never;
+type Args<K extends keyof operations> = (K extends keyof _PathOverrides ? _PathOverrides[K] : {}) & _Query<K> & _Body<K>;
+type Response<K extends keyof operations> = _SuccessShape<operations[K]["responses"]> extends infer X ? [X] extends [never] ? any : X extends {
+    content: {
+        "application/json": infer T;
+    };
+} ? T : any : any;
+declare class QuestionTypes {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List public question types
+     *
+     * Lists all public question types, which can be enabled in workspaces.
+     *
+     * API endpoint: `GET /question-types/public`
+     */
+    listPublic(args?: Args<"questionTypes.listPublic">, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.listPublic">>;
+    /**
+     * Get question type
+     *
+     * Retrieves a specific question type by its ID.
+     *
+     * API endpoint: `GET /question-types/{id}`
+     */
+    get(id: string, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.get">>;
+    get(args: Args<"questionTypes.get">, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.get">>;
+    /**
+     * Delete question type
+     *
+     * Deletes a specific question type by its ID. Note that only the owner organization of the question type can delete it, and only if it has not been used in an exam.
+     *
+     * API endpoint: `DELETE /question-types/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.delete">>;
+    delete(args: Args<"questionTypes.delete">, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.delete">>;
+    /**
+     * Get question type PCI module for QTI 3 export
+     *
+     * Get JS module for a question type PCI for QTI 3 export.
+     *
+     * API endpoint: `GET /question-types/{questionTypeId}/export/qti3-pci`
+     */
+    getQti3Pci(questionTypeId: string, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.getQti3Pci">>;
+    getQti3Pci(args: Args<"questionTypes.getQti3Pci">, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.getQti3Pci">>;
+    /**
+     * List question types
+     *
+     * Lists all question types, either those available by default or those created within the user's organization.
+     *
+     * API endpoint: `GET /question-types`
+     */
+    list(args?: Args<"questionTypes.list">, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.list">>;
+    /**
+     * Upsert question type
+     *
+     * Creates a new question type or updates an existing one. If the question type already exists, it will be updated; otherwise, a new one will be created.
+     *
+     * API endpoint: `POST /question-types`
+     */
+    upsert(args?: Args<"questionTypes.upsert">, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.upsert">>;
+    /**
+     * Enable question type
+     *
+     * Enable a question type for the current workspace.
+     *
+     * API endpoint: `POST /question-types/{questionTypeId}/enable`
+     */
+    enable(questionTypeId: string, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.enable">>;
+    enable(args: Args<"questionTypes.enable">, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.enable">>;
+    /**
+     * Disable question type
+     *
+     * Disable a question type for the current workspace.
+     *
+     * API endpoint: `POST /question-types/{questionTypeId}/disable`
+     */
+    disable(questionTypeId: string, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.disable">>;
+    disable(args: Args<"questionTypes.disable">, options?: ExamplaryRequestOptions): Promise<Response<"questionTypes.disable">>;
+}
+declare class LibraryPublishersItems {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List items by publisher
+     *
+     * Lists all library items for the specified publisher profile.
+     *
+     * API endpoint: `GET /library/publishers/{publisherId}/items`
+     */
+    list(publisherId: string, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.items.list">>;
+    list(args: Args<"library.publishers.items.list">, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.items.list">>;
+    /**
+     * Create library item
+     *
+     * Adds an item to the library. Only the publisher owner can add items to their publisher profile.
+     *
+     * API endpoint: `POST /library/publishers/{publisherId}/items`
+     */
+    create(args: Args<"library.publishers.items.create">, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.items.create">>;
+}
+declare class LibraryPublishers {
+    private readonly ctx;
+    readonly items: LibraryPublishersItems;
+    constructor(ctx: ClientContext);
+    /**
+     * List featured publishers
+     *
+     * Lists all library publishers that are marked as featured.
+     *
+     * API endpoint: `GET /library/publishers/featured`
+     */
+    listFeatured(args?: Args<"library.publishers.listFeatured">, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.listFeatured">>;
+    /**
+     * List all publishers
+     *
+     * Lists all library publisher profiles.
+     *
+     * API endpoint: `GET /library/publishers`
+     */
+    listAll(args?: Args<"library.publishers.listAll">, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.listAll">>;
+    /**
+     * Create publisher
+     *
+     * Creates a new library publisher profile.
+     *
+     * API endpoint: `POST /library/publishers`
+     */
+    create(args?: Args<"library.publishers.create">, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.create">>;
+    /**
+     * List my publishers
+     *
+     * Lists all library publisher profiles created by the authenticated user.
+     *
+     * API endpoint: `GET /library/publishers/mine`
+     */
+    listMine(args?: Args<"library.publishers.listMine">, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.listMine">>;
+    /**
+     * Update publisher
+     *
+     * Updates a library publisher profile. Only the owner can update their publisher profile.
+     *
+     * API endpoint: `PATCH /library/publishers/{publisherId}`
+     */
+    update(args: Args<"library.publishers.update">, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.update">>;
+    /**
+     * Delete publisher
+     *
+     * Deletes a library publisher profile. Only the owner can delete their publisher profile.
+     *
+     * API endpoint: `DELETE /library/publishers/{publisherId}`
+     */
+    delete(publisherId: string, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.delete">>;
+    delete(args: Args<"library.publishers.delete">, options?: ExamplaryRequestOptions): Promise<Response<"library.publishers.delete">>;
+}
+declare class LibraryItems {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List featured library items
+     *
+     * Lists all library items that are marked as featured.
+     *
+     * API endpoint: `GET /library/items/featured`
+     */
+    listFeatured(args?: Args<"library.items.listFeatured">, options?: ExamplaryRequestOptions): Promise<Response<"library.items.listFeatured">>;
+    /**
+     * Update library item
+     *
+     * Updates a library item. Only the publisher owner can update items in their publisher profile.
+     *
+     * API endpoint: `PATCH /library/items/{itemId}`
+     */
+    update(args: Args<"library.items.update">, options?: ExamplaryRequestOptions): Promise<Response<"library.items.update">>;
+    /**
+     * Delete library item
+     *
+     * Deletes a library item. Only the publisher owner can delete items from their publisher profile.
+     *
+     * API endpoint: `DELETE /library/items/{itemId}`
+     */
+    delete(itemId: string, options?: ExamplaryRequestOptions): Promise<Response<"library.items.delete">>;
+    delete(args: Args<"library.items.delete">, options?: ExamplaryRequestOptions): Promise<Response<"library.items.delete">>;
+}
+declare class Library {
+    private readonly ctx;
+    readonly publishers: LibraryPublishers;
+    readonly items: LibraryItems;
+    constructor(ctx: ClientContext);
+}
+declare class Oauth {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * OAuth authorization endpoint
+     *
+     * Initiates OAuth authorization flow. Redirects to the frontend authorization UI where users can approve or deny access.
+     *
+     * API endpoint: `GET /oauth/authorize`
+     */
+    authorize(args: Args<"oauth.authorize">, options?: ExamplaryRequestOptions): Promise<Response<"oauth.authorize">>;
+    /**
+     * OAuth token endpoint
+     *
+     * Exchange authorization code for access token, or refresh an existing token.
+     *
+     * API endpoint: `POST /oauth/token`
+     */
+    token(args?: Args<"oauth.token">, options?: ExamplaryRequestOptions): Promise<Response<"oauth.token">>;
+}
+declare class EmbedSessions {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Create embed session
+     *
+     * Create a new embed session. This allows you to embed the exam generation flow into your own application.
+     *
+     * API endpoint: `POST /embed-sessions`
+     */
+    create(args?: Args<"embedSessions.create">, options?: ExamplaryRequestOptions): Promise<Response<"embedSessions.create">>;
+    /**
+     * Get embed session
+     *
+     * Retrieve an embed session by its ID.
+     *
+     * API endpoint: `GET /embed-sessions/{id}`
+     */
+    get(id: string, options?: ExamplaryRequestOptions): Promise<Response<"embedSessions.get">>;
+    get(args: Args<"embedSessions.get">, options?: ExamplaryRequestOptions): Promise<Response<"embedSessions.get">>;
+    /**
+     * Revoke embed session
+     *
+     * Revoke access to an embed session by its ID.
+     *
+     * API endpoint: `DELETE /embed-sessions/{id}`
+     */
+    revoke(id: string, options?: ExamplaryRequestOptions): Promise<Response<"embedSessions.revoke">>;
+    revoke(args: Args<"embedSessions.revoke">, options?: ExamplaryRequestOptions): Promise<Response<"embedSessions.revoke">>;
+}
+declare class Me {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Get me
+     *
+     * Get the current user's account details.
+     *
+     * API endpoint: `GET /me`
+     */
+    get(args?: Args<"me.get">, options?: ExamplaryRequestOptions): Promise<Response<"me.get">>;
+    /**
+     * Update me
+     *
+     * Update the current user's account details.
+     *
+     * API endpoint: `PATCH /me`
+     */
+    update(args?: Args<"me.update">, options?: ExamplaryRequestOptions): Promise<Response<"me.update">>;
+}
+declare class Media {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Get file upload URL
+     *
+     * Returns a signed URL for uploading a file, and a public URL for accessing it afterwards.
+     *
+     * API endpoint: `GET /media/upload`
+     */
+    upload(args: Args<"media.upload">, options?: ExamplaryRequestOptions): Promise<Response<"media.upload">>;
+}
+declare class OrgCustomDomain {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Get custom domain configuration
+     *
+     * API endpoint: `GET /org/custom-domain`
+     */
+    get(args?: Args<"org.customDomain.get">, options?: ExamplaryRequestOptions): Promise<Response<"org.customDomain.get">>;
+    /**
+     * Update custom domain configuration
+     *
+     * API endpoint: `POST /org/custom-domain`
+     */
+    update(args?: Args<"org.customDomain.update">, options?: ExamplaryRequestOptions): Promise<Response<"org.customDomain.update">>;
+}
+declare class Org {
+    private readonly ctx;
+    readonly customDomain: OrgCustomDomain;
+    constructor(ctx: ClientContext);
+    /**
+     * Get organization
+     *
+     * API endpoint: `GET /org`
+     */
+    get(args?: Args<"org.get">, options?: ExamplaryRequestOptions): Promise<Response<"org.get">>;
+    /**
+     * Update organization
+     *
+     * API endpoint: `PATCH /org`
+     */
+    update(args?: Args<"org.update">, options?: ExamplaryRequestOptions): Promise<Response<"org.update">>;
+    /**
+     * Delete organization
+     *
+     * API endpoint: `DELETE /org`
+     */
+    delete(args?: Args<"org.delete">, options?: ExamplaryRequestOptions): Promise<Response<"org.delete">>;
+}
+declare class Orgs {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List all organizations
+     *
+     * API endpoint: `GET /orgs`
+     */
+    list(args?: Args<"orgs.list">, options?: ExamplaryRequestOptions): Promise<Response<"orgs.list">>;
+    /**
+     * Create a new organization
+     *
+     * Create a new workspace to collaborate with others on exams.
+     *
+     * API endpoint: `POST /orgs`
+     */
+    create(args?: Args<"orgs.create">, options?: ExamplaryRequestOptions): Promise<Response<"orgs.create">>;
+}
+declare class ApiKeys {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Get API key
+     *
+     * Get the API key for the current org/user combination. Creates one if none exists.
+     *
+     * API endpoint: `GET /api-keys`
+     */
+    get(args?: Args<"apiKeys.get">, options?: ExamplaryRequestOptions): Promise<Response<"apiKeys.get">>;
+    /**
+     * Reset API key
+     *
+     * Invalidate old API keys for this org/user and create a new one.
+     *
+     * API endpoint: `POST /api-keys/reset`
+     */
+    reset(args?: Args<"apiKeys.reset">, options?: ExamplaryRequestOptions): Promise<Response<"apiKeys.reset">>;
+}
+declare class Attributes {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List attributes
+     *
+     * Get all custom attributes configured for the current workspace.
+     *
+     * API endpoint: `GET /attributes`
+     */
+    list(args?: Args<"attributes.list">, options?: ExamplaryRequestOptions): Promise<Response<"attributes.list">>;
+    /**
+     * Create attribute
+     *
+     * Create a new custom attribute in the current workspace.
+     *
+     * API endpoint: `POST /attributes`
+     */
+    create(args?: Args<"attributes.create">, options?: ExamplaryRequestOptions): Promise<Response<"attributes.create">>;
+    /**
+     * Reorder attributes
+     *
+     * Update the position of multiple attributes at once.
+     *
+     * API endpoint: `POST /attributes/reorder`
+     */
+    reorder(args?: Args<"attributes.reorder">, options?: ExamplaryRequestOptions): Promise<Response<"attributes.reorder">>;
+    /**
+     * Update attribute
+     *
+     * Update an existing attribute in the current workspace.
+     *
+     * API endpoint: `POST /attributes/{id}`
+     */
+    update(args: Args<"attributes.update">, options?: ExamplaryRequestOptions): Promise<Response<"attributes.update">>;
+    /**
+     * Delete attribute
+     *
+     * Delete a custom attribute from the current workspace. Default attributes cannot be deleted.
+     *
+     * API endpoint: `DELETE /attributes/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"attributes.delete">>;
+    delete(args: Args<"attributes.delete">, options?: ExamplaryRequestOptions): Promise<Response<"attributes.delete">>;
+}
+declare class Taxonomies {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Get taxonomies
+     *
+     * Get a list available taxonomies, including defaults and taxonomies created in the current workspace.
+     *
+     * API endpoint: `GET /taxonomies`
+     */
+    list(args?: Args<"taxonomies.list">, options?: ExamplaryRequestOptions): Promise<Response<"taxonomies.list">>;
+    /**
+     * Create taxonomy
+     *
+     * Save a new taxonomy in the current workspace.
+     *
+     * API endpoint: `POST /taxonomies`
+     */
+    create(args?: Args<"taxonomies.create">, options?: ExamplaryRequestOptions): Promise<Response<"taxonomies.create">>;
+    /**
+     * Update taxonomy
+     *
+     * Update an existing taxonomy in the current workspace.
+     *
+     * API endpoint: `POST /taxonomies/{id}`
+     */
+    update(args: Args<"taxonomies.update">, options?: ExamplaryRequestOptions): Promise<Response<"taxonomies.update">>;
+    /**
+     * Delete taxonomy
+     *
+     * Delete a taxonomy from the current workspace. This fails if there are any exams associated with the taxonomy.
+     *
+     * API endpoint: `DELETE /taxonomies/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"taxonomies.delete">>;
+    delete(args: Args<"taxonomies.delete">, options?: ExamplaryRequestOptions): Promise<Response<"taxonomies.delete">>;
+}
+declare class Permissions {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Autocomplete users and groups
+     *
+     * Search for users and groups to share with. Returns matches by name or email. Respects restricted group visibility.
+     *
+     * API endpoint: `GET /permissions/autocomplete`
+     */
+    autocomplete(args: Args<"permissions.autocomplete">, options?: ExamplaryRequestOptions): Promise<Response<"permissions.autocomplete">>;
+    /**
+     * Get sharing permissions
+     *
+     * Get a list of users, groups and orgs that have access to a specific resource.
+     *
+     * API endpoint: `GET /permissions/{resource}`
+     */
+    list(resource: string, options?: ExamplaryRequestOptions): Promise<Response<"permissions.list">>;
+    list(args: Args<"permissions.list">, options?: ExamplaryRequestOptions): Promise<Response<"permissions.list">>;
+    /**
+     * Create permission
+     *
+     * Create a new permission for a specific resource, or update the role of an existing actor.
+     *
+     * API endpoint: `POST /permissions/{resource}`
+     */
+    assign(args: Args<"permissions.assign">, options?: ExamplaryRequestOptions): Promise<Response<"permissions.assign">>;
+    /**
+     * Get actor role
+     *
+     * Get the role of a specific actor for a specific resource.
+     *
+     * API endpoint: `GET /permissions/{resource}/{actor}`
+     */
+    getActorRole(args: Args<"permissions.getActorRole">, options?: ExamplaryRequestOptions): Promise<Response<"permissions.getActorRole">>;
+    /**
+     * Remove permission
+     *
+     * Remove a permission for a specific actor on a specific resource.
+     *
+     * API endpoint: `DELETE /permissions/{resource}/{actor}`
+     */
+    delete(args: Args<"permissions.delete">, options?: ExamplaryRequestOptions): Promise<Response<"permissions.delete">>;
+}
+declare class StudentLevels {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List available student levels
+     *
+     * Get a list of available default student levels.
+     *
+     * API endpoint: `GET /student-levels`
+     */
+    list(args?: Args<"studentLevels.list">, options?: ExamplaryRequestOptions): Promise<Response<"studentLevels.list">>;
+}
+declare class Users {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List users
+     *
+     * Get a list of all users in the workspace.
+     *
+     * API endpoint: `GET /users`
+     */
+    list(args?: Args<"users.list">, options?: ExamplaryRequestOptions): Promise<Response<"users.list">>;
+    /**
+     * Create user
+     *
+     * Create a new user in the workspace.
+     *
+     * API endpoint: `POST /users`
+     */
+    create(args?: Args<"users.create">, options?: ExamplaryRequestOptions): Promise<Response<"users.create">>;
+    /**
+     * Update user role
+     *
+     * Update a user's role within the workspace.
+     *
+     * API endpoint: `PATCH /users/{id}`
+     */
+    update(id: string, options?: ExamplaryRequestOptions): Promise<Response<"users.update">>;
+    update(args: Args<"users.update">, options?: ExamplaryRequestOptions): Promise<Response<"users.update">>;
+    /**
+     * Delete user
+     *
+     * Delete a user from the workspace.
+     *
+     * API endpoint: `DELETE /users/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"users.delete">>;
+    delete(args: Args<"users.delete">, options?: ExamplaryRequestOptions): Promise<Response<"users.delete">>;
+}
+declare class ExamsSessions {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List exam sessions
+     *
+     * Get a list of all student sessions for an exam, representing a set of answers from a student.
+     *
+     * API endpoint: `GET /exams/{examId}/sessions`
+     */
+    list(examId: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.list">>;
+    list(args: Args<"exams.sessions.list">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.list">>;
+    /**
+     * Create session
+     *
+     * Manually create a session, possibly from uploaded data.
+     *
+     * API endpoint: `POST /exams/{examId}/sessions`
+     */
+    import(args: Args<"exams.sessions.import">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.import">>;
+    /**
+     * Get answers from scan
+     *
+     * Scan student answers from a document.
+     *
+     * API endpoint: `POST /exams/{examId}/sessions/scan`
+     */
+    scan(examId: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.scan">>;
+    scan(args: Args<"exams.sessions.scan">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.scan">>;
+    /**
+     * Scan document for student answers
+     *
+     * Start a background task to extract student answers from an uploaded PDF document.
+     *
+     * API endpoint: `POST /exams/{examId}/sessions/scan-document`
+     */
+    scanDocument(args: Args<"exams.sessions.scanDocument">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.scanDocument">>;
+    /**
+     * Get exam session
+     *
+     * Get a single exam session by its ID, representing a set of answers from a student.
+     *
+     * API endpoint: `GET /exams/{examId}/sessions/{sessionId}`
+     */
+    get(args: Args<"exams.sessions.get">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.get">>;
+    /**
+     * Delete exam session
+     *
+     * Remove an exam session.
+     *
+     * API endpoint: `DELETE /exams/{examId}/sessions/{sessionId}`
+     */
+    delete(args: Args<"exams.sessions.delete">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.delete">>;
+    /**
+     * Provide feedback
+     *
+     * Set teacher feedback and/or a grade for a specific question in an exam session.
+     *
+     * API endpoint: `POST /exams/{examId}/sessions/{sessionId}/feedback`
+     */
+    saveFeedback(args: Args<"exams.sessions.saveFeedback">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.saveFeedback">>;
+    /**
+     * Provide overall feedback
+     *
+     * Set teacher feedback for the test as a whole in an exam session.
+     *
+     * API endpoint: `POST /exams/{examId}/sessions/{sessionId}/overall-feedback`
+     */
+    saveOverallFeedback(args: Args<"exams.sessions.saveOverallFeedback">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.saveOverallFeedback">>;
+    /**
+     * Generate overall feedback
+     *
+     * Generate feedback for the test as a whole in an exam session.
+     *
+     * API endpoint: `POST /exams/{examId}/sessions/{sessionId}/generate-overall-feedback`
+     */
+    generateOverallFeedback(args: Args<"exams.sessions.generateOverallFeedback">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.generateOverallFeedback">>;
+    /**
+     * Accept AI grading suggestions
+     *
+     * Accept all AI-generated grading suggestions for the exam session.
+     *
+     * API endpoint: `POST /exams/{examId}/sessions/{sessionId}/suggestions/accept-all`
+     */
+    acceptAllSuggestions(args: Args<"exams.sessions.acceptAllSuggestions">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.acceptAllSuggestions">>;
+    /**
+     * Accept single AI grading suggestion
+     *
+     * Accept a single AI-generated grading suggestion for the exam session.
+     *
+     * API endpoint: `POST /exams/{examId}/sessions/{sessionId}/suggestions/{questionId}/accept`
+     */
+    acceptSuggestion(args: Args<"exams.sessions.acceptSuggestion">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.acceptSuggestion">>;
+    /**
+     * Edit answer
+     *
+     * Edit a single answer in an exam session.
+     *
+     * API endpoint: `PATCH /exams/{examId}/sessions/{sessionId}/answers/{questionId}`
+     */
+    editAnswer(args: Args<"exams.sessions.editAnswer">, options?: ExamplaryRequestOptions): Promise<Response<"exams.sessions.editAnswer">>;
+}
+declare class ExamsQuestions {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Import questions
+     *
+     * Import questions into an exam from a file. Support Word, PDF, Moodle quiz XML and plain text files.
+     *
+     * API endpoint: `POST /exams/{examId}/questions/import`
+     */
+    import(args: Args<"exams.questions.import">, options?: ExamplaryRequestOptions): Promise<Response<"exams.questions.import">>;
+    /**
+     * Generate question
+     *
+     * Generate a new question for the exam using an AI prompt.
+     *
+     * API endpoint: `POST /exams/{examId}/questions/generate`
+     */
+    generate(args: Args<"exams.questions.generate">, options?: ExamplaryRequestOptions): Promise<Response<"exams.questions.generate">>;
+    /**
+     * Get question
+     *
+     * Retrieve a question by its ID.
+     *
+     * API endpoint: `GET /exams/{examId}/questions/{questionId}`
+     */
+    get(args: Args<"exams.questions.get">, options?: ExamplaryRequestOptions): Promise<Response<"exams.questions.get">>;
+    /**
+     * Regenerate question
+     *
+     * Update a question using an AI prompt.
+     *
+     * API endpoint: `POST /exams/{examId}/questions/{questionId}/generate`
+     */
+    regenerate(args: Args<"exams.questions.regenerate">, options?: ExamplaryRequestOptions): Promise<Response<"exams.questions.regenerate">>;
+}
+declare class ExamsExport {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Export QTI 3 package
+     *
+     * Export an exam as a QTI 3 ZIP package.
+     *
+     * API endpoint: `POST /exams/{examId}/export/qti3-zip`
+     */
+    qti3Zip(examId: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.export.qti3Zip">>;
+    qti3Zip(args: Args<"exams.export.qti3Zip">, options?: ExamplaryRequestOptions): Promise<Response<"exams.export.qti3Zip">>;
+    /**
+     * Export QTI 2.1 package
+     *
+     * Export an exam as a QTI 2.1 ZIP package.
+     *
+     * API endpoint: `POST /exams/{examId}/export/qti21-zip`
+     */
+    qti21Zip(examId: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.export.qti21Zip">>;
+    qti21Zip(args: Args<"exams.export.qti21Zip">, options?: ExamplaryRequestOptions): Promise<Response<"exams.export.qti21Zip">>;
+}
+declare class Exams {
+    private readonly ctx;
+    readonly sessions: ExamsSessions;
+    readonly questions: ExamsQuestions;
+    readonly export: ExamsExport;
+    constructor(ctx: ClientContext);
+    /**
+     * List exams
+     *
+     * Get a list of all exams within your workspace.
+     *
+     * API endpoint: `GET /exams`
+     */
+    list(args: Args<"exams.list">, options?: ExamplaryRequestOptions): Promise<Response<"exams.list">>;
+    /**
+     * Create exam
+     *
+     * Create a new exam within your workspace.
+     *
+     * API endpoint: `POST /exams`
+     */
+    create(args?: Args<"exams.create">, options?: ExamplaryRequestOptions): Promise<Response<"exams.create">>;
+    /**
+     * Import exam
+     *
+     * Create an exam by importing one or more source materials (e.g. an existing exam).
+     *
+     * API endpoint: `POST /exams/import`
+     */
+    import(args?: Args<"exams.import">, options?: ExamplaryRequestOptions): Promise<Response<"exams.import">>;
+    /**
+     * Get exam
+     *
+     * Get a single exam by its ID.
+     *
+     * API endpoint: `GET /exams/{id}`
+     */
+    get(id: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.get">>;
+    get(args: Args<"exams.get">, options?: ExamplaryRequestOptions): Promise<Response<"exams.get">>;
+    /**
+     * Update exam
+     *
+     * Update an existing exam.
+     *
+     * API endpoint: `POST /exams/{id}`
+     */
+    update(id: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.update">>;
+    update(args: Args<"exams.update">, options?: ExamplaryRequestOptions): Promise<Response<"exams.update">>;
+    /**
+     * Delete exam
+     *
+     * Delete the exam.
+     *
+     * API endpoint: `DELETE /exams/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.delete">>;
+    delete(args: Args<"exams.delete">, options?: ExamplaryRequestOptions): Promise<Response<"exams.delete">>;
+    /**
+     * Duplicate exam
+     *
+     * Duplicate the exam's questions and settings to a new exam.
+     *
+     * API endpoint: `POST /exams/{examId}/duplicate`
+     */
+    duplicate(args: Args<"exams.duplicate">, options?: ExamplaryRequestOptions): Promise<Response<"exams.duplicate">>;
+    /**
+     * Print exam
+     *
+     * Export an exam to a PDF file or Word document.
+     *
+     * API endpoint: `POST /exams/{examId}/print`
+     */
+    print(examId: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.print">>;
+    print(args: Args<"exams.print">, options?: ExamplaryRequestOptions): Promise<Response<"exams.print">>;
+    /**
+     * Generate exam
+     *
+     * Initiate a job to generate new questions for the exam using AI, based on the source materials and metadata specified.
+     *
+     * API endpoint: `POST /exams/{examId}/generate`
+     */
+    startGeneration(examId: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.startGeneration">>;
+    startGeneration(args: Args<"exams.startGeneration">, options?: ExamplaryRequestOptions): Promise<Response<"exams.startGeneration">>;
+    /**
+     * Cancel exam generation
+     *
+     * Cancel an ongoing job to generate new questions for the exam using AI.
+     *
+     * API endpoint: `POST /exams/{examId}/generate/cancel`
+     */
+    cancelGeneration(examId: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.cancelGeneration">>;
+    cancelGeneration(args: Args<"exams.cancelGeneration">, options?: ExamplaryRequestOptions): Promise<Response<"exams.cancelGeneration">>;
+    /**
+     * Get exam context suggestions
+     *
+     * Get AI-generated suggestions for context/instructions to include in the exam generation prompt, based on the source materials linked to the exam.
+     *
+     * API endpoint: `GET /exams/{examId}/context-suggestions`
+     */
+    getContextSuggestions(examId: string, options?: ExamplaryRequestOptions): Promise<Response<"exams.getContextSuggestions">>;
+    getContextSuggestions(args: Args<"exams.getContextSuggestions">, options?: ExamplaryRequestOptions): Promise<Response<"exams.getContextSuggestions">>;
+}
+declare class PracticeSpacesStudents {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List practice space students
+     *
+     * Get a list of all students that practiced in a practice space.
+     *
+     * API endpoint: `GET /practice-spaces/{practiceSpaceId}/students`
+     */
+    list(practiceSpaceId: string, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.students.list">>;
+    list(args: Args<"practiceSpaces.students.list">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.students.list">>;
+    /**
+     * Get practice space student
+     *
+     * Get details about a specific practice space student.
+     *
+     * API endpoint: `GET /practice-spaces/{practiceSpaceId}/students/{studentId}`
+     */
+    get(args: Args<"practiceSpaces.students.get">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.students.get">>;
+}
+declare class PracticeSpacesSessions {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Create practice space session
+     *
+     * Create a new practice space session.
+     *
+     * API endpoint: `POST /practice-spaces/{practiceSpaceId}/sessions`
+     */
+    create(args: Args<"practiceSpaces.sessions.create">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.sessions.create">>;
+    /**
+     * Get my practice space session
+     *
+     * Get the current user's past practice space session.
+     *
+     * API endpoint: `GET /practice-spaces/{practiceSpaceId}/sessions/mine`
+     */
+    getMine(practiceSpaceId: string, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.sessions.getMine">>;
+    getMine(args: Args<"practiceSpaces.sessions.getMine">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.sessions.getMine">>;
+    /**
+     * Get practice space session
+     *
+     * Get a practice space session by its ID.
+     *
+     * API endpoint: `GET /practice-spaces/{practiceSpaceId}/sessions/{sessionId}`
+     */
+    get(args: Args<"practiceSpaces.sessions.get">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.sessions.get">>;
+    /**
+     * Save answer for a practice space session
+     *
+     * Save an answer for a specific question in a practice space session.
+     *
+     * API endpoint: `POST /practice-spaces/{practiceSpaceId}/sessions/{sessionId}/answers/{questionId}`
+     */
+    saveAnswer(args: Args<"practiceSpaces.sessions.saveAnswer">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.sessions.saveAnswer">>;
+}
+declare class PracticeSpaces {
+    private readonly ctx;
+    readonly students: PracticeSpacesStudents;
+    readonly sessions: PracticeSpacesSessions;
+    constructor(ctx: ClientContext);
+    /**
+     * List practice spaces
+     *
+     * Get a list of all practice spaces you have access to in this workspace.
+     *
+     * API endpoint: `GET /practice-spaces`
+     */
+    list(args: Args<"practiceSpaces.list">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.list">>;
+    /**
+     * Create practice space
+     *
+     * Create a new practice space within your workspace.
+     *
+     * API endpoint: `POST /practice-spaces`
+     */
+    create(args?: Args<"practiceSpaces.create">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.create">>;
+    /**
+     * Get practice space
+     *
+     * Get a single practice space by its ID.
+     *
+     * API endpoint: `GET /practice-spaces/{id}`
+     */
+    get(id: string, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.get">>;
+    get(args: Args<"practiceSpaces.get">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.get">>;
+    /**
+     * Update practice space
+     *
+     * Update an existing practice space.
+     *
+     * API endpoint: `PATCH /practice-spaces/{id}`
+     */
+    update(args: Args<"practiceSpaces.update">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.update">>;
+    /**
+     * Delete practice space
+     *
+     * Delete the practice space.
+     *
+     * API endpoint: `DELETE /practice-spaces/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.delete">>;
+    delete(args: Args<"practiceSpaces.delete">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.delete">>;
+    /**
+     * Duplicate practice space
+     *
+     * Duplicate the practice space's settings and topics to a new practice space.
+     *
+     * API endpoint: `POST /practice-spaces/{practiceSpaceId}/duplicate`
+     */
+    duplicate(args: Args<"practiceSpaces.duplicate">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.duplicate">>;
+    /**
+     * Generate practice space topics
+     *
+     * Start generating mastery topics for a practice space.
+     *
+     * API endpoint: `POST /practice-spaces/{practiceSpaceId}/generate-topics`
+     */
+    generateTopics(practiceSpaceId: string, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.generateTopics">>;
+    generateTopics(args: Args<"practiceSpaces.generateTopics">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.generateTopics">>;
+    /**
+     * Cancel practice space topic generation
+     *
+     * Cancel an in-progress mastery topic generation job.
+     *
+     * API endpoint: `POST /practice-spaces/{practiceSpaceId}/cancel-generate-topics`
+     */
+    cancelGenerateTopics(practiceSpaceId: string, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.cancelGenerateTopics">>;
+    cancelGenerateTopics(args: Args<"practiceSpaces.cancelGenerateTopics">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.cancelGenerateTopics">>;
+    /**
+     * Preview top practice space questions
+     *
+     * Get a preview of the top practice space questions by quality score.
+     *
+     * API endpoint: `GET /practice-spaces/{practiceSpaceId}/questions-preview`
+     */
+    questionsPreview(practiceSpaceId: string, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.questionsPreview">>;
+    questionsPreview(args: Args<"practiceSpaces.questionsPreview">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.questionsPreview">>;
+    /**
+     * Get practice space progress
+     *
+     * Get the progress of a single practice space by its ID.
+     *
+     * API endpoint: `GET /practice-spaces/{practiceSpaceId}/progress`
+     */
+    getProgress(practiceSpaceId: string, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.getProgress">>;
+    getProgress(args: Args<"practiceSpaces.getProgress">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.getProgress">>;
+    /**
+     * Generate practice space topic feedback
+     *
+     * Get feedback for a specific topic in a practice space.
+     *
+     * API endpoint: `POST /practice-spaces/{practiceSpaceId}/progress/topic-feedback`
+     */
+    generateTopicFeedback(args: Args<"practiceSpaces.generateTopicFeedback">, options?: ExamplaryRequestOptions): Promise<Response<"practiceSpaces.generateTopicFeedback">>;
+}
+declare class SourceMaterials {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List source materials in org
+     *
+     * Returns a list of source materials for the current organization.
+     *
+     * API endpoint: `GET /source-materials`
+     */
+    list(args: Args<"sourceMaterials.list">, options?: ExamplaryRequestOptions): Promise<Response<"sourceMaterials.list">>;
+    /**
+     * Add source material
+     *
+     * Add a source material and start processing it for later use in an exam.
+     *
+     * API endpoint: `POST /source-materials`
+     */
+    create(args?: Args<"sourceMaterials.create">, options?: ExamplaryRequestOptions): Promise<Response<"sourceMaterials.create">>;
+    /**
+     * Get source material
+     *
+     * Returns the current status and facts extracted from the specified source material.
+     *
+     * API endpoint: `GET /source-materials/{id}`
+     */
+    get(id: string, options?: ExamplaryRequestOptions): Promise<Response<"sourceMaterials.get">>;
+    get(args: Args<"sourceMaterials.get">, options?: ExamplaryRequestOptions): Promise<Response<"sourceMaterials.get">>;
+    /**
+     * Update source material
+     *
+     * Updates the specified source material.
+     *
+     * API endpoint: `PATCH /source-materials/{id}`
+     */
+    update(args: Args<"sourceMaterials.update">, options?: ExamplaryRequestOptions): Promise<Response<"sourceMaterials.update">>;
+    /**
+     * Delete source material
+     *
+     * Deletes the specified source material.
+     *
+     * API endpoint: `DELETE /source-materials/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"sourceMaterials.delete">>;
+    delete(args: Args<"sourceMaterials.delete">, options?: ExamplaryRequestOptions): Promise<Response<"sourceMaterials.delete">>;
+    /**
+     * Create a source material slice
+     *
+     * Create a new source material based on a specific page range of an existing source material.
+     *
+     * API endpoint: `POST /source-materials/{sourceMaterialId}/slice`
+     */
+    slice(args: Args<"sourceMaterials.slice">, options?: ExamplaryRequestOptions): Promise<Response<"sourceMaterials.slice">>;
+}
+declare class Folders {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Get folders
+     *
+     * Get a list of folders for exam organisation that exist within the current workspace.
+     *
+     * API endpoint: `GET /folders`
+     */
+    list(args?: Args<"folders.list">, options?: ExamplaryRequestOptions): Promise<Response<"folders.list">>;
+    /**
+     * Create folder
+     *
+     * Create a new folder in the current workspace.
+     *
+     * API endpoint: `POST /folders`
+     */
+    create(args?: Args<"folders.create">, options?: ExamplaryRequestOptions): Promise<Response<"folders.create">>;
+    /**
+     * Update folder
+     *
+     * Update an existing folder in the current workspace.
+     *
+     * API endpoint: `POST /folders/{id}`
+     */
+    update(args: Args<"folders.update">, options?: ExamplaryRequestOptions): Promise<Response<"folders.update">>;
+    /**
+     * Delete folder
+     *
+     * Delete a folder from the current workspace. If there are any exams in the folder, they will be moved out of the folder.
+     *
+     * API endpoint: `DELETE /folders/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"folders.delete">>;
+    delete(args: Args<"folders.delete">, options?: ExamplaryRequestOptions): Promise<Response<"folders.delete">>;
+}
+declare class Groups {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * List groups
+     *
+     * List all groups in the organization. When restricted group visibility is enabled, only returns groups the user belongs to.
+     *
+     * API endpoint: `GET /groups`
+     */
+    list(args?: Args<"groups.list">, options?: ExamplaryRequestOptions): Promise<Response<"groups.list">>;
+    /**
+     * Create group
+     *
+     * Create a new group. Requires admin or owner org role.
+     *
+     * API endpoint: `POST /groups`
+     */
+    create(args?: Args<"groups.create">, options?: ExamplaryRequestOptions): Promise<Response<"groups.create">>;
+    /**
+     * Rename group
+     *
+     * Rename a group. Requires group manager/owner role or org admin/owner.
+     *
+     * API endpoint: `PATCH /groups/{id}`
+     */
+    update(args: Args<"groups.update">, options?: ExamplaryRequestOptions): Promise<Response<"groups.update">>;
+    /**
+     * Delete group
+     *
+     * Delete a group and revoke all associated permissions. Requires group manager/owner role or org admin/owner.
+     *
+     * API endpoint: `DELETE /groups/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"groups.delete">>;
+    delete(args: Args<"groups.delete">, options?: ExamplaryRequestOptions): Promise<Response<"groups.delete">>;
+    /**
+     * List group members
+     *
+     * List all members of a group with resolved user info. Respects restricted group visibility.
+     *
+     * API endpoint: `GET /groups/{groupId}/members`
+     */
+    listMembers(groupId: string, options?: ExamplaryRequestOptions): Promise<Response<"groups.listMembers">>;
+    listMembers(args: Args<"groups.listMembers">, options?: ExamplaryRequestOptions): Promise<Response<"groups.listMembers">>;
+    /**
+     * Add group member
+     *
+     * Add a member to a group. Requires group manager/owner role or org admin/owner.
+     *
+     * API endpoint: `POST /groups/{groupId}/members`
+     */
+    addMember(args: Args<"groups.addMember">, options?: ExamplaryRequestOptions): Promise<Response<"groups.addMember">>;
+    /**
+     * Change member role
+     *
+     * Change a member's role in the group. Requires group manager/owner role or org admin/owner.
+     *
+     * API endpoint: `PATCH /groups/{groupId}/members/{userId}`
+     */
+    updateMember(args: Args<"groups.updateMember">, options?: ExamplaryRequestOptions): Promise<Response<"groups.updateMember">>;
+    /**
+     * Remove group member
+     *
+     * Remove a member from the group. Requires group manager/owner role or org admin/owner. Cannot remove the owner.
+     *
+     * API endpoint: `DELETE /groups/{groupId}/members/{userId}`
+     */
+    removeMember(args: Args<"groups.removeMember">, options?: ExamplaryRequestOptions): Promise<Response<"groups.removeMember">>;
+}
+declare class QuestionBank {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Get question bank items
+     *
+     * Get a list of question bank items that exist within the current workspace.
+     *
+     * API endpoint: `GET /question-bank`
+     */
+    list(args?: Args<"questionBank.list">, options?: ExamplaryRequestOptions): Promise<Response<"questionBank.list">>;
+    /**
+     * Add question to question bank
+     *
+     * Add a question to the question bank in the current workspace.
+     *
+     * API endpoint: `POST /question-bank`
+     */
+    create(args?: Args<"questionBank.create">, options?: ExamplaryRequestOptions): Promise<Response<"questionBank.create">>;
+    /**
+     * Update question bank item
+     *
+     * Update an existing question bank item in the current workspace.
+     *
+     * API endpoint: `PATCH /question-bank/{id}`
+     */
+    update(args: Args<"questionBank.update">, options?: ExamplaryRequestOptions): Promise<Response<"questionBank.update">>;
+    /**
+     * Delete question bank item
+     *
+     * Delete a question bank item from the current workspace.
+     *
+     * API endpoint: `DELETE /question-bank/{id}`
+     */
+    delete(id: string, options?: ExamplaryRequestOptions): Promise<Response<"questionBank.delete">>;
+    delete(args: Args<"questionBank.delete">, options?: ExamplaryRequestOptions): Promise<Response<"questionBank.delete">>;
+}
+declare class Jobs {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    /**
+     * Get job status
+     *
+     * Poll the status of a background job.
+     *
+     * API endpoint: `GET /jobs/{id}`
+     */
+    get(id: string, options?: ExamplaryRequestOptions): Promise<Response<"jobs.get">>;
+    get(args: Args<"jobs.get">, options?: ExamplaryRequestOptions): Promise<Response<"jobs.get">>;
+    /**
+     * Cancel a job
+     *
+     * Cancel a background job.
+     *
+     * API endpoint: `DELETE /jobs/{id}`
+     */
+    cancel(id: string, options?: ExamplaryRequestOptions): Promise<Response<"jobs.cancel">>;
+    cancel(args: Args<"jobs.cancel">, options?: ExamplaryRequestOptions): Promise<Response<"jobs.cancel">>;
+}
+declare class Examplary {
+    private readonly ctx;
+    readonly questionTypes: QuestionTypes;
+    readonly library: Library;
+    readonly oauth: Oauth;
+    readonly embedSessions: EmbedSessions;
+    readonly me: Me;
+    readonly media: Media;
+    readonly org: Org;
+    readonly orgs: Orgs;
+    readonly apiKeys: ApiKeys;
+    readonly attributes: Attributes;
+    readonly taxonomies: Taxonomies;
+    readonly permissions: Permissions;
+    readonly studentLevels: StudentLevels;
+    readonly users: Users;
+    readonly exams: Exams;
+    readonly practiceSpaces: PracticeSpaces;
+    readonly sourceMaterials: SourceMaterials;
+    readonly folders: Folders;
+    readonly groups: Groups;
+    readonly questionBank: QuestionBank;
+    readonly jobs: Jobs;
+    constructor(options: ExamplaryClientOptions);
+    /**
+     * Get rubrics
+     *
+     * Get a list of rubrics that exist within the current workspace.
+     *
+     * API endpoint: `GET /rubrics`
+     */
+    getRubrics(args?: Args<"getRubrics">, options?: ExamplaryRequestOptions): Promise<Response<"getRubrics">>;
+    /**
+     * Save rubric
+     *
+     * Add a rubric to the current workspace.
+     *
+     * API endpoint: `POST /rubrics`
+     */
+    postRubrics(args?: Args<"postRubrics">, options?: ExamplaryRequestOptions): Promise<Response<"postRubrics">>;
+    /**
+     * Generate rubric
+     *
+     * Start a background job to generate a rubric using AI.
+     *
+     * API endpoint: `POST /rubrics/generate`
+     */
+    postRubricsGenerate(args?: Args<"postRubricsGenerate">, options?: ExamplaryRequestOptions): Promise<Response<"postRubricsGenerate">>;
+    /**
+     * Update rubric
+     *
+     * Update an existing rubric in the current workspace.
+     *
+     * API endpoint: `PATCH /rubrics/{id}`
+     */
+    patchRubricsId(args: Args<"patchRubrics:id">, options?: ExamplaryRequestOptions): Promise<Response<"patchRubrics:id">>;
+    /**
+     * Delete rubric
+     *
+     * Delete a rubric from the current workspace.
+     *
+     * API endpoint: `DELETE /rubrics/{id}`
+     */
+    deleteRubricsId(id: string, options?: ExamplaryRequestOptions): Promise<Response<"deleteRubrics:id">>;
+    deleteRubricsId(args: Args<"deleteRubrics:id">, options?: ExamplaryRequestOptions): Promise<Response<"deleteRubrics:id">>;
+}
+
+declare class ExamplaryError<T = unknown, D = any> extends AxiosError<T, D> {
+    originalMessage?: string;
+    constructor(message?: string, code?: string, config?: InternalAxiosRequestConfig<D>, request?: any, response?: AxiosResponse<T, D>);
+    static fromAxiosError(error: AxiosError): ExamplaryError;
+}
+
+export { type Args, Examplary, type ExamplaryClientOptions, ExamplaryError, type ExamplaryRequestOptions, type Response, type components, type operations, type paths };