@studyfetch/sdk 1.1.1 → 1.3.0

package/src/resources/v1/embed/embed.ts

@@ -6,34 +6,49 @@ import { Component, ComponentInteractParams, ComponentRetrieveParams } from './c
 import { APIPromise } from '../../../core/api-promise';
 import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
-import { path } from '../../../internal/utils/path';
 
 export class Embed extends APIResource {
   component: ComponentAPI.Component = new ComponentAPI.Component(this._client);
 
-  retrieve(componentID: string, query: EmbedRetrieveParams, options?: RequestOptions): APIPromise<void> {
-    return this._client.get(path`/api/v1/embed/${componentID}`, {
+  /**
+   * Get theme CSS for embed
+   *
+   * @example
+   * ```ts
+   * await client.v1.embed.getTheme({ token: 'token' });
+   * ```
+   */
+  getTheme(query: EmbedGetThemeParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/api/v1/embed/theme', {
       query,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
-  getHealth(options?: RequestOptions): APIPromise<void> {
+  /**
+   * Health check endpoint
+   *
+   * @example
+   * ```ts
+   * await client.v1.embed.healthCheck();
+   * ```
+   */
+  healthCheck(options?: RequestOptions): APIPromise<void> {
     return this._client.get('/api/v1/embed/health', {
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
-  getTheme(query: EmbedGetThemeParams, options?: RequestOptions): APIPromise<void> {
-    return this._client.get('/api/v1/embed/theme', {
-      query,
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
-  }
-
+  /**
+   * Verify embed token
+   *
+   * @example
+   * ```ts
+   * await client.v1.embed.verify({ token: 'token' });
+   * ```
+   */
   verify(query: EmbedVerifyParams, options?: RequestOptions): APIPromise<void> {
     return this._client.get('/api/v1/embed/verify', {
       query,
@@ -43,26 +58,24 @@ export class Embed extends APIResource {
   }
 }
 
-export interface EmbedRetrieveParams {
-  token: string;
-}
-
 export interface EmbedGetThemeParams {
+  /**
+   * Embed token
+   */
   token: string;
 }
 
 export interface EmbedVerifyParams {
+  /**
+   * Embed token to verify
+   */
   token: string;
 }
 
 Embed.Component = Component;
 
 export declare namespace Embed {
-  export {
-    type EmbedRetrieveParams as EmbedRetrieveParams,
-    type EmbedGetThemeParams as EmbedGetThemeParams,
-    type EmbedVerifyParams as EmbedVerifyParams,
-  };
+  export { type EmbedGetThemeParams as EmbedGetThemeParams, type EmbedVerifyParams as EmbedVerifyParams };
 
   export {
     Component as Component,

package/src/resources/v1/embed/index.ts

@@ -1,4 +1,4 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 export { Component, type ComponentRetrieveParams, type ComponentInteractParams } from './component';
-export { Embed, type EmbedRetrieveParams, type EmbedGetThemeParams, type EmbedVerifyParams } from './embed';
+export { Embed, type EmbedGetThemeParams, type EmbedVerifyParams } from './embed';

package/src/resources/v1/explainers.ts

@@ -6,6 +6,14 @@ import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
 
 export class Explainers extends APIResource {
+  /**
+   * Create explainers component
+   *
+   * @example
+   * ```ts
+   * await client.v1.explainers.create();
+   * ```
+   */
   create(body: ExplainerCreateParams, options?: RequestOptions): APIPromise<void> {
     return this._client.post('/api/v1/explainers/create', {
       body,
@@ -14,8 +22,18 @@ export class Explainers extends APIResource {
     });
   }
 
-  webhook(options?: RequestOptions): APIPromise<void> {
+  /**
+   * Handle webhook events
+   *
+   * @example
+   * ```ts
+   * await client.v1.explainers.handleWebhook({ body: 'body' });
+   * ```
+   */
+  handleWebhook(params: ExplainerHandleWebhookParams, options?: RequestOptions): APIPromise<void> {
+    const { body } = params;
     return this._client.post('/api/v1/explainers/webhook', {
+      body: body,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
@@ -24,6 +42,13 @@ export class Explainers extends APIResource {
 
 export interface ExplainerCreateParams {}
 
+export interface ExplainerHandleWebhookParams {
+  body: string;
+}
+
 export declare namespace Explainers {
-  export { type ExplainerCreateParams as ExplainerCreateParams };
+  export {
+    type ExplainerCreateParams as ExplainerCreateParams,
+    type ExplainerHandleWebhookParams as ExplainerHandleWebhookParams,
+  };
 }

package/src/resources/v1/flashcards.ts

@@ -7,20 +7,68 @@ import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
 export class Flashcards extends APIResource {
-  createBatch(componentID: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/api/v1/flashcards/${componentID}/batch`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  /**
+   * Process multiple flashcard operations
+   *
+   * @example
+   * ```ts
+   * const response = await client.v1.flashcards.batchProcess(
+   *   'componentId',
+   *   { operations: [{ action: 'rate', cardId: 'cardId' }] },
+   * );
+   * ```
+   */
+  batchProcess(
+    componentID: string,
+    body: FlashcardBatchProcessParams,
+    options?: RequestOptions,
+  ): APIPromise<FlashcardBatchProcessResponse> {
+    return this._client.post(path`/api/v1/flashcards/${componentID}/batch`, { body, ...options });
+  }
+
+  /**
+   * Get spaced repetition algorithm info
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.v1.flashcards.getAlgorithmInfo();
+   * ```
+   */
+  getAlgorithmInfo(options?: RequestOptions): APIPromise<FlashcardGetAlgorithmInfoResponse> {
+    return this._client.get('/api/v1/flashcards/algorithm', options);
   }
 
-  getAlgorithm(options?: RequestOptions): APIPromise<void> {
-    return this._client.get('/api/v1/flashcards/algorithm', {
+  /**
+   * Get all flashcards for component
+   *
+   * @example
+   * ```ts
+   * await client.v1.flashcards.getAll('componentId');
+   * ```
+   */
+  getAll(
+    componentID: string,
+    query: FlashcardGetAllParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
+    return this._client.get(path`/api/v1/flashcards/${componentID}/all`, {
+      query,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
+  /**
+   * Get due flashcards for review
+   *
+   * @example
+   * ```ts
+   * await client.v1.flashcards.getDue('componentId', {
+   *   groupId: 'groupId',
+   * });
+   * ```
+   */
   getDue(componentID: string, query: FlashcardGetDueParams, options?: RequestOptions): APIPromise<void> {
     return this._client.get(path`/api/v1/flashcards/${componentID}/due`, {
       query,
@@ -29,7 +77,19 @@ export class Flashcards extends APIResource {
     });
   }
 
-  getStats(componentID: string, query: FlashcardGetStatsParams, options?: RequestOptions): APIPromise<void> {
+  /**
+   * Get flashcard statistics
+   *
+   * @example
+   * ```ts
+   * await client.v1.flashcards.getStats('componentId');
+   * ```
+   */
+  getStats(
+    componentID: string,
+    query: FlashcardGetStatsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
     return this._client.get(path`/api/v1/flashcards/${componentID}/stats`, {
       query,
       ...options,
@@ -37,57 +97,258 @@ export class Flashcards extends APIResource {
     });
   }
 
-  listAll(componentID: string, query: FlashcardListAllParams, options?: RequestOptions): APIPromise<void> {
-    return this._client.get(path`/api/v1/flashcards/${componentID}/all`, {
-      query,
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  /**
+   * Get available flashcard types
+   *
+   * @example
+   * ```ts
+   * const response = await client.v1.flashcards.getTypes();
+   * ```
+   */
+  getTypes(options?: RequestOptions): APIPromise<FlashcardGetTypesResponse> {
+    return this._client.get('/api/v1/flashcards/types', options);
   }
 
-  listTypes(options?: RequestOptions): APIPromise<void> {
-    return this._client.get('/api/v1/flashcards/types', {
+  /**
+   * Rate a flashcard
+   *
+   * @example
+   * ```ts
+   * await client.v1.flashcards.rate('componentId', {
+   *   cardId: 'cardId',
+   *   rating: 0,
+   * });
+   * ```
+   */
+  rate(componentID: string, body: FlashcardRateParams, options?: RequestOptions): APIPromise<void> {
+    return this._client.post(path`/api/v1/flashcards/${componentID}/rate`, {
+      body,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
+}
 
-  rate(componentID: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/api/v1/flashcards/${componentID}/rate`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+export interface FlashcardBatchProcessResponse {
+  /**
+   * Failed operations
+   */
+  failed?: number;
+
+  /**
+   * Total operations processed
+   */
+  processed?: number;
+
+  results?: Array<FlashcardBatchProcessResponse.Result>;
+
+  /**
+   * Overall success
+   */
+  success?: boolean;
+
+  /**
+   * Successful operations
+   */
+  successful?: number;
+}
+
+export namespace FlashcardBatchProcessResponse {
+  export interface Result {
+    /**
+     * Flashcard ID
+     */
+    cardId: string;
+
+    /**
+     * Operation success
+     */
+    success: boolean;
+
+    /**
+     * Error message if failed
+     */
+    error?: string;
+
+    /**
+     * Operation result
+     */
+    result?: unknown;
   }
 }
 
+export interface FlashcardGetAlgorithmInfoResponse {
+  /**
+   * Algorithm name
+   */
+  algorithm?: string;
+
+  intervals?: FlashcardGetAlgorithmInfoResponse.Intervals;
+
+  phases?: { [key: string]: string };
+
+  ratings?: { [key: string]: FlashcardGetAlgorithmInfoResponse.Ratings };
+}
+
+export namespace FlashcardGetAlgorithmInfoResponse {
+  export interface Intervals {
+    /**
+     * Description of graduated intervals
+     */
+    graduated?: string;
+
+    /**
+     * Description of lapse intervals
+     */
+    lapse?: string;
+
+    /**
+     * Learning intervals in minutes
+     */
+    learning?: Array<number>;
+  }
+
+  export interface Ratings {
+    /**
+     * Rating description
+     */
+    description: string;
+
+    /**
+     * Rating name
+     */
+    name: string;
+  }
+}
+
+export interface FlashcardGetTypesResponse {
+  descriptions?: { [key: string]: string };
+
+  /**
+   * List of flashcard types
+   */
+  types?: Array<string>;
+}
+
+export interface FlashcardBatchProcessParams {
+  operations: Array<FlashcardBatchProcessParams.Operation>;
+
+  /**
+   * Group ID (optional)
+   */
+  groupId?: string;
+
+  /**
+   * User ID (optional)
+   */
+  userId?: string;
+}
+
+export namespace FlashcardBatchProcessParams {
+  export interface Operation {
+    action: 'rate' | 'get_due' | 'get_all' | 'get_stats';
+
+    /**
+     * Flashcard ID
+     */
+    cardId: string;
+
+    /**
+     * Group ID (optional)
+     */
+    groupId?: string;
+
+    /**
+     * Rating for rate action (0-3)
+     */
+    rating?: number;
+
+    /**
+     * User ID (optional)
+     */
+    userId?: string;
+  }
+}
+
+export interface FlashcardGetAllParams {
+  /**
+   * Group ID
+   */
+  groupId?: string;
+
+  /**
+   * Max number of cards
+   */
+  limit?: number;
+
+  /**
+   * Offset
+   */
+  offset?: number;
+
+  /**
+   * User ID
+   */
+  userId?: string;
+}
+
 export interface FlashcardGetDueParams {
   groupId: string;
 
-  limit: number;
+  /**
+   * Max number of cards
+   */
+  limit?: number;
 
-  userId: string;
+  /**
+   * User ID
+   */
+  userId?: string;
 }
 
 export interface FlashcardGetStatsParams {
-  groupId: string;
+  /**
+   * Group ID
+   */
+  groupId?: string;
 
-  userId: string;
+  /**
+   * User ID
+   */
+  userId?: string;
 }
 
-export interface FlashcardListAllParams {
-  groupId: string;
+export interface FlashcardRateParams {
+  /**
+   * Flashcard ID
+   */
+  cardId: string;
 
-  limit: number;
+  /**
+   * Rating (0-3)
+   */
+  rating: number;
 
-  offset: number;
+  /**
+   * Group ID (optional)
+   */
+  groupId?: string;
 
-  userId: string;
+  /**
+   * User ID (optional)
+   */
+  userId?: string;
 }
 
 export declare namespace Flashcards {
   export {
+    type FlashcardBatchProcessResponse as FlashcardBatchProcessResponse,
+    type FlashcardGetAlgorithmInfoResponse as FlashcardGetAlgorithmInfoResponse,
+    type FlashcardGetTypesResponse as FlashcardGetTypesResponse,
+    type FlashcardBatchProcessParams as FlashcardBatchProcessParams,
+    type FlashcardGetAllParams as FlashcardGetAllParams,
     type FlashcardGetDueParams as FlashcardGetDueParams,
     type FlashcardGetStatsParams as FlashcardGetStatsParams,
-    type FlashcardListAllParams as FlashcardListAllParams,
+    type FlashcardRateParams as FlashcardRateParams,
   };
 }

package/src/resources/v1/folders.ts

@@ -7,13 +7,30 @@ import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
 export class Folders extends APIResource {
-  create(options?: RequestOptions): APIPromise<void> {
+  /**
+   * Create a new folder
+   *
+   * @example
+   * ```ts
+   * await client.v1.folders.create({ name: 'name' });
+   * ```
+   */
+  create(body: FolderCreateParams, options?: RequestOptions): APIPromise<void> {
     return this._client.post('/api/v1/folders', {
+      body,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
+  /**
+   * Get folder by ID
+   *
+   * @example
+   * ```ts
+   * await client.v1.folders.retrieve('id');
+   * ```
+   */
   retrieve(id: string, options?: RequestOptions): APIPromise<void> {
     return this._client.get(path`/api/v1/folders/${id}`, {
       ...options,
@@ -21,20 +38,46 @@ export class Folders extends APIResource {
     });
   }
 
-  update(id: string, options?: RequestOptions): APIPromise<void> {
+  /**
+   * Update folder
+   *
+   * @example
+   * ```ts
+   * await client.v1.folders.update('id');
+   * ```
+   */
+  update(id: string, body: FolderUpdateParams, options?: RequestOptions): APIPromise<void> {
     return this._client.patch(path`/api/v1/folders/${id}`, {
+      body,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
-  list(options?: RequestOptions): APIPromise<void> {
+  /**
+   * Get all folders
+   *
+   * @example
+   * ```ts
+   * await client.v1.folders.list();
+   * ```
+   */
+  list(query: FolderListParams | null | undefined = {}, options?: RequestOptions): APIPromise<void> {
     return this._client.get('/api/v1/folders', {
+      query,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
+  /**
+   * Delete folder
+   *
+   * @example
+   * ```ts
+   * await client.v1.folders.delete('id');
+   * ```
+   */
   delete(id: string, options?: RequestOptions): APIPromise<void> {
     return this._client.delete(path`/api/v1/folders/${id}`, {
       ...options,
@@ -42,24 +85,83 @@ export class Folders extends APIResource {
     });
   }
 
-  listMaterials(id: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.get(path`/api/v1/folders/${id}/materials`, {
+  /**
+   * Get folder tree structure
+   *
+   * @example
+   * ```ts
+   * await client.v1.folders.getTree();
+   * ```
+   */
+  getTree(options?: RequestOptions): APIPromise<void> {
+    return this._client.get('/api/v1/folders/tree', {
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
-  move(id: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.patch(path`/api/v1/folders/${id}/move`, {
+  /**
+   * @example
+   * ```ts
+   * await client.v1.folders.listMaterials('id');
+   * ```
+   */
+  listMaterials(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.get(path`/api/v1/folders/${id}/materials`, {
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
-  retrieveTree(options?: RequestOptions): APIPromise<void> {
-    return this._client.get('/api/v1/folders/tree', {
+  /**
+   * @example
+   * ```ts
+   * await client.v1.folders.move('id');
+   * ```
+   */
+  move(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.patch(path`/api/v1/folders/${id}/move`, {
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 }
+
+export interface FolderCreateParams {
+  /**
+   * Folder name
+   */
+  name: string;
+
+  /**
+   * Parent folder ID (optional)
+   */
+  parentId?: string;
+}
+
+export interface FolderUpdateParams {
+  /**
+   * New folder name
+   */
+  name?: string;
+
+  /**
+   * New parent folder ID
+   */
+  parentId?: string;
+}
+
+export interface FolderListParams {
+  /**
+   * Filter by parent folder
+   */
+  parentId?: unknown;
+}
+
+export declare namespace Folders {
+  export {
+    type FolderCreateParams as FolderCreateParams,
+    type FolderUpdateParams as FolderUpdateParams,
+    type FolderListParams as FolderListParams,
+  };
+}