@studyfetch/sdk 1.24.0 → 1.26.0

package/src/resources/v1/materials/test.ts

@@ -2,59 +2,175 @@
 
 import { APIResource } from '../../../core/resource';
 import { APIPromise } from '../../../core/api-promise';
-import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 
 export class Test extends APIResource {
   /**
+   * Test OCR functionality with a sample PDF
+   *
    * @example
    * ```ts
-   * await client.v1.materials.test.performOcr();
+   * const response =
+   *   await client.v1.materials.test.performOcr();
    * ```
    */
-  performOcr(options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/materials/test/ocr', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  performOcr(options?: RequestOptions): APIPromise<TestPerformOcrResponse> {
+    return this._client.post('/api/v1/materials/test/ocr', options);
   }
 
   /**
+   * Test EPUB processing functionality
+   *
    * @example
    * ```ts
-   * await client.v1.materials.test.processEpub();
+   * const response =
+   *   await client.v1.materials.test.processEpub();
    * ```
    */
-  processEpub(options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/materials/test/epub-processing', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  processEpub(options?: RequestOptions): APIPromise<TestProcessEpubResponse> {
+    return this._client.post('/api/v1/materials/test/epub-processing', options);
   }
 
   /**
+   * Test image processing with OCR and AI vision
+   *
    * @example
    * ```ts
-   * await client.v1.materials.test.processImage();
+   * const response =
+   *   await client.v1.materials.test.processImage();
    * ```
    */
-  processImage(options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/materials/test/image-processing', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  processImage(options?: RequestOptions): APIPromise<TestProcessImageResponse> {
+    return this._client.post('/api/v1/materials/test/image-processing', options);
   }
 
   /**
+   * Test video processing setup and dependencies
+   *
    * @example
    * ```ts
-   * await client.v1.materials.test.processVideo();
+   * const response =
+   *   await client.v1.materials.test.processVideo();
    * ```
    */
-  processVideo(options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/materials/test/video-processing', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  processVideo(options?: RequestOptions): APIPromise<TestProcessVideoResponse> {
+    return this._client.post('/api/v1/materials/test/video-processing', options);
   }
 }
+
+export interface TestPerformOcrResponse {
+  /**
+   * First 500 characters of extracted text
+   */
+  firstChars: string;
+
+  /**
+   * Test success status
+   */
+  success: boolean;
+
+  /**
+   * Length of extracted text
+   */
+  textLength: number;
+}
+
+export interface TestProcessEpubResponse {
+  /**
+   * Test success status
+   */
+  success: boolean;
+
+  /**
+   * EPUB file size in bytes
+   */
+  epubSize?: number;
+
+  /**
+   * EPUB file size in MB
+   */
+  epubSizeMB?: string;
+
+  /**
+   * Error message if failed
+   */
+  error?: string;
+
+  /**
+   * Success message
+   */
+  message?: string;
+
+  /**
+   * Error stack trace
+   */
+  stack?: string;
+}
+
+export interface TestProcessImageResponse {
+  /**
+   * Test success status
+   */
+  success: boolean;
+
+  /**
+   * Error message if failed
+   */
+  error?: string;
+
+  /**
+   * Image info if no base64 data
+   */
+  imageInfo?: unknown;
+
+  /**
+   * Success message
+   */
+  message?: string;
+
+  /**
+   * Test results
+   */
+  results?: unknown;
+
+  /**
+   * Error stack trace
+   */
+  stack?: string;
+}
+
+export interface TestProcessVideoResponse {
+  /**
+   * Test success status
+   */
+  success: boolean;
+
+  /**
+   * Error message if failed
+   */
+  error?: string;
+
+  /**
+   * Success message
+   */
+  message?: string;
+
+  /**
+   * Error stack trace
+   */
+  stack?: string;
+
+  /**
+   * Test results
+   */
+  tests?: unknown;
+}
+
+export declare namespace Test {
+  export {
+    type TestPerformOcrResponse as TestPerformOcrResponse,
+    type TestProcessEpubResponse as TestProcessEpubResponse,
+    type TestProcessImageResponse as TestProcessImageResponse,
+    type TestProcessVideoResponse as TestProcessVideoResponse,
+  };
+}

package/src/resources/v1/materials/upload.ts

@@ -4,35 +4,49 @@ import { APIResource } from '../../../core/resource';
 import * as MaterialsAPI from './materials';
 import { APIPromise } from '../../../core/api-promise';
 import { type Uploadable } from '../../../core/uploads';
-import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 import { multipartFormRequestOptions } from '../../../internal/uploads';
 
 export class Upload extends APIResource {
   /**
+   * Complete upload after using presigned URL
+   *
    * @example
    * ```ts
-   * await client.v1.materials.upload.completeUpload();
+   * const material =
+   *   await client.v1.materials.upload.completeUpload({
+   *     materialId: '507f1f77bcf86cd799439013',
+   *     organizationId: '507f1f77bcf86cd799439011',
+   *     s3Key:
+   *       'organizations/507f1f77bcf86cd799439011/materials/document.pdf',
+   *   });
    * ```
    */
-  completeUpload(options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/materials/upload/complete', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  completeUpload(
+    body: UploadCompleteUploadParams,
+    options?: RequestOptions,
+  ): APIPromise<MaterialsAPI.Material> {
+    return this._client.post('/api/v1/materials/upload/complete', { body, ...options });
   }
 
   /**
+   * Get presigned URL for direct S3 upload
+   *
    * @example
    * ```ts
-   * await client.v1.materials.upload.createPresignedURL();
+   * const response =
+   *   await client.v1.materials.upload.createPresignedURL({
+   *     contentType: 'application/pdf',
+   *     filename: 'document.pdf',
+   *     name: 'Chapter 1 Notes',
+   *   });
    * ```
    */
-  createPresignedURL(options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/materials/upload/presigned-url', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  createPresignedURL(
+    body: UploadCreatePresignedURLParams,
+    options?: RequestOptions,
+  ): APIPromise<UploadCreatePresignedURLResponse> {
+    return this._client.post('/api/v1/materials/upload/presigned-url', { body, ...options });
   }
 
   /**
@@ -54,6 +68,29 @@ export class Upload extends APIResource {
     );
   }
 
+  /**
+   * Uploads a file and waits for processing to finish before returning. Useful for
+   * synchronous API usage.
+   *
+   * @example
+   * ```ts
+   * const material =
+   *   await client.v1.materials.upload.uploadFileAndProcess({
+   *     file: fs.createReadStream('path/to/file'),
+   *     name: 'name',
+   *   });
+   * ```
+   */
+  uploadFileAndProcess(
+    body: UploadUploadFileAndProcessParams,
+    options?: RequestOptions,
+  ): APIPromise<MaterialsAPI.Material> {
+    return this._client.post(
+      '/api/v1/materials/upload/file-and-process',
+      multipartFormRequestOptions({ body, ...options }, this._client),
+    );
+  }
+
   /**
    * Upload material from URL
    *
@@ -72,6 +109,99 @@ export class Upload extends APIResource {
   ): APIPromise<MaterialsAPI.Material> {
     return this._client.post('/api/v1/materials/upload/url', { body, ...options });
   }
+
+  /**
+   * Fetches content from URL and waits for processing to finish before returning.
+   * Useful for synchronous API usage.
+   *
+   * @example
+   * ```ts
+   * const material =
+   *   await client.v1.materials.upload.uploadURLAndProcess({
+   *     name: 'My Document',
+   *     url: 'https://example.com/document.pdf',
+   *   });
+   * ```
+   */
+  uploadURLAndProcess(
+    body: UploadUploadURLAndProcessParams,
+    options?: RequestOptions,
+  ): APIPromise<MaterialsAPI.Material> {
+    return this._client.post('/api/v1/materials/upload/url-and-process', { body, ...options });
+  }
+}
+
+export interface Complete {
+  /**
+   * The ID of the material that was uploaded
+   */
+  materialId: string;
+
+  /**
+   * The ID of the organization
+   */
+  organizationId: string;
+
+  /**
+   * The S3 key of the uploaded file
+   */
+  s3Key: string;
+}
+
+export interface UploadCreatePresignedURLResponse {
+  /**
+   * Material ID to use for completion
+   */
+  materialId: string;
+
+  /**
+   * S3 key for the file
+   */
+  s3Key: string;
+
+  /**
+   * Presigned URL for direct S3 upload
+   */
+  uploadUrl: string;
+}
+
+export interface UploadCompleteUploadParams {
+  /**
+   * The ID of the material that was uploaded
+   */
+  materialId: string;
+
+  /**
+   * The ID of the organization
+   */
+  organizationId: string;
+
+  /**
+   * The S3 key of the uploaded file
+   */
+  s3Key: string;
+}
+
+export interface UploadCreatePresignedURLParams {
+  /**
+   * MIME type of the file
+   */
+  contentType: string;
+
+  /**
+   * Filename to upload
+   */
+  filename: string;
+
+  /**
+   * Display name for the material
+   */
+  name: string;
+
+  /**
+   * Folder ID to place the material in
+   */
+  folderId?: string;
 }
 
 export interface UploadUploadFileParams {
@@ -88,6 +218,30 @@ export interface UploadUploadFileParams {
   folderId?: string;
 }
 
+export interface UploadUploadFileAndProcessParams {
+  file: Uploadable;
+
+  /**
+   * Material name
+   */
+  name: string;
+
+  /**
+   * Folder ID (optional)
+   */
+  folderId?: string;
+
+  /**
+   * Polling interval in milliseconds (default: 2000)
+   */
+  pollIntervalMs?: number;
+
+  /**
+   * Processing timeout in milliseconds (default: 300000)
+   */
+  timeoutMs?: number;
+}
+
 export interface UploadUploadFromURLParams {
   /**
    * Material name
@@ -105,9 +259,42 @@ export interface UploadUploadFromURLParams {
   folderId?: string;
 }
 
+export interface UploadUploadURLAndProcessParams {
+  /**
+   * Material name
+   */
+  name: string;
+
+  /**
+   * URL to fetch content from
+   */
+  url: string;
+
+  /**
+   * Folder ID (optional)
+   */
+  folderId?: string;
+
+  /**
+   * Polling interval in milliseconds (default: 2 seconds)
+   */
+  pollIntervalMs?: number;
+
+  /**
+   * Maximum time to wait for processing in milliseconds (default: 5 minutes)
+   */
+  timeoutMs?: number;
+}
+
 export declare namespace Upload {
   export {
+    type Complete as Complete,
+    type UploadCreatePresignedURLResponse as UploadCreatePresignedURLResponse,
+    type UploadCompleteUploadParams as UploadCompleteUploadParams,
+    type UploadCreatePresignedURLParams as UploadCreatePresignedURLParams,
     type UploadUploadFileParams as UploadUploadFileParams,
+    type UploadUploadFileAndProcessParams as UploadUploadFileAndProcessParams,
     type UploadUploadFromURLParams as UploadUploadFromURLParams,
+    type UploadUploadURLAndProcessParams as UploadUploadURLAndProcessParams,
   };
 }

package/src/resources/v1/usage/analyst.ts

@@ -7,33 +7,38 @@ import { RequestOptions } from '../../../internal/request-options';
 
 export class Analyst extends APIResource {
   /**
-   * Get test results for users and groups in JWT
+   * Get test results with full question data for user or group
    *
    * @example
    * ```ts
    * await client.v1.usage.analyst.getTestQuestions();
    * ```
    */
-  getTestQuestions(options?: RequestOptions): APIPromise<void> {
+  getTestQuestions(
+    query: AnalystGetTestQuestionsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<void> {
     return this._client.get('/api/v1/usage-analyst/test-questions', {
+      query,
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 
   /**
-   * Get chat messages for users and groups in JWT
+   * Get all chat messages from sessions for user or group
    *
    * @example
    * ```ts
-   * await client.v1.usage.analyst.listChatMessages();
+   * const response =
+   *   await client.v1.usage.analyst.listChatMessages();
    * ```
    */
-  listChatMessages(options?: RequestOptions): APIPromise<void> {
-    return this._client.get('/api/v1/usage-analyst/chat-messages', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  listChatMessages(
+    query: AnalystListChatMessagesParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<AnalystListChatMessagesResponse> {
+    return this._client.get('/api/v1/usage-analyst/chat-messages', { query, ...options });
   }
 
   /**
@@ -57,6 +62,56 @@ export class Analyst extends APIResource {
   }
 }
 
+export interface AnalystListChatMessagesResponse {
+  messages?: Array<AnalystListChatMessagesResponse.Message>;
+
+  sessionCount?: number;
+
+  total?: number;
+}
+
+export namespace AnalystListChatMessagesResponse {
+  export interface Message {
+    componentId?: string;
+
+    content?: string;
+
+    createdAt?: string;
+
+    metadata?: unknown;
+
+    role?: 'user' | 'assistant' | 'system';
+
+    sessionId?: string;
+
+    userId?: string;
+  }
+}
+
+export interface AnalystGetTestQuestionsParams {
+  /**
+   * Array of group IDs to filter
+   */
+  groupIds?: Array<string>;
+
+  /**
+   * User ID to get test results for
+   */
+  userId?: string;
+}
+
+export interface AnalystListChatMessagesParams {
+  /**
+   * Array of group IDs to filter
+   */
+  groupIds?: Array<string>;
+
+  /**
+   * User ID to get chat messages for
+   */
+  userId?: string;
+}
+
 export interface AnalystListEventsParams {
   /**
    * End date for filtering (ISO 8601)
@@ -95,8 +150,23 @@ export interface AnalystListEventsParams {
    * Start date for filtering (ISO 8601)
    */
   startDate: string;
+
+  /**
+   * Array of group IDs to filter
+   */
+  groupIds?: Array<string>;
+
+  /**
+   * Array of user IDs to filter
+   */
+  userIds?: Array<string>;
 }
 
 export declare namespace Analyst {
-  export { type AnalystListEventsParams as AnalystListEventsParams };
+  export {
+    type AnalystListChatMessagesResponse as AnalystListChatMessagesResponse,
+    type AnalystGetTestQuestionsParams as AnalystGetTestQuestionsParams,
+    type AnalystListChatMessagesParams as AnalystListChatMessagesParams,
+    type AnalystListEventsParams as AnalystListEventsParams,
+  };
 }

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

@@ -1,6 +1,12 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { Analyst, type AnalystListEventsParams } from './analyst';
+export {
+  Analyst,
+  type AnalystListChatMessagesResponse,
+  type AnalystGetTestQuestionsParams,
+  type AnalystListChatMessagesParams,
+  type AnalystListEventsParams,
+} from './analyst';
 export {
   Usage,
   type UsageGetStatsParams,

package/src/resources/v1/usage/usage.ts

@@ -2,7 +2,13 @@
 
 import { APIResource } from '../../../core/resource';
 import * as AnalystAPI from './analyst';
-import { Analyst, AnalystListEventsParams } from './analyst';
+import {
+  Analyst,
+  AnalystGetTestQuestionsParams,
+  AnalystListChatMessagesParams,
+  AnalystListChatMessagesResponse,
+  AnalystListEventsParams,
+} from './analyst';
 import { APIPromise } from '../../../core/api-promise';
 import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
@@ -184,5 +190,11 @@ export declare namespace Usage {
     type UsageListEventsParams as UsageListEventsParams,
   };
 
-  export { Analyst as Analyst, type AnalystListEventsParams as AnalystListEventsParams };
+  export {
+    Analyst as Analyst,
+    type AnalystListChatMessagesResponse as AnalystListChatMessagesResponse,
+    type AnalystGetTestQuestionsParams as AnalystGetTestQuestionsParams,
+    type AnalystListChatMessagesParams as AnalystListChatMessagesParams,
+    type AnalystListEventsParams as AnalystListEventsParams,
+  };
 }