@studyfetch/sdk 1.23.0 → 1.25.0

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

@@ -2,11 +2,24 @@
 
 import { APIResource } from '../../../core/resource';
 import * as BulkAPI from './bulk';
-import { Bulk } from './bulk';
+import { Bulk, BulkMoveParams, BulkMoveResponse } from './bulk';
 import * as TestAPI from './test';
-import { Test } from './test';
+import {
+  Test,
+  TestPerformOcrResponse,
+  TestProcessEpubResponse,
+  TestProcessImageResponse,
+  TestProcessVideoResponse,
+} from './test';
 import * as UploadAPI from './upload';
-import { Upload, UploadUploadFileParams, UploadUploadFromURLParams } from './upload';
+import {
+  Upload,
+  UploadCompleteUploadParams,
+  UploadCreatePresignedURLParams,
+  UploadCreatePresignedURLResponse,
+  UploadUploadFileParams,
+  UploadUploadFromURLParams,
+} from './upload';
 import { APIPromise } from '../../../core/api-promise';
 import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
@@ -75,104 +88,110 @@ export class Materials extends APIResource {
   }
 
   /**
+   * Create batch upload URLs for multiple materials
+   *
    * @example
    * ```ts
-   * await client.v1.materials.batchCreate();
+   * const response = await client.v1.materials.batchCreate({
+   *   materials: [
+   *     {
+   *       contentType: 'application/pdf',
+   *       filename: 'document.pdf',
+   *       name: 'Chapter 1',
+   *     },
+   *   ],
+   * });
    * ```
    */
-  batchCreate(options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/materials/batch', {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  batchCreate(
+    body: MaterialBatchCreateParams,
+    options?: RequestOptions,
+  ): APIPromise<MaterialBatchCreateResponse> {
+    return this._client.post('/api/v1/materials/batch', { body, ...options });
   }
 
   /**
+   * Get debug information for a material including extracted content
+   *
    * @example
    * ```ts
-   * await client.v1.materials.debug('id');
+   * const response = await client.v1.materials.debug('id');
    * ```
    */
-  debug(id: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.get(path`/api/v1/materials/${id}/debug`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  debug(id: string, options?: RequestOptions): APIPromise<MaterialDebugResponse> {
+    return this._client.get(path`/api/v1/materials/${id}/debug`, options);
   }
 
   /**
+   * Get temporary download URL for material
+   *
    * @example
    * ```ts
-   * await client.v1.materials.getDownloadURL('id', {
-   *   expiresIn: 'expiresIn',
-   * });
+   * const response = await client.v1.materials.getDownloadURL(
+   *   'id',
+   * );
    * ```
    */
   getDownloadURL(
     id: string,
-    query: MaterialGetDownloadURLParams,
+    query: MaterialGetDownloadURLParams | null | undefined = {},
     options?: RequestOptions,
-  ): APIPromise<void> {
-    return this._client.get(path`/api/v1/materials/${id}/download-url`, {
-      query,
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  ): APIPromise<MaterialGetDownloadURLResponse> {
+    return this._client.get(path`/api/v1/materials/${id}/download-url`, { query, ...options });
   }
 
   /**
+   * Move material to a different folder
+   *
    * @example
    * ```ts
-   * await client.v1.materials.move('id');
+   * const material = await client.v1.materials.move('id', {
+   *   folderId: 'folderId',
+   * });
    * ```
    */
-  move(id: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/api/v1/materials/${id}/move`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  move(id: string, body: MaterialMoveParams, options?: RequestOptions): APIPromise<Material> {
+    return this._client.post(path`/api/v1/materials/${id}/move`, { body, ...options });
   }
 
   /**
+   * Rename a material
+   *
    * @example
    * ```ts
-   * await client.v1.materials.rename('id');
+   * const material = await client.v1.materials.rename('id', {
+   *   name: 'New Material Name',
+   * });
    * ```
    */
-  rename(id: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/api/v1/materials/${id}/rename`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  rename(id: string, body: MaterialRenameParams, options?: RequestOptions): APIPromise<Material> {
+    return this._client.post(path`/api/v1/materials/${id}/rename`, { body, ...options });
   }
 
   /**
+   * Reprocess material to regenerate embeddings and extract content
+   *
    * @example
    * ```ts
-   * await client.v1.materials.reprocess('id');
+   * const material = await client.v1.materials.reprocess('id');
    * ```
    */
-  reprocess(id: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/api/v1/materials/${id}/reprocess`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  reprocess(id: string, options?: RequestOptions): APIPromise<Material> {
+    return this._client.post(path`/api/v1/materials/${id}/reprocess`, options);
   }
 
   /**
-   * Search materials using RAG
+   * Search materials using RAG (Retrieval-Augmented Generation)
    *
    * @example
    * ```ts
-   * await client.v1.materials.search({ query: 'query' });
+   * const response = await client.v1.materials.search({
+   *   query: 'What is photosynthesis?',
+   * });
    * ```
    */
-  search(body: MaterialSearchParams, options?: RequestOptions): APIPromise<void> {
-    return this._client.post('/api/v1/materials/search', {
-      body,
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
+  search(body: MaterialSearchParams, options?: RequestOptions): APIPromise<MaterialSearchResponse> {
+    return this._client.post('/api/v1/materials/search', { body, ...options });
   }
 }
 
@@ -256,6 +275,168 @@ export namespace Material {
 
 export type MaterialListResponse = Array<Material>;
 
+export type MaterialBatchCreateResponse = Array<MaterialBatchCreateResponse.MaterialBatchCreateResponseItem>;
+
+export namespace MaterialBatchCreateResponse {
+  export interface MaterialBatchCreateResponseItem {
+    /**
+     * Material ID
+     */
+    materialId: string;
+
+    /**
+     * Material name
+     */
+    name: string;
+
+    /**
+     * S3 key
+     */
+    s3Key: string;
+
+    /**
+     * Presigned upload URL
+     */
+    uploadUrl: string;
+  }
+}
+
+export interface MaterialDebugResponse {
+  /**
+   * Content details
+   */
+  content: unknown;
+
+  /**
+   * Content type
+   */
+  contentType: string;
+
+  /**
+   * Processed images
+   */
+  images: Array<MaterialDebugResponse.Image>;
+
+  /**
+   * Material ID
+   */
+  materialId: string;
+
+  /**
+   * Material metadata
+   */
+  metadata: unknown;
+
+  /**
+   * Material name
+   */
+  name: string;
+
+  /**
+   * Processing status
+   */
+  status: string;
+
+  /**
+   * Transcript structure for videos
+   */
+  transcriptStructure: unknown | null;
+}
+
+export namespace MaterialDebugResponse {
+  export interface Image {
+    id?: string;
+
+    description?: string;
+
+    pageIndex?: number;
+
+    s3Key?: string;
+
+    s3Url?: string;
+  }
+}
+
+export interface MaterialGetDownloadURLResponse {
+  /**
+   * Temporary download URL
+   */
+  downloadUrl: string;
+}
+
+export interface MaterialSearchResponse {
+  /**
+   * Whether results were filtered by scope
+   */
+  filtered: boolean;
+
+  /**
+   * Original search query
+   */
+  query: string;
+
+  /**
+   * Search results
+   */
+  results: Array<MaterialSearchResponse.Result>;
+
+  /**
+   * Search scope
+   */
+  scope: MaterialSearchResponse.Scope;
+
+  /**
+   * Total number of results
+   */
+  totalResults: number;
+}
+
+export namespace MaterialSearchResponse {
+  export interface Result {
+    /**
+     * Chunk index within the material
+     */
+    chunkIndex: number;
+
+    /**
+     * Material information
+     */
+    material: Result.Material | null;
+
+    /**
+     * Relevance score (0-1)
+     */
+    score: number;
+
+    /**
+     * Matched text chunk
+     */
+    text: string;
+  }
+
+  export namespace Result {
+    /**
+     * Material information
+     */
+    export interface Material {
+      id?: string;
+
+      contentType?: string;
+
+      name?: string;
+    }
+  }
+
+  /**
+   * Search scope
+   */
+  export interface Scope {
+    folderIds?: Array<string>;
+
+    materialIds?: Array<string>;
+  }
+}
+
 export interface MaterialCreateParams {
   /**
    * Content details
@@ -307,8 +488,56 @@ export interface MaterialListParams {
   folderId?: string;
 }
 
+export interface MaterialBatchCreateParams {
+  /**
+   * Array of materials to create
+   */
+  materials: Array<MaterialBatchCreateParams.Material>;
+}
+
+export namespace MaterialBatchCreateParams {
+  export interface Material {
+    /**
+     * MIME type
+     */
+    contentType: string;
+
+    /**
+     * Filename
+     */
+    filename: string;
+
+    /**
+     * Material name
+     */
+    name: string;
+
+    /**
+     * Folder ID
+     */
+    folderId?: string;
+  }
+}
+
 export interface MaterialGetDownloadURLParams {
-  expiresIn: string;
+  /**
+   * URL expiration time in seconds (default: 3600)
+   */
+  expiresIn?: number;
+}
+
+export interface MaterialMoveParams {
+  /**
+   * Target folder ID (null for root)
+   */
+  folderId: string | null;
+}
+
+export interface MaterialRenameParams {
+  /**
+   * New name for the material
+   */
+  name: string;
 }
 
 export interface MaterialSearchParams {
@@ -318,18 +547,17 @@ export interface MaterialSearchParams {
   query: string;
 
   /**
-   * Optional: Limit search to materials within specific folders (includes
-   * subfolders)
+   * Limit search to materials within specific folders (includes subfolders)
    */
   folderIds?: Array<string>;
 
   /**
-   * Optional: Limit search to specific material IDs
+   * Limit search to specific material IDs
    */
   materialIds?: Array<string>;
 
   /**
-   * Number of results to return (default: 5)
+   * Number of results to return
    */
   topK?: number;
 }
@@ -342,19 +570,35 @@ export declare namespace Materials {
   export {
     type Material as Material,
     type MaterialListResponse as MaterialListResponse,
+    type MaterialBatchCreateResponse as MaterialBatchCreateResponse,
+    type MaterialDebugResponse as MaterialDebugResponse,
+    type MaterialGetDownloadURLResponse as MaterialGetDownloadURLResponse,
+    type MaterialSearchResponse as MaterialSearchResponse,
     type MaterialCreateParams as MaterialCreateParams,
     type MaterialListParams as MaterialListParams,
+    type MaterialBatchCreateParams as MaterialBatchCreateParams,
     type MaterialGetDownloadURLParams as MaterialGetDownloadURLParams,
+    type MaterialMoveParams as MaterialMoveParams,
+    type MaterialRenameParams as MaterialRenameParams,
     type MaterialSearchParams as MaterialSearchParams,
   };
 
   export {
     Upload as Upload,
+    type UploadCreatePresignedURLResponse as UploadCreatePresignedURLResponse,
+    type UploadCompleteUploadParams as UploadCompleteUploadParams,
+    type UploadCreatePresignedURLParams as UploadCreatePresignedURLParams,
     type UploadUploadFileParams as UploadUploadFileParams,
     type UploadUploadFromURLParams as UploadUploadFromURLParams,
   };
 
-  export { Bulk as Bulk };
+  export { Bulk as Bulk, type BulkMoveResponse as BulkMoveResponse, type BulkMoveParams as BulkMoveParams };
 
-  export { Test as Test };
+  export {
+    Test as Test,
+    type TestPerformOcrResponse as TestPerformOcrResponse,
+    type TestProcessEpubResponse as TestProcessEpubResponse,
+    type TestProcessImageResponse as TestProcessImageResponse,
+    type TestProcessVideoResponse as TestProcessVideoResponse,
+  };
 }

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,
+  };
+}