@knowledge-stack/ksapi 1.23.5 → 1.25.0

package/src/apis/ChunksApi.ts

@@ -15,6 +15,7 @@
 
 import * as runtime from '../runtime';
 import type {
+  ChunkBulkResponse,
   ChunkResponse,
   ChunkSearchRequest,
   CreateChunkRequest,
@@ -22,8 +23,11 @@ import type {
   ScoredChunkResponse,
   UpdateChunkContentRequest,
   UpdateChunkMetadataRequest,
+  VersionChunkIdsResponse,
 } from '../models/index';
 import {
+    ChunkBulkResponseFromJSON,
+    ChunkBulkResponseToJSON,
     ChunkResponseFromJSON,
     ChunkResponseToJSON,
     ChunkSearchRequestFromJSON,
@@ -38,6 +42,8 @@ import {
     UpdateChunkContentRequestToJSON,
     UpdateChunkMetadataRequestFromJSON,
     UpdateChunkMetadataRequestToJSON,
+    VersionChunkIdsResponseFromJSON,
+    VersionChunkIdsResponseToJSON,
 } from '../models/index';
 
 export interface CreateChunkOperationRequest {
@@ -55,6 +61,16 @@ export interface GetChunkRequest {
     ksUat?: string | null;
 }
 
+export interface GetChunksBulkRequest {
+    chunkIds?: Array<string> | null;
+    ksUat?: string | null;
+}
+
+export interface GetVersionChunkIdsRequest {
+    documentVersionId: string;
+    ksUat?: string | null;
+}
+
 export interface SearchChunksRequest {
     chunkSearchRequest: ChunkSearchRequest;
     ksUat?: string | null;
@@ -79,6 +95,15 @@ export interface UpdateChunkMetadataOperationRequest {
  * @interface ChunksApiInterface
  */
 export interface ChunksApiInterface {
+    /**
+     * Creates request options for createChunk without sending the request
+     * @param {CreateChunkRequest} createChunkRequest 
+     * @param {string} [ksUat] 
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    createChunkRequestOpts(requestParameters: CreateChunkOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Create a new chunk with content.  The chunk is created as a child of the specified parent (must be DOCUMENT_VERSION or SECTION). Content is deduplicated by SHA256 hash.
      * @summary Create Chunk Handler
@@ -96,6 +121,15 @@ export interface ChunksApiInterface {
      */
     createChunk(requestParameters: CreateChunkOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ChunkResponse>;
 
+    /**
+     * Creates request options for deleteChunk without sending the request
+     * @param {string} chunkId 
+     * @param {string} [ksUat] 
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    deleteChunkRequestOpts(requestParameters: DeleteChunkRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Delete a chunk.  The chunk is deleted via its PathPart (cascading delete). The associated ChunkContent may remain if shared by other chunks.
      * @summary Delete Chunk Handler
@@ -113,6 +147,15 @@ export interface ChunksApiInterface {
      */
     deleteChunk(requestParameters: DeleteChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
 
+    /**
+     * Creates request options for getChunk without sending the request
+     * @param {string} chunkId 
+     * @param {string} [ksUat] 
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    getChunkRequestOpts(requestParameters: GetChunkRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Get a chunk by its ID, including content.
      * @summary Get Chunk Handler
@@ -131,7 +174,68 @@ export interface ChunksApiInterface {
     getChunk(requestParameters: GetChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ChunkResponse>;
 
     /**
-     * Semantic search over chunks using vector similarity.  Combines pgvector cosine similarity with path-based authorization and optional metadata filters. Uses a two-session design to avoid holding a DB connection during the external embedding API call.
+     * Creates request options for getChunksBulk without sending the request
+     * @param {Array<string>} [chunkIds] Chunk IDs to resolve (max 200)
+     * @param {string} [ksUat] 
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    getChunksBulkRequestOpts(requestParameters: GetChunksBulkRequest): Promise<runtime.RequestOpts>;
+
+    /**
+     * Batch-fetch chunks with their full ancestor path part IDs.  Returns standard chunk data plus path_part_id_segments (the ordered ancestor chain from root to chunk) for each requested chunk. Non-existent IDs are silently skipped. Limited to 200 IDs per call.
+     * @summary Get Chunks Bulk Handler
+     * @param {Array<string>} [chunkIds] Chunk IDs to resolve (max 200)
+     * @param {string} [ksUat] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    getChunksBulkRaw(requestParameters: GetChunksBulkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ChunkBulkResponse>>>;
+
+    /**
+     * Batch-fetch chunks with their full ancestor path part IDs.  Returns standard chunk data plus path_part_id_segments (the ordered ancestor chain from root to chunk) for each requested chunk. Non-existent IDs are silently skipped. Limited to 200 IDs per call.
+     * Get Chunks Bulk Handler
+     */
+    getChunksBulk(requestParameters: GetChunksBulkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ChunkBulkResponse>>;
+
+    /**
+     * Creates request options for getVersionChunkIds without sending the request
+     * @param {string} documentVersionId Document version ID
+     * @param {string} [ksUat] 
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    getVersionChunkIdsRequestOpts(requestParameters: GetVersionChunkIdsRequest): Promise<runtime.RequestOpts>;
+
+    /**
+     * Get all chunk IDs belonging to a document version.  Used by the embedding pipeline to discover chunks for a version.
+     * @summary Get Version Chunk Ids Handler
+     * @param {string} documentVersionId Document version ID
+     * @param {string} [ksUat] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    getVersionChunkIdsRaw(requestParameters: GetVersionChunkIdsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<VersionChunkIdsResponse>>;
+
+    /**
+     * Get all chunk IDs belonging to a document version.  Used by the embedding pipeline to discover chunks for a version.
+     * Get Version Chunk Ids Handler
+     */
+    getVersionChunkIds(requestParameters: GetVersionChunkIdsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<VersionChunkIdsResponse>;
+
+    /**
+     * Creates request options for searchChunks without sending the request
+     * @param {ChunkSearchRequest} chunkSearchRequest 
+     * @param {string} [ksUat] 
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    searchChunksRequestOpts(requestParameters: SearchChunksRequest): Promise<runtime.RequestOpts>;
+
+    /**
+     * Semantic search over chunks using Qdrant vector similarity.  Combines vector similarity with path-based authorization and optional metadata filters. Uses Qdrant for vector search and hydrates results from Postgres.
      * @summary Search Chunks Handler
      * @param {ChunkSearchRequest} chunkSearchRequest 
      * @param {string} [ksUat] 
@@ -142,11 +246,21 @@ export interface ChunksApiInterface {
     searchChunksRaw(requestParameters: SearchChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ScoredChunkResponse>>>;
 
     /**
-     * Semantic search over chunks using vector similarity.  Combines pgvector cosine similarity with path-based authorization and optional metadata filters. Uses a two-session design to avoid holding a DB connection during the external embedding API call.
+     * Semantic search over chunks using Qdrant vector similarity.  Combines vector similarity with path-based authorization and optional metadata filters. Uses Qdrant for vector search and hydrates results from Postgres.
      * Search Chunks Handler
      */
     searchChunks(requestParameters: SearchChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ScoredChunkResponse>>;
 
+    /**
+     * Creates request options for updateChunkContent without sending the request
+     * @param {string} chunkId 
+     * @param {UpdateChunkContentRequest} updateChunkContentRequest 
+     * @param {string} [ksUat] 
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    updateChunkContentRequestOpts(requestParameters: UpdateChunkContentOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Update chunk content by creating a new content row.  The old content row is preserved (not deleted). If the new content matches an existing content hash, it will be deduplicated.
      * @summary Update Chunk Content Handler
@@ -165,6 +279,16 @@ export interface ChunksApiInterface {
      */
     updateChunkContent(requestParameters: UpdateChunkContentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ChunkResponse>;
 
+    /**
+     * Creates request options for updateChunkMetadata without sending the request
+     * @param {string} chunkId 
+     * @param {UpdateChunkMetadataRequest} updateChunkMetadataRequest 
+     * @param {string} [ksUat] 
+     * @throws {RequiredError}
+     * @memberof ChunksApiInterface
+     */
+    updateChunkMetadataRequestOpts(requestParameters: UpdateChunkMetadataOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Update chunk metadata by merging with existing metadata.  The provided metadata is shallow-merged into the existing chunk_metadata.
      * @summary Update Chunk Metadata Handler
@@ -191,10 +315,9 @@ export interface ChunksApiInterface {
 export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
 
     /**
-     * Create a new chunk with content.  The chunk is created as a child of the specified parent (must be DOCUMENT_VERSION or SECTION). Content is deduplicated by SHA256 hash.
-     * Create Chunk Handler
+     * Creates request options for createChunk without sending the request
      */
-    async createChunkRaw(requestParameters: CreateChunkOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChunkResponse>> {
+    async createChunkRequestOpts(requestParameters: CreateChunkOperationRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['createChunkRequest'] == null) {
             throw new runtime.RequiredError(
                 'createChunkRequest',
@@ -211,13 +334,22 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
 
         let urlPath = `/v1/chunks`;
 
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: CreateChunkRequestToJSON(requestParameters['createChunkRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Create a new chunk with content.  The chunk is created as a child of the specified parent (must be DOCUMENT_VERSION or SECTION). Content is deduplicated by SHA256 hash.
+     * Create Chunk Handler
+     */
+    async createChunkRaw(requestParameters: CreateChunkOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChunkResponse>> {
+        const requestOptions = await this.createChunkRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => ChunkResponseFromJSON(jsonValue));
     }
@@ -232,10 +364,9 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
     }
 
     /**
-     * Delete a chunk.  The chunk is deleted via its PathPart (cascading delete). The associated ChunkContent may remain if shared by other chunks.
-     * Delete Chunk Handler
+     * Creates request options for deleteChunk without sending the request
      */
-    async deleteChunkRaw(requestParameters: DeleteChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async deleteChunkRequestOpts(requestParameters: DeleteChunkRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['chunkId'] == null) {
             throw new runtime.RequiredError(
                 'chunkId',
@@ -251,12 +382,21 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
         let urlPath = `/v1/chunks/{chunk_id}`;
         urlPath = urlPath.replace(`{${"chunk_id"}}`, encodeURIComponent(String(requestParameters['chunkId'])));
 
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Delete a chunk.  The chunk is deleted via its PathPart (cascading delete). The associated ChunkContent may remain if shared by other chunks.
+     * Delete Chunk Handler
+     */
+    async deleteChunkRaw(requestParameters: DeleteChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteChunkRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.VoidApiResponse(response);
     }
@@ -270,10 +410,9 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
     }
 
     /**
-     * Get a chunk by its ID, including content.
-     * Get Chunk Handler
+     * Creates request options for getChunk without sending the request
      */
-    async getChunkRaw(requestParameters: GetChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChunkResponse>> {
+    async getChunkRequestOpts(requestParameters: GetChunkRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['chunkId'] == null) {
             throw new runtime.RequiredError(
                 'chunkId',
@@ -289,12 +428,21 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
         let urlPath = `/v1/chunks/{chunk_id}`;
         urlPath = urlPath.replace(`{${"chunk_id"}}`, encodeURIComponent(String(requestParameters['chunkId'])));
 
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Get a chunk by its ID, including content.
+     * Get Chunk Handler
+     */
+    async getChunkRaw(requestParameters: GetChunkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChunkResponse>> {
+        const requestOptions = await this.getChunkRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => ChunkResponseFromJSON(jsonValue));
     }
@@ -309,10 +457,102 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
     }
 
     /**
-     * Semantic search over chunks using vector similarity.  Combines pgvector cosine similarity with path-based authorization and optional metadata filters. Uses a two-session design to avoid holding a DB connection during the external embedding API call.
-     * Search Chunks Handler
+     * Creates request options for getChunksBulk without sending the request
      */
-    async searchChunksRaw(requestParameters: SearchChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ScoredChunkResponse>>> {
+    async getChunksBulkRequestOpts(requestParameters: GetChunksBulkRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['chunkIds'] != null) {
+            queryParameters['chunk_ids'] = requestParameters['chunkIds'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/v1/chunks/bulk`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Batch-fetch chunks with their full ancestor path part IDs.  Returns standard chunk data plus path_part_id_segments (the ordered ancestor chain from root to chunk) for each requested chunk. Non-existent IDs are silently skipped. Limited to 200 IDs per call.
+     * Get Chunks Bulk Handler
+     */
+    async getChunksBulkRaw(requestParameters: GetChunksBulkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ChunkBulkResponse>>> {
+        const requestOptions = await this.getChunksBulkRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ChunkBulkResponseFromJSON));
+    }
+
+    /**
+     * Batch-fetch chunks with their full ancestor path part IDs.  Returns standard chunk data plus path_part_id_segments (the ordered ancestor chain from root to chunk) for each requested chunk. Non-existent IDs are silently skipped. Limited to 200 IDs per call.
+     * Get Chunks Bulk Handler
+     */
+    async getChunksBulk(requestParameters: GetChunksBulkRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ChunkBulkResponse>> {
+        const response = await this.getChunksBulkRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getVersionChunkIds without sending the request
+     */
+    async getVersionChunkIdsRequestOpts(requestParameters: GetVersionChunkIdsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['documentVersionId'] == null) {
+            throw new runtime.RequiredError(
+                'documentVersionId',
+                'Required parameter "documentVersionId" was null or undefined when calling getVersionChunkIds().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['documentVersionId'] != null) {
+            queryParameters['document_version_id'] = requestParameters['documentVersionId'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/v1/chunks/version-chunk-ids`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all chunk IDs belonging to a document version.  Used by the embedding pipeline to discover chunks for a version.
+     * Get Version Chunk Ids Handler
+     */
+    async getVersionChunkIdsRaw(requestParameters: GetVersionChunkIdsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<VersionChunkIdsResponse>> {
+        const requestOptions = await this.getVersionChunkIdsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => VersionChunkIdsResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all chunk IDs belonging to a document version.  Used by the embedding pipeline to discover chunks for a version.
+     * Get Version Chunk Ids Handler
+     */
+    async getVersionChunkIds(requestParameters: GetVersionChunkIdsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<VersionChunkIdsResponse> {
+        const response = await this.getVersionChunkIdsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for searchChunks without sending the request
+     */
+    async searchChunksRequestOpts(requestParameters: SearchChunksRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['chunkSearchRequest'] == null) {
             throw new runtime.RequiredError(
                 'chunkSearchRequest',
@@ -329,19 +569,28 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
 
         let urlPath = `/v1/chunks/search`;
 
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: ChunkSearchRequestToJSON(requestParameters['chunkSearchRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Semantic search over chunks using Qdrant vector similarity.  Combines vector similarity with path-based authorization and optional metadata filters. Uses Qdrant for vector search and hydrates results from Postgres.
+     * Search Chunks Handler
+     */
+    async searchChunksRaw(requestParameters: SearchChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ScoredChunkResponse>>> {
+        const requestOptions = await this.searchChunksRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ScoredChunkResponseFromJSON));
     }
 
     /**
-     * Semantic search over chunks using vector similarity.  Combines pgvector cosine similarity with path-based authorization and optional metadata filters. Uses a two-session design to avoid holding a DB connection during the external embedding API call.
+     * Semantic search over chunks using Qdrant vector similarity.  Combines vector similarity with path-based authorization and optional metadata filters. Uses Qdrant for vector search and hydrates results from Postgres.
      * Search Chunks Handler
      */
     async searchChunks(requestParameters: SearchChunksRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ScoredChunkResponse>> {
@@ -350,10 +599,9 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
     }
 
     /**
-     * Update chunk content by creating a new content row.  The old content row is preserved (not deleted). If the new content matches an existing content hash, it will be deduplicated.
-     * Update Chunk Content Handler
+     * Creates request options for updateChunkContent without sending the request
      */
-    async updateChunkContentRaw(requestParameters: UpdateChunkContentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChunkResponse>> {
+    async updateChunkContentRequestOpts(requestParameters: UpdateChunkContentOperationRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['chunkId'] == null) {
             throw new runtime.RequiredError(
                 'chunkId',
@@ -378,13 +626,22 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
         let urlPath = `/v1/chunks/{chunk_id}/content`;
         urlPath = urlPath.replace(`{${"chunk_id"}}`, encodeURIComponent(String(requestParameters['chunkId'])));
 
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
             body: UpdateChunkContentRequestToJSON(requestParameters['updateChunkContentRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Update chunk content by creating a new content row.  The old content row is preserved (not deleted). If the new content matches an existing content hash, it will be deduplicated.
+     * Update Chunk Content Handler
+     */
+    async updateChunkContentRaw(requestParameters: UpdateChunkContentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChunkResponse>> {
+        const requestOptions = await this.updateChunkContentRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => ChunkResponseFromJSON(jsonValue));
     }
@@ -399,10 +656,9 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
     }
 
     /**
-     * Update chunk metadata by merging with existing metadata.  The provided metadata is shallow-merged into the existing chunk_metadata.
-     * Update Chunk Metadata Handler
+     * Creates request options for updateChunkMetadata without sending the request
      */
-    async updateChunkMetadataRaw(requestParameters: UpdateChunkMetadataOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChunkResponse>> {
+    async updateChunkMetadataRequestOpts(requestParameters: UpdateChunkMetadataOperationRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['chunkId'] == null) {
             throw new runtime.RequiredError(
                 'chunkId',
@@ -427,13 +683,22 @@ export class ChunksApi extends runtime.BaseAPI implements ChunksApiInterface {
         let urlPath = `/v1/chunks/{chunk_id}`;
         urlPath = urlPath.replace(`{${"chunk_id"}}`, encodeURIComponent(String(requestParameters['chunkId'])));
 
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
             body: UpdateChunkMetadataRequestToJSON(requestParameters['updateChunkMetadataRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Update chunk metadata by merging with existing metadata.  The provided metadata is shallow-merged into the existing chunk_metadata.
+     * Update Chunk Metadata Handler
+     */
+    async updateChunkMetadataRaw(requestParameters: UpdateChunkMetadataOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ChunkResponse>> {
+        const requestOptions = await this.updateChunkMetadataRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => ChunkResponseFromJSON(jsonValue));
     }

package/src/apis/DefaultApi.ts

@@ -32,6 +32,13 @@ import {
  * @interface DefaultApiInterface
  */
 export interface DefaultApiInterface {
+    /**
+     * Creates request options for healthCheck without sending the request
+     * @throws {RequiredError}
+     * @memberof DefaultApiInterface
+     */
+    healthCheckRequestOpts(): Promise<runtime.RequestOpts>;
+
     /**
      * Health check endpoint.
      * @summary Health Check Handler
@@ -47,6 +54,13 @@ export interface DefaultApiInterface {
      */
     healthCheck(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<HealthCheckResponse>;
 
+    /**
+     * Creates request options for hello without sending the request
+     * @throws {RequiredError}
+     * @memberof DefaultApiInterface
+     */
+    helloRequestOpts(): Promise<runtime.RequestOpts>;
+
     /**
      * Root endpoint.
      * @summary Root Handler
@@ -70,10 +84,9 @@ export interface DefaultApiInterface {
 export class DefaultApi extends runtime.BaseAPI implements DefaultApiInterface {
 
     /**
-     * Health check endpoint.
-     * Health Check Handler
+     * Creates request options for healthCheck without sending the request
      */
-    async healthCheckRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<HealthCheckResponse>> {
+    async healthCheckRequestOpts(): Promise<runtime.RequestOpts> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -81,12 +94,21 @@ export class DefaultApi extends runtime.BaseAPI implements DefaultApiInterface {
 
         let urlPath = `/healthz`;
 
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Health check endpoint.
+     * Health Check Handler
+     */
+    async healthCheckRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<HealthCheckResponse>> {
+        const requestOptions = await this.healthCheckRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => HealthCheckResponseFromJSON(jsonValue));
     }
@@ -101,10 +123,9 @@ export class DefaultApi extends runtime.BaseAPI implements DefaultApiInterface {
     }
 
     /**
-     * Root endpoint.
-     * Root Handler
+     * Creates request options for hello without sending the request
      */
-    async helloRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RootResponse>> {
+    async helloRequestOpts(): Promise<runtime.RequestOpts> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -112,12 +133,21 @@ export class DefaultApi extends runtime.BaseAPI implements DefaultApiInterface {
 
         let urlPath = `/`;
 
-        const response = await this.request({
+        return {
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Root endpoint.
+     * Root Handler
+     */
+    async helloRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RootResponse>> {
+        const requestOptions = await this.helloRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => RootResponseFromJSON(jsonValue));
     }