@toloka-platform/sdk 0.14.0 → 0.15.1

package/openapi/gen/api.ts

@@ -12,7 +12,6 @@ import type {
   CreateBatchInferenceRunBody,
   CreateDatasetBody,
   CreateDatasetExportBody,
-  CreateDatasetField200,
   CreateDatasetFieldBody,
   CreateDatasetFieldsFromUploadedRowsBody,
   CreateDatasetSliceBody,
@@ -103,6 +102,7 @@ import type {
   RunItem,
   RunItemId,
   RunJob,
+  RunLintsResult,
   SampleDatasetItemsBody,
   SampleJob,
   SampleResult,
@@ -124,25 +124,26 @@ import type {
   UploadId,
   UploadJob,
   ValidatePipelineGraphBody
-} from './models';
+} from './api.schemas';
 
 import { potatoFetch } from '../../src/transport';
+
 export const getListBaseModelsUrl = () => {
 
 
-  
+
 
   return `/api/v2-beta/base-models`
 }
 
-export const listBaseModels = async ( options?: RequestInit): Promise<ListBaseModels200> => {
-  
+export const listBaseModels = async ( options?: Parameters<typeof potatoFetch>[1]): Promise<ListBaseModels200> => {
+
   return potatoFetch<ListBaseModels200>(getListBaseModelsUrl(),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -151,19 +152,19 @@ export const listBaseModels = async ( options?: RequestInit): Promise<ListBaseMo
 export const getGetBaseModelUrl = (baseModelId: BaseModelId,) => {
 
 
-  
+
 
   return `/api/v2-beta/base-models/${baseModelId}`
 }
 
-export const getBaseModel = async (baseModelId: BaseModelId, options?: RequestInit): Promise<BaseModel> => {
-  
+export const getBaseModel = async (baseModelId: BaseModelId, options?: Parameters<typeof potatoFetch>[1]): Promise<BaseModel> => {
+
   return potatoFetch<BaseModel>(getGetBaseModelUrl(baseModelId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -174,9 +175,9 @@ export const getListProjectModelsUrl = (projectId: ProjectId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -186,14 +187,14 @@ export const getListProjectModelsUrl = (projectId: ProjectId,
 }
 
 export const listProjectModels = async (projectId: ProjectId,
-    params?: ListProjectModelsParams, options?: RequestInit): Promise<ListProjectModels200> => {
-  
+    params?: ListProjectModelsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListProjectModels200> => {
+
   return potatoFetch<ListProjectModels200>(getListProjectModelsUrl(projectId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -202,21 +203,34 @@ export const listProjectModels = async (projectId: ProjectId,
 export const getCreateProjectModelUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/models`
 }
 
 export const createProjectModel = async (projectId: ProjectId,
-    createProjectModelBody: CreateProjectModelBody, options?: RequestInit): Promise<Model> => {
-  
-  return potatoFetch<Model>(getCreateProjectModelUrl(projectId),
-  {      
+    createProjectModelBody: CreateProjectModelBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Model> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Model>(getCreateProjectModelUrl(projectId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createProjectModelBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createProjectModelBody)
   }
 );}
 
@@ -228,9 +242,9 @@ export const getListModelVersionsUrl = (projectId: ProjectId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -241,14 +255,14 @@ export const getListModelVersionsUrl = (projectId: ProjectId,
 
 export const listModelVersions = async (projectId: ProjectId,
     modelId: ModelId,
-    params?: ListModelVersionsParams, options?: RequestInit): Promise<ListModelVersions200> => {
-  
+    params?: ListModelVersionsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListModelVersions200> => {
+
   return potatoFetch<ListModelVersions200>(getListModelVersionsUrl(projectId,modelId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -257,19 +271,19 @@ export const listModelVersions = async (projectId: ProjectId,
 export const getGetModelVersionUrl = (modelVersionId: ModelVersionId,) => {
 
 
-  
+
 
   return `/api/v2-beta/model-versions/${modelVersionId}`
 }
 
-export const getModelVersion = async (modelVersionId: ModelVersionId, options?: RequestInit): Promise<ModelVersion> => {
-  
+export const getModelVersion = async (modelVersionId: ModelVersionId, options?: Parameters<typeof potatoFetch>[1]): Promise<ModelVersion> => {
+
   return potatoFetch<ModelVersion>(getGetModelVersionUrl(modelVersionId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -278,19 +292,19 @@ export const getModelVersion = async (modelVersionId: ModelVersionId, options?:
 export const getGetModelVersionContentUrl = (modelVersionId: ModelVersionId,) => {
 
 
-  
+
 
   return `/api/v2-beta/model-versions/${modelVersionId}/content`
 }
 
-export const getModelVersionContent = async (modelVersionId: ModelVersionId, options?: RequestInit): Promise<ModelVersionContentDownload> => {
-  
+export const getModelVersionContent = async (modelVersionId: ModelVersionId, options?: Parameters<typeof potatoFetch>[1]): Promise<ModelVersionContentDownload> => {
+
   return potatoFetch<ModelVersionContentDownload>(getGetModelVersionContentUrl(modelVersionId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -300,20 +314,20 @@ export const getArchiveProjectModelUrl = (projectId: ProjectId,
     modelId: ModelId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/models/${modelId}/archive`
 }
 
 export const archiveProjectModel = async (projectId: ProjectId,
-    modelId: ModelId, options?: RequestInit): Promise<Model> => {
-  
+    modelId: ModelId, options?: Parameters<typeof potatoFetch>[1]): Promise<Model> => {
+
   return potatoFetch<Model>(getArchiveProjectModelUrl(projectId,modelId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -323,20 +337,20 @@ export const getGetProjectModelUrl = (projectId: ProjectId,
     modelId: ModelId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/models/${modelId}`
 }
 
 export const getProjectModel = async (projectId: ProjectId,
-    modelId: ModelId, options?: RequestInit): Promise<Model> => {
-  
+    modelId: ModelId, options?: Parameters<typeof potatoFetch>[1]): Promise<Model> => {
+
   return potatoFetch<Model>(getGetProjectModelUrl(projectId,modelId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -347,9 +361,9 @@ export const getListProjectTrainingsUrl = (projectId: ProjectId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -359,14 +373,14 @@ export const getListProjectTrainingsUrl = (projectId: ProjectId,
 }
 
 export const listProjectTrainings = async (projectId: ProjectId,
-    params?: ListProjectTrainingsParams, options?: RequestInit): Promise<ListProjectTrainings200> => {
-  
+    params?: ListProjectTrainingsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListProjectTrainings200> => {
+
   return potatoFetch<ListProjectTrainings200>(getListProjectTrainingsUrl(projectId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -375,21 +389,34 @@ export const listProjectTrainings = async (projectId: ProjectId,
 export const getCreateProjectTrainingUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/trainings`
 }
 
 export const createProjectTraining = async (projectId: ProjectId,
-    createProjectTrainingBody: CreateProjectTrainingBody, options?: RequestInit): Promise<Training> => {
-  
-  return potatoFetch<Training>(getCreateProjectTrainingUrl(projectId),
-  {      
+    createProjectTrainingBody: CreateProjectTrainingBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Training> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Training>(getCreateProjectTrainingUrl(projectId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createProjectTrainingBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createProjectTrainingBody)
   }
 );}
 
@@ -398,19 +425,19 @@ export const createProjectTraining = async (projectId: ProjectId,
 export const getGetTrainingUrl = (trainingId: TrainingId,) => {
 
 
-  
+
 
   return `/api/v2-beta/trainings/${trainingId}`
 }
 
-export const getTraining = async (trainingId: TrainingId, options?: RequestInit): Promise<Training> => {
-  
+export const getTraining = async (trainingId: TrainingId, options?: Parameters<typeof potatoFetch>[1]): Promise<Training> => {
+
   return potatoFetch<Training>(getGetTrainingUrl(trainingId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -419,21 +446,34 @@ export const getTraining = async (trainingId: TrainingId, options?: RequestInit)
 export const getUpdateTrainingMetadataUrl = (trainingId: TrainingId,) => {
 
 
-  
+
 
   return `/api/v2-beta/trainings/${trainingId}`
 }
 
 export const updateTrainingMetadata = async (trainingId: TrainingId,
-    updateTrainingMetadataBody: UpdateTrainingMetadataBody, options?: RequestInit): Promise<Training> => {
-  
-  return potatoFetch<Training>(getUpdateTrainingMetadataUrl(trainingId),
-  {      
+    updateTrainingMetadataBody: UpdateTrainingMetadataBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Training> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Training>(getUpdateTrainingMetadataUrl(trainingId),
+  {
     ...options,
     method: 'PATCH',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      updateTrainingMetadataBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(updateTrainingMetadataBody)
   }
 );}
 
@@ -442,21 +482,34 @@ export const updateTrainingMetadata = async (trainingId: TrainingId,
 export const getReplaceTrainingConfigurationUrl = (trainingId: TrainingId,) => {
 
 
-  
+
 
   return `/api/v2-beta/trainings/${trainingId}/configuration`
 }
 
 export const replaceTrainingConfiguration = async (trainingId: TrainingId,
-    replaceTrainingConfigurationBody: ReplaceTrainingConfigurationBody, options?: RequestInit): Promise<Training> => {
-  
-  return potatoFetch<Training>(getReplaceTrainingConfigurationUrl(trainingId),
-  {      
+    replaceTrainingConfigurationBody: ReplaceTrainingConfigurationBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Training> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Training>(getReplaceTrainingConfigurationUrl(trainingId),
+  {
     ...options,
     method: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      replaceTrainingConfigurationBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(replaceTrainingConfigurationBody)
   }
 );}
 
@@ -465,21 +518,34 @@ export const replaceTrainingConfiguration = async (trainingId: TrainingId,
 export const getPrepareTrainingCostEstimateInputsUrl = (trainingId: TrainingId,) => {
 
 
-  
+
 
   return `/api/v2-beta/trainings/${trainingId}/cost-estimate-inputs`
 }
 
 export const prepareTrainingCostEstimateInputs = async (trainingId: TrainingId,
-    prepareTrainingCostEstimateInputsBody: PrepareTrainingCostEstimateInputsBody, options?: RequestInit): Promise<TrainingCostEstimateInputSet> => {
-  
-  return potatoFetch<TrainingCostEstimateInputSet>(getPrepareTrainingCostEstimateInputsUrl(trainingId),
-  {      
+    prepareTrainingCostEstimateInputsBody: PrepareTrainingCostEstimateInputsBody, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingCostEstimateInputSet> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<TrainingCostEstimateInputSet>(getPrepareTrainingCostEstimateInputsUrl(trainingId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      prepareTrainingCostEstimateInputsBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(prepareTrainingCostEstimateInputsBody)
   }
 );}
 
@@ -488,21 +554,34 @@ export const prepareTrainingCostEstimateInputs = async (trainingId: TrainingId,
 export const getEstimateTrainingCostUrl = (trainingId: TrainingId,) => {
 
 
-  
+
 
   return `/api/v2-beta/trainings/${trainingId}/cost-estimate`
 }
 
 export const estimateTrainingCost = async (trainingId: TrainingId,
-    estimateTrainingCostBody: EstimateTrainingCostBody, options?: RequestInit): Promise<TrainingCostEstimate> => {
-  
-  return potatoFetch<TrainingCostEstimate>(getEstimateTrainingCostUrl(trainingId),
-  {      
+    estimateTrainingCostBody: EstimateTrainingCostBody, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingCostEstimate> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<TrainingCostEstimate>(getEstimateTrainingCostUrl(trainingId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      estimateTrainingCostBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(estimateTrainingCostBody)
   }
 );}
 
@@ -511,21 +590,34 @@ export const estimateTrainingCost = async (trainingId: TrainingId,
 export const getCreateTrainingRunUrl = (trainingId: TrainingId,) => {
 
 
-  
+
 
   return `/api/v2-beta/trainings/${trainingId}/runs`
 }
 
 export const createTrainingRun = async (trainingId: TrainingId,
-    createTrainingRunBody: CreateTrainingRunBody, options?: RequestInit): Promise<TrainingRun> => {
-  
-  return potatoFetch<TrainingRun>(getCreateTrainingRunUrl(trainingId),
-  {      
+    createTrainingRunBody: CreateTrainingRunBody, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingRun> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<TrainingRun>(getCreateTrainingRunUrl(trainingId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createTrainingRunBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createTrainingRunBody)
   }
 );}
 
@@ -536,9 +628,9 @@ export const getListTrainingRunsUrl = (trainingId: TrainingId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -548,14 +640,14 @@ export const getListTrainingRunsUrl = (trainingId: TrainingId,
 }
 
 export const listTrainingRuns = async (trainingId: TrainingId,
-    params?: ListTrainingRunsParams, options?: RequestInit): Promise<ListTrainingRuns200> => {
-  
+    params?: ListTrainingRunsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListTrainingRuns200> => {
+
   return potatoFetch<ListTrainingRuns200>(getListTrainingRunsUrl(trainingId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -564,19 +656,19 @@ export const listTrainingRuns = async (trainingId: TrainingId,
 export const getGetTrainingRunUrl = (trainingRunId: TrainingRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/training-runs/${trainingRunId}`
 }
 
-export const getTrainingRun = async (trainingRunId: TrainingRunId, options?: RequestInit): Promise<TrainingRun> => {
-  
+export const getTrainingRun = async (trainingRunId: TrainingRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingRun> => {
+
   return potatoFetch<TrainingRun>(getGetTrainingRunUrl(trainingRunId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -587,9 +679,9 @@ export const getGetTrainingRunLogsUrl = (trainingRunId: TrainingRunId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -599,14 +691,14 @@ export const getGetTrainingRunLogsUrl = (trainingRunId: TrainingRunId,
 }
 
 export const getTrainingRunLogs = async (trainingRunId: TrainingRunId,
-    params?: GetTrainingRunLogsParams, options?: RequestInit): Promise<TrainingRunLogs> => {
-  
+    params?: GetTrainingRunLogsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingRunLogs> => {
+
   return potatoFetch<TrainingRunLogs>(getGetTrainingRunLogsUrl(trainingRunId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -615,19 +707,19 @@ export const getTrainingRunLogs = async (trainingRunId: TrainingRunId,
 export const getGetTrainingRunMetricsUrl = (trainingRunId: TrainingRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/training-runs/${trainingRunId}/metrics`
 }
 
-export const getTrainingRunMetrics = async (trainingRunId: TrainingRunId, options?: RequestInit): Promise<TrainingRunMetrics> => {
-  
+export const getTrainingRunMetrics = async (trainingRunId: TrainingRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingRunMetrics> => {
+
   return potatoFetch<TrainingRunMetrics>(getGetTrainingRunMetricsUrl(trainingRunId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -639,9 +731,9 @@ export const getGetTrainingRunMetricHistoryUrl = (trainingRunId: TrainingRunId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -652,14 +744,14 @@ export const getGetTrainingRunMetricHistoryUrl = (trainingRunId: TrainingRunId,
 
 export const getTrainingRunMetricHistory = async (trainingRunId: TrainingRunId,
     metricKey: string,
-    params?: GetTrainingRunMetricHistoryParams, options?: RequestInit): Promise<TrainingRunMetricHistory> => {
-  
+    params?: GetTrainingRunMetricHistoryParams, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingRunMetricHistory> => {
+
   return potatoFetch<TrainingRunMetricHistory>(getGetTrainingRunMetricHistoryUrl(trainingRunId,metricKey,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -668,19 +760,19 @@ export const getTrainingRunMetricHistory = async (trainingRunId: TrainingRunId,
 export const getResumeTrainingRunUrl = (trainingRunId: TrainingRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/training-runs/${trainingRunId}/resume`
 }
 
-export const resumeTrainingRun = async (trainingRunId: TrainingRunId, options?: RequestInit): Promise<TrainingRun> => {
-  
+export const resumeTrainingRun = async (trainingRunId: TrainingRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingRun> => {
+
   return potatoFetch<TrainingRun>(getResumeTrainingRunUrl(trainingRunId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -689,19 +781,19 @@ export const resumeTrainingRun = async (trainingRunId: TrainingRunId, options?:
 export const getCancelTrainingRunUrl = (trainingRunId: TrainingRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/training-runs/${trainingRunId}/cancel`
 }
 
-export const cancelTrainingRun = async (trainingRunId: TrainingRunId, options?: RequestInit): Promise<TrainingRun> => {
-  
+export const cancelTrainingRun = async (trainingRunId: TrainingRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<TrainingRun> => {
+
   return potatoFetch<TrainingRun>(getCancelTrainingRunUrl(trainingRunId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -711,9 +803,9 @@ export const getListAudienceSpecializationsUrl = (params?: ListAudienceSpecializ
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -722,14 +814,14 @@ export const getListAudienceSpecializationsUrl = (params?: ListAudienceSpecializ
   return stringifiedParams.length > 0 ? `/api/v2-beta/audience/specializations?${stringifiedParams}` : `/api/v2-beta/audience/specializations`
 }
 
-export const listAudienceSpecializations = async (params?: ListAudienceSpecializationsParams, options?: RequestInit): Promise<ListAudienceSpecializations200> => {
-  
+export const listAudienceSpecializations = async (params?: ListAudienceSpecializationsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListAudienceSpecializations200> => {
+
   return potatoFetch<ListAudienceSpecializations200>(getListAudienceSpecializationsUrl(params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -738,19 +830,19 @@ export const listAudienceSpecializations = async (params?: ListAudienceSpecializ
 export const getListGenerationModelsUrl = () => {
 
 
-  
+
 
   return `/api/v2-beta/generation-models`
 }
 
-export const listGenerationModels = async ( options?: RequestInit): Promise<ListGenerationModels200> => {
-  
+export const listGenerationModels = async ( options?: Parameters<typeof potatoFetch>[1]): Promise<ListGenerationModels200> => {
+
   return potatoFetch<ListGenerationModels200>(getListGenerationModelsUrl(),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -759,19 +851,19 @@ export const listGenerationModels = async ( options?: RequestInit): Promise<List
 export const getGetCurrentUserUrl = () => {
 
 
-  
+
 
   return `/api/v2-beta/me`
 }
 
-export const getCurrentUser = async ( options?: RequestInit): Promise<CurrentUser> => {
-  
+export const getCurrentUser = async ( options?: Parameters<typeof potatoFetch>[1]): Promise<CurrentUser> => {
+
   return potatoFetch<CurrentUser>(getGetCurrentUserUrl(),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -780,19 +872,19 @@ export const getCurrentUser = async ( options?: RequestInit): Promise<CurrentUse
 export const getListDeliveryOrdersUrl = () => {
 
 
-  
+
 
   return `/api/v2-beta/delivery-orders`
 }
 
-export const listDeliveryOrders = async ( options?: RequestInit): Promise<ListDeliveryOrders200> => {
-  
+export const listDeliveryOrders = async ( options?: Parameters<typeof potatoFetch>[1]): Promise<ListDeliveryOrders200> => {
+
   return potatoFetch<ListDeliveryOrders200>(getListDeliveryOrdersUrl(),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -802,9 +894,9 @@ export const getListProjectsUrl = (params?: ListProjectsParams,) => {
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -813,14 +905,14 @@ export const getListProjectsUrl = (params?: ListProjectsParams,) => {
   return stringifiedParams.length > 0 ? `/api/v2-beta/projects?${stringifiedParams}` : `/api/v2-beta/projects`
 }
 
-export const listProjects = async (params?: ListProjectsParams, options?: RequestInit): Promise<ListProjects200> => {
-  
+export const listProjects = async (params?: ListProjectsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListProjects200> => {
+
   return potatoFetch<ListProjects200>(getListProjectsUrl(params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -829,20 +921,33 @@ export const listProjects = async (params?: ListProjectsParams, options?: Reques
 export const getCreateProjectUrl = () => {
 
 
-  
+
 
   return `/api/v2-beta/projects`
 }
 
-export const createProject = async (createProjectBody: CreateProjectBody, options?: RequestInit): Promise<Project> => {
-  
-  return potatoFetch<Project>(getCreateProjectUrl(),
-  {      
+export const createProject = async (createProjectBody: CreateProjectBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Project> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Project>(getCreateProjectUrl(),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createProjectBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createProjectBody)
   }
 );}
 
@@ -851,19 +956,19 @@ export const createProject = async (createProjectBody: CreateProjectBody, option
 export const getGetProjectByIdUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}`
 }
 
-export const getProjectById = async (projectId: ProjectId, options?: RequestInit): Promise<Project> => {
-  
+export const getProjectById = async (projectId: ProjectId, options?: Parameters<typeof potatoFetch>[1]): Promise<Project> => {
+
   return potatoFetch<Project>(getGetProjectByIdUrl(projectId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -872,21 +977,34 @@ export const getProjectById = async (projectId: ProjectId, options?: RequestInit
 export const getUpdateProjectUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}`
 }
 
 export const updateProject = async (projectId: ProjectId,
-    updateProjectBody: UpdateProjectBody, options?: RequestInit): Promise<Project> => {
-  
-  return potatoFetch<Project>(getUpdateProjectUrl(projectId),
-  {      
+    updateProjectBody: UpdateProjectBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Project> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Project>(getUpdateProjectUrl(projectId),
+  {
     ...options,
     method: 'PATCH',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      updateProjectBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(updateProjectBody)
   }
 );}
 
@@ -897,9 +1015,9 @@ export const getListProjectPipelinesUrl = (projectId: ProjectId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -909,14 +1027,14 @@ export const getListProjectPipelinesUrl = (projectId: ProjectId,
 }
 
 export const listProjectPipelines = async (projectId: ProjectId,
-    params?: ListProjectPipelinesParams, options?: RequestInit): Promise<ListProjectPipelines200> => {
-  
+    params?: ListProjectPipelinesParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListProjectPipelines200> => {
+
   return potatoFetch<ListProjectPipelines200>(getListProjectPipelinesUrl(projectId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -925,19 +1043,19 @@ export const listProjectPipelines = async (projectId: ProjectId,
 export const getGetPipelineByIdUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}`
 }
 
-export const getPipelineById = async (pipelineId: PipelineId, options?: RequestInit): Promise<Pipeline> => {
-  
+export const getPipelineById = async (pipelineId: PipelineId, options?: Parameters<typeof potatoFetch>[1]): Promise<Pipeline> => {
+
   return potatoFetch<Pipeline>(getGetPipelineByIdUrl(pipelineId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -946,21 +1064,34 @@ export const getPipelineById = async (pipelineId: PipelineId, options?: RequestI
 export const getUpdatePipelineUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}`
 }
 
 export const updatePipeline = async (pipelineId: PipelineId,
-    updatePipelineBody: UpdatePipelineBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getUpdatePipelineUrl(pipelineId),
-  {      
+    updatePipelineBody: UpdatePipelineBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Pipeline> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Pipeline>(getUpdatePipelineUrl(pipelineId),
+  {
     ...options,
     method: 'PATCH',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      updatePipelineBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(updatePipelineBody)
   }
 );}
 
@@ -971,9 +1102,9 @@ export const getListProjectDatasetsUrl = (projectId: ProjectId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -983,14 +1114,14 @@ export const getListProjectDatasetsUrl = (projectId: ProjectId,
 }
 
 export const listProjectDatasets = async (projectId: ProjectId,
-    params?: ListProjectDatasetsParams, options?: RequestInit): Promise<ListProjectDatasets200> => {
-  
+    params?: ListProjectDatasetsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListProjectDatasets200> => {
+
   return potatoFetch<ListProjectDatasets200>(getListProjectDatasetsUrl(projectId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -999,21 +1130,34 @@ export const listProjectDatasets = async (projectId: ProjectId,
 export const getCreateDatasetUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/datasets`
 }
 
 export const createDataset = async (projectId: ProjectId,
-    createDatasetBody: CreateDatasetBody, options?: RequestInit): Promise<Dataset> => {
-  
-  return potatoFetch<Dataset>(getCreateDatasetUrl(projectId),
-  {      
+    createDatasetBody: CreateDatasetBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Dataset> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Dataset>(getCreateDatasetUrl(projectId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createDatasetBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createDatasetBody)
   }
 );}
 
@@ -1022,19 +1166,19 @@ export const createDataset = async (projectId: ProjectId,
 export const getGetDatasetByIdUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}`
 }
 
-export const getDatasetById = async (datasetId: DatasetId, options?: RequestInit): Promise<Dataset> => {
-  
+export const getDatasetById = async (datasetId: DatasetId, options?: Parameters<typeof potatoFetch>[1]): Promise<Dataset> => {
+
   return potatoFetch<Dataset>(getGetDatasetByIdUrl(datasetId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1045,9 +1189,9 @@ export const getListDatasetFieldsUrl = (datasetId: DatasetId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -1057,14 +1201,14 @@ export const getListDatasetFieldsUrl = (datasetId: DatasetId,
 }
 
 export const listDatasetFields = async (datasetId: DatasetId,
-    params?: ListDatasetFieldsParams, options?: RequestInit): Promise<ListDatasetFields200> => {
-  
+    params?: ListDatasetFieldsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListDatasetFields200> => {
+
   return potatoFetch<ListDatasetFields200>(getListDatasetFieldsUrl(datasetId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1073,21 +1217,34 @@ export const listDatasetFields = async (datasetId: DatasetId,
 export const getCreateDatasetFieldUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/fields`
 }
 
 export const createDatasetField = async (datasetId: DatasetId,
-    createDatasetFieldBody: CreateDatasetFieldBody, options?: RequestInit): Promise<CreateDatasetField200> => {
-  
-  return potatoFetch<CreateDatasetField200>(getCreateDatasetFieldUrl(datasetId),
-  {      
+    createDatasetFieldBody: CreateDatasetFieldBody, options?: Parameters<typeof potatoFetch>[1]): Promise<DatasetField | CreatedDatasetFields> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<DatasetField | CreatedDatasetFields>(getCreateDatasetFieldUrl(datasetId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createDatasetFieldBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createDatasetFieldBody)
   }
 );}
 
@@ -1096,19 +1253,19 @@ export const createDatasetField = async (datasetId: DatasetId,
 export const getGetDatasetInferredFieldsUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/inferred-fields`
 }
 
-export const getDatasetInferredFields = async (datasetId: DatasetId, options?: RequestInit): Promise<GetDatasetInferredFields200> => {
-  
+export const getDatasetInferredFields = async (datasetId: DatasetId, options?: Parameters<typeof potatoFetch>[1]): Promise<GetDatasetInferredFields200> => {
+
   return potatoFetch<GetDatasetInferredFields200>(getGetDatasetInferredFieldsUrl(datasetId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1117,21 +1274,34 @@ export const getDatasetInferredFields = async (datasetId: DatasetId, options?: R
 export const getAddDatasetItemsUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/items`
 }
 
 export const addDatasetItems = async (datasetId: DatasetId,
-    addDatasetItemsBody: AddDatasetItemsBody, options?: RequestInit): Promise<AddDatasetItems200> => {
-  
-  return potatoFetch<AddDatasetItems200>(getAddDatasetItemsUrl(datasetId),
-  {      
+    addDatasetItemsBody: AddDatasetItemsBody, options?: Parameters<typeof potatoFetch>[1]): Promise<AddDatasetItems200> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<AddDatasetItems200>(getAddDatasetItemsUrl(datasetId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      addDatasetItemsBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(addDatasetItemsBody)
   }
 );}
 
@@ -1142,9 +1312,9 @@ export const getListDatasetItemsUrl = (datasetId: DatasetId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -1154,14 +1324,14 @@ export const getListDatasetItemsUrl = (datasetId: DatasetId,
 }
 
 export const listDatasetItems = async (datasetId: DatasetId,
-    params?: ListDatasetItemsParams, options?: RequestInit): Promise<ListDatasetItems200> => {
-  
+    params?: ListDatasetItemsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListDatasetItems200> => {
+
   return potatoFetch<ListDatasetItems200>(getListDatasetItemsUrl(datasetId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1170,21 +1340,34 @@ export const listDatasetItems = async (datasetId: DatasetId,
 export const getCreateDatasetUploadUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/uploads`
 }
 
 export const createDatasetUpload = async (datasetId: DatasetId,
-    createDatasetUploadBody: CreateDatasetUploadBody, options?: RequestInit): Promise<CreateDatasetUpload200> => {
-  
-  return potatoFetch<CreateDatasetUpload200>(getCreateDatasetUploadUrl(datasetId),
-  {      
+    createDatasetUploadBody: CreateDatasetUploadBody, options?: Parameters<typeof potatoFetch>[1]): Promise<CreateDatasetUpload200> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<CreateDatasetUpload200>(getCreateDatasetUploadUrl(datasetId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createDatasetUploadBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createDatasetUploadBody)
   }
 );}
 
@@ -1193,19 +1376,19 @@ export const createDatasetUpload = async (datasetId: DatasetId,
 export const getFinalizeDatasetUploadUrl = (uploadId: UploadId,) => {
 
 
-  
+
 
   return `/api/v2-beta/uploads/${uploadId}/finalize`
 }
 
-export const finalizeDatasetUpload = async (uploadId: UploadId, options?: RequestInit): Promise<UploadJob> => {
-  
+export const finalizeDatasetUpload = async (uploadId: UploadId, options?: Parameters<typeof potatoFetch>[1]): Promise<UploadJob> => {
+
   return potatoFetch<UploadJob>(getFinalizeDatasetUploadUrl(uploadId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -1214,19 +1397,19 @@ export const finalizeDatasetUpload = async (uploadId: UploadId, options?: Reques
 export const getCancelDatasetUploadUrl = (uploadId: UploadId,) => {
 
 
-  
+
 
   return `/api/v2-beta/uploads/${uploadId}/cancel`
 }
 
-export const cancelDatasetUpload = async (uploadId: UploadId, options?: RequestInit): Promise<void> => {
-  
+export const cancelDatasetUpload = async (uploadId: UploadId, options?: Parameters<typeof potatoFetch>[1]): Promise<void> => {
+
   return potatoFetch<void>(getCancelDatasetUploadUrl(uploadId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -1235,19 +1418,19 @@ export const cancelDatasetUpload = async (uploadId: UploadId, options?: RequestI
 export const getGetDatasetUploadUrl = (uploadId: UploadId,) => {
 
 
-  
+
 
   return `/api/v2-beta/uploads/${uploadId}`
 }
 
-export const getDatasetUpload = async (uploadId: UploadId, options?: RequestInit): Promise<UploadJob> => {
-  
+export const getDatasetUpload = async (uploadId: UploadId, options?: Parameters<typeof potatoFetch>[1]): Promise<UploadJob> => {
+
   return potatoFetch<UploadJob>(getGetDatasetUploadUrl(uploadId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1256,21 +1439,34 @@ export const getDatasetUpload = async (uploadId: UploadId, options?: RequestInit
 export const getImportPipelineUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/pipelines/import`
 }
 
 export const importPipeline = async (projectId: ProjectId,
-    importPipelineBody: ImportPipelineBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getImportPipelineUrl(projectId),
-  {      
+    importPipelineBody: ImportPipelineBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Pipeline> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Pipeline>(getImportPipelineUrl(projectId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      importPipelineBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(importPipelineBody)
   }
 );}
 
@@ -1279,21 +1475,34 @@ export const importPipeline = async (projectId: ProjectId,
 export const getAttachPipelineDatasetUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/dataset`
 }
 
 export const attachPipelineDataset = async (pipelineId: PipelineId,
-    attachPipelineDatasetBody: AttachPipelineDatasetBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getAttachPipelineDatasetUrl(pipelineId),
-  {      
+    attachPipelineDatasetBody: AttachPipelineDatasetBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Pipeline> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Pipeline>(getAttachPipelineDatasetUrl(pipelineId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      attachPipelineDatasetBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(attachPipelineDatasetBody)
   }
 );}
 
@@ -1302,19 +1511,19 @@ export const attachPipelineDataset = async (pipelineId: PipelineId,
 export const getExportPipelineUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/export`
 }
 
-export const exportPipeline = async (pipelineId: PipelineId, options?: RequestInit): Promise<ExportPipeline200> => {
-  
+export const exportPipeline = async (pipelineId: PipelineId, options?: Parameters<typeof potatoFetch>[1]): Promise<ExportPipeline200> => {
+
   return potatoFetch<ExportPipeline200>(getExportPipelineUrl(pipelineId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1323,21 +1532,34 @@ export const exportPipeline = async (pipelineId: PipelineId, options?: RequestIn
 export const getCopyPipelineUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/copy`
 }
 
 export const copyPipeline = async (pipelineId: PipelineId,
-    copyPipelineBody: CopyPipelineBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getCopyPipelineUrl(pipelineId),
-  {      
+    copyPipelineBody: CopyPipelineBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Pipeline> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Pipeline>(getCopyPipelineUrl(pipelineId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      copyPipelineBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(copyPipelineBody)
   }
 );}
 
@@ -1346,21 +1568,34 @@ export const copyPipeline = async (pipelineId: PipelineId,
 export const getEstimatePipelineCostUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/cost-estimate`
 }
 
 export const estimatePipelineCost = async (pipelineId: PipelineId,
-    estimatePipelineCostBody: EstimatePipelineCostBody, options?: RequestInit): Promise<PipelineCostEstimate> => {
-  
-  return potatoFetch<PipelineCostEstimate>(getEstimatePipelineCostUrl(pipelineId),
-  {      
+    estimatePipelineCostBody: EstimatePipelineCostBody, options?: Parameters<typeof potatoFetch>[1]): Promise<PipelineCostEstimate> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<PipelineCostEstimate>(getEstimatePipelineCostUrl(pipelineId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      estimatePipelineCostBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(estimatePipelineCostBody)
   }
 );}
 
@@ -1369,19 +1604,19 @@ export const estimatePipelineCost = async (pipelineId: PipelineId,
 export const getCreatePipelineRunUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/runs`
 }
 
-export const createPipelineRun = async (pipelineId: PipelineId, options?: RequestInit): Promise<RunJob> => {
-  
+export const createPipelineRun = async (pipelineId: PipelineId, options?: Parameters<typeof potatoFetch>[1]): Promise<RunJob> => {
+
   return potatoFetch<RunJob>(getCreatePipelineRunUrl(pipelineId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -1392,9 +1627,9 @@ export const getListPipelineRunsUrl = (pipelineId: PipelineId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -1404,14 +1639,14 @@ export const getListPipelineRunsUrl = (pipelineId: PipelineId,
 }
 
 export const listPipelineRuns = async (pipelineId: PipelineId,
-    params?: ListPipelineRunsParams, options?: RequestInit): Promise<ListPipelineRuns200> => {
-  
+    params?: ListPipelineRunsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListPipelineRuns200> => {
+
   return potatoFetch<ListPipelineRuns200>(getListPipelineRunsUrl(pipelineId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1420,19 +1655,19 @@ export const listPipelineRuns = async (pipelineId: PipelineId,
 export const getGetPipelineRunUrl = (runId: RunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/runs/${runId}`
 }
 
-export const getPipelineRun = async (runId: RunId, options?: RequestInit): Promise<RunJob> => {
-  
+export const getPipelineRun = async (runId: RunId, options?: Parameters<typeof potatoFetch>[1]): Promise<RunJob> => {
+
   return potatoFetch<RunJob>(getGetPipelineRunUrl(runId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1441,19 +1676,19 @@ export const getPipelineRun = async (runId: RunId, options?: RequestInit): Promi
 export const getGetPipelineRunCostUrl = (runId: RunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/runs/${runId}/cost`
 }
 
-export const getPipelineRunCost = async (runId: RunId, options?: RequestInit): Promise<RunCost> => {
-  
+export const getPipelineRunCost = async (runId: RunId, options?: Parameters<typeof potatoFetch>[1]): Promise<RunCost> => {
+
   return potatoFetch<RunCost>(getGetPipelineRunCostUrl(runId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1462,19 +1697,19 @@ export const getPipelineRunCost = async (runId: RunId, options?: RequestInit): P
 export const getCancelPipelineRunUrl = (runId: RunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/runs/${runId}/cancel`
 }
 
-export const cancelPipelineRun = async (runId: RunId, options?: RequestInit): Promise<RunJob> => {
-  
+export const cancelPipelineRun = async (runId: RunId, options?: Parameters<typeof potatoFetch>[1]): Promise<RunJob> => {
+
   return potatoFetch<RunJob>(getCancelPipelineRunUrl(runId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -1483,21 +1718,34 @@ export const cancelPipelineRun = async (runId: RunId, options?: RequestInit): Pr
 export const getSampleDatasetItemsUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/sample`
 }
 
 export const sampleDatasetItems = async (datasetId: DatasetId,
-    sampleDatasetItemsBody: SampleDatasetItemsBody, options?: RequestInit): Promise<SampleResult> => {
-  
-  return potatoFetch<SampleResult>(getSampleDatasetItemsUrl(datasetId),
-  {      
+    sampleDatasetItemsBody: SampleDatasetItemsBody, options?: Parameters<typeof potatoFetch>[1]): Promise<SampleResult> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<SampleResult>(getSampleDatasetItemsUrl(datasetId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      sampleDatasetItemsBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(sampleDatasetItemsBody)
   }
 );}
 
@@ -1506,19 +1754,19 @@ export const sampleDatasetItems = async (datasetId: DatasetId,
 export const getGetDatasetSampleUrl = (sampleId: string,) => {
 
 
-  
+
 
   return `/api/v2-beta/samples/${sampleId}`
 }
 
-export const getDatasetSample = async (sampleId: string, options?: RequestInit): Promise<SampleJob> => {
-  
+export const getDatasetSample = async (sampleId: string, options?: Parameters<typeof potatoFetch>[1]): Promise<SampleJob> => {
+
   return potatoFetch<SampleJob>(getGetDatasetSampleUrl(sampleId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1527,21 +1775,34 @@ export const getDatasetSample = async (sampleId: string, options?: RequestInit):
 export const getCreateDatasetSliceUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/slices`
 }
 
 export const createDatasetSlice = async (datasetId: DatasetId,
-    createDatasetSliceBody: CreateDatasetSliceBody, options?: RequestInit): Promise<DatasetSlice> => {
-  
-  return potatoFetch<DatasetSlice>(getCreateDatasetSliceUrl(datasetId),
-  {      
+    createDatasetSliceBody: CreateDatasetSliceBody, options?: Parameters<typeof potatoFetch>[1]): Promise<DatasetSlice> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<DatasetSlice>(getCreateDatasetSliceUrl(datasetId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createDatasetSliceBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createDatasetSliceBody)
   }
 );}
 
@@ -1552,9 +1813,9 @@ export const getListDatasetSlicesUrl = (datasetId: DatasetId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -1564,14 +1825,14 @@ export const getListDatasetSlicesUrl = (datasetId: DatasetId,
 }
 
 export const listDatasetSlices = async (datasetId: DatasetId,
-    params?: ListDatasetSlicesParams, options?: RequestInit): Promise<ListDatasetSlices200> => {
-  
+    params?: ListDatasetSlicesParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListDatasetSlices200> => {
+
   return potatoFetch<ListDatasetSlices200>(getListDatasetSlicesUrl(datasetId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1580,19 +1841,19 @@ export const listDatasetSlices = async (datasetId: DatasetId,
 export const getGetDatasetSliceUrl = (sliceId: string,) => {
 
 
-  
+
 
   return `/api/v2-beta/slices/${sliceId}`
 }
 
-export const getDatasetSlice = async (sliceId: string, options?: RequestInit): Promise<DatasetSlice> => {
-  
+export const getDatasetSlice = async (sliceId: string, options?: Parameters<typeof potatoFetch>[1]): Promise<DatasetSlice> => {
+
   return potatoFetch<DatasetSlice>(getGetDatasetSliceUrl(sliceId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1601,21 +1862,34 @@ export const getDatasetSlice = async (sliceId: string, options?: RequestInit): P
 export const getSplitDatasetUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/split`
 }
 
 export const splitDataset = async (datasetId: DatasetId,
-    splitDatasetBody: SplitDatasetBody, options?: RequestInit): Promise<DatasetField> => {
-  
-  return potatoFetch<DatasetField>(getSplitDatasetUrl(datasetId),
-  {      
+    splitDatasetBody: SplitDatasetBody, options?: Parameters<typeof potatoFetch>[1]): Promise<DatasetField> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<DatasetField>(getSplitDatasetUrl(datasetId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      splitDatasetBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(splitDatasetBody)
   }
 );}
 
@@ -1624,21 +1898,34 @@ export const splitDataset = async (datasetId: DatasetId,
 export const getCreateDatasetExportUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/exports`
 }
 
 export const createDatasetExport = async (datasetId: DatasetId,
-    createDatasetExportBody: CreateDatasetExportBody, options?: RequestInit): Promise<ExportJob> => {
-  
-  return potatoFetch<ExportJob>(getCreateDatasetExportUrl(datasetId),
-  {      
+    createDatasetExportBody: CreateDatasetExportBody, options?: Parameters<typeof potatoFetch>[1]): Promise<ExportJob> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<ExportJob>(getCreateDatasetExportUrl(datasetId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createDatasetExportBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createDatasetExportBody)
   }
 );}
 
@@ -1647,19 +1934,19 @@ export const createDatasetExport = async (datasetId: DatasetId,
 export const getGetDatasetExportUrl = (exportId: ExportId,) => {
 
 
-  
+
 
   return `/api/v2-beta/exports/${exportId}`
 }
 
-export const getDatasetExport = async (exportId: ExportId, options?: RequestInit): Promise<ExportJob> => {
-  
+export const getDatasetExport = async (exportId: ExportId, options?: Parameters<typeof potatoFetch>[1]): Promise<ExportJob> => {
+
   return potatoFetch<ExportJob>(getGetDatasetExportUrl(exportId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1668,21 +1955,34 @@ export const getDatasetExport = async (exportId: ExportId, options?: RequestInit
 export const getCreateDatasetFieldsFromUploadedRowsUrl = (datasetId: DatasetId,) => {
 
 
-  
+
 
   return `/api/v2-beta/datasets/${datasetId}/fields/from-uploaded`
 }
 
 export const createDatasetFieldsFromUploadedRows = async (datasetId: DatasetId,
-    createDatasetFieldsFromUploadedRowsBody: CreateDatasetFieldsFromUploadedRowsBody, options?: RequestInit): Promise<CreatedDatasetFields> => {
-  
-  return potatoFetch<CreatedDatasetFields>(getCreateDatasetFieldsFromUploadedRowsUrl(datasetId),
-  {      
+    createDatasetFieldsFromUploadedRowsBody: CreateDatasetFieldsFromUploadedRowsBody, options?: Parameters<typeof potatoFetch>[1]): Promise<CreatedDatasetFields> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<CreatedDatasetFields>(getCreateDatasetFieldsFromUploadedRowsUrl(datasetId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createDatasetFieldsFromUploadedRowsBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createDatasetFieldsFromUploadedRowsBody)
   }
 );}
 
@@ -1691,19 +1991,19 @@ export const createDatasetFieldsFromUploadedRows = async (datasetId: DatasetId,
 export const getGetPipelineGraphSnapshotUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/graph`
 }
 
-export const getPipelineGraphSnapshot = async (pipelineId: PipelineId, options?: RequestInit): Promise<PipelineGraphSnapshot> => {
-  
+export const getPipelineGraphSnapshot = async (pipelineId: PipelineId, options?: Parameters<typeof potatoFetch>[1]): Promise<PipelineGraphSnapshot> => {
+
   return potatoFetch<PipelineGraphSnapshot>(getGetPipelineGraphSnapshotUrl(pipelineId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1712,21 +2012,34 @@ export const getPipelineGraphSnapshot = async (pipelineId: PipelineId, options?:
 export const getReplacePipelineGraphUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/graph`
 }
 
 export const replacePipelineGraph = async (pipelineId: PipelineId,
-    replacePipelineGraphBody: ReplacePipelineGraphBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getReplacePipelineGraphUrl(pipelineId),
-  {      
+    replacePipelineGraphBody: ReplacePipelineGraphBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Pipeline> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Pipeline>(getReplacePipelineGraphUrl(pipelineId),
+  {
     ...options,
     method: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      replacePipelineGraphBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(replacePipelineGraphBody)
   }
 );}
 
@@ -1735,21 +2048,34 @@ export const replacePipelineGraph = async (pipelineId: PipelineId,
 export const getValidatePipelineGraphUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/graph/validate`
 }
 
 export const validatePipelineGraph = async (pipelineId: PipelineId,
-    validatePipelineGraphBody: ValidatePipelineGraphBody, options?: RequestInit): Promise<PipelineValidationReport> => {
-  
-  return potatoFetch<PipelineValidationReport>(getValidatePipelineGraphUrl(pipelineId),
-  {      
+    validatePipelineGraphBody: ValidatePipelineGraphBody, options?: Parameters<typeof potatoFetch>[1]): Promise<PipelineValidationReport> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<PipelineValidationReport>(getValidatePipelineGraphUrl(pipelineId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      validatePipelineGraphBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(validatePipelineGraphBody)
   }
 );}
 
@@ -1759,22 +2085,35 @@ export const getPatchPipelineNodeUrl = (pipelineId: PipelineId,
     nodeId: string,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/graph/nodes/${nodeId}`
 }
 
 export const patchPipelineNode = async (pipelineId: PipelineId,
     nodeId: string,
-    patchPipelineNodeBody: PatchPipelineNodeBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getPatchPipelineNodeUrl(pipelineId,nodeId),
-  {      
+    patchPipelineNodeBody: PatchPipelineNodeBody, options?: Parameters<typeof potatoFetch>[1]): Promise<Pipeline> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<Pipeline>(getPatchPipelineNodeUrl(pipelineId,nodeId),
+  {
     ...options,
     method: 'PATCH',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      patchPipelineNodeBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(patchPipelineNodeBody)
   }
 );}
 
@@ -1783,21 +2122,34 @@ export const patchPipelineNode = async (pipelineId: PipelineId,
 export const getCreateProjectTokenUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/tokens`
 }
 
 export const createProjectToken = async (projectId: ProjectId,
-    createScopedTokenBody: CreateScopedTokenBody, options?: RequestInit): Promise<ScopedToken> => {
-  
-  return potatoFetch<ScopedToken>(getCreateProjectTokenUrl(projectId),
-  {      
+    createScopedTokenBody: CreateScopedTokenBody, options?: Parameters<typeof potatoFetch>[1]): Promise<ScopedToken> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<ScopedToken>(getCreateProjectTokenUrl(projectId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createScopedTokenBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createScopedTokenBody)
   }
 );}
 
@@ -1808,9 +2160,9 @@ export const getListProjectTokensUrl = (projectId: ProjectId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -1820,14 +2172,14 @@ export const getListProjectTokensUrl = (projectId: ProjectId,
 }
 
 export const listProjectTokens = async (projectId: ProjectId,
-    params?: ListProjectTokensParams, options?: RequestInit): Promise<ListProjectTokens200> => {
-  
+    params?: ListProjectTokensParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListProjectTokens200> => {
+
   return potatoFetch<ListProjectTokens200>(getListProjectTokensUrl(projectId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1836,19 +2188,19 @@ export const listProjectTokens = async (projectId: ProjectId,
 export const getRevokeProjectTokensUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/tokens`
 }
 
-export const revokeProjectTokens = async (projectId: ProjectId, options?: RequestInit): Promise<RevokedScopedTokens> => {
-  
+export const revokeProjectTokens = async (projectId: ProjectId, options?: Parameters<typeof potatoFetch>[1]): Promise<RevokedScopedTokens> => {
+
   return potatoFetch<RevokedScopedTokens>(getRevokeProjectTokensUrl(projectId),
-  {      
+  {
     ...options,
     method: 'DELETE'
-    
-    
+
+
   }
 );}
 
@@ -1858,20 +2210,20 @@ export const getRevokeProjectTokenUrl = (projectId: ProjectId,
     tokenId: string,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/tokens/${tokenId}`
 }
 
 export const revokeProjectToken = async (projectId: ProjectId,
-    tokenId: string, options?: RequestInit): Promise<void> => {
-  
+    tokenId: string, options?: Parameters<typeof potatoFetch>[1]): Promise<void> => {
+
   return potatoFetch<void>(getRevokeProjectTokenUrl(projectId,tokenId),
-  {      
+  {
     ...options,
     method: 'DELETE'
-    
-    
+
+
   }
 );}
 
@@ -1880,19 +2232,19 @@ export const revokeProjectToken = async (projectId: ProjectId,
 export const getRevokeCurrentTokenUrl = () => {
 
 
-  
+
 
   return `/api/v2-beta/tokens/current`
 }
 
-export const revokeCurrentToken = async ( options?: RequestInit): Promise<void> => {
-  
+export const revokeCurrentToken = async ( options?: Parameters<typeof potatoFetch>[1]): Promise<void> => {
+
   return potatoFetch<void>(getRevokeCurrentTokenUrl(),
-  {      
+  {
     ...options,
     method: 'DELETE'
-    
-    
+
+
   }
 );}
 
@@ -1901,19 +2253,19 @@ export const revokeCurrentToken = async ( options?: RequestInit): Promise<void>
 export const getListProjectSecretsUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/secrets`
 }
 
-export const listProjectSecrets = async (projectId: ProjectId, options?: RequestInit): Promise<ListProjectSecrets200> => {
-  
+export const listProjectSecrets = async (projectId: ProjectId, options?: Parameters<typeof potatoFetch>[1]): Promise<ListProjectSecrets200> => {
+
   return potatoFetch<ListProjectSecrets200>(getListProjectSecretsUrl(projectId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1923,22 +2275,35 @@ export const getSetProjectSecretUrl = (projectId: ProjectId,
     name: ProjectSecretName,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/secrets/${name}`
 }
 
 export const setProjectSecret = async (projectId: ProjectId,
     name: ProjectSecretName,
-    setProjectSecretBody: SetProjectSecretBody, options?: RequestInit): Promise<ProjectSecret> => {
-  
-  return potatoFetch<ProjectSecret>(getSetProjectSecretUrl(projectId,name),
-  {      
+    setProjectSecretBody: SetProjectSecretBody, options?: Parameters<typeof potatoFetch>[1]): Promise<ProjectSecret> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<ProjectSecret>(getSetProjectSecretUrl(projectId,name),
+  {
     ...options,
     method: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      setProjectSecretBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(setProjectSecretBody)
   }
 );}
 
@@ -1947,19 +2312,19 @@ export const setProjectSecret = async (projectId: ProjectId,
 export const getListProjectFilesUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/files`
 }
 
-export const listProjectFiles = async (projectId: ProjectId, options?: RequestInit): Promise<ListProjectFiles200> => {
-  
+export const listProjectFiles = async (projectId: ProjectId, options?: Parameters<typeof potatoFetch>[1]): Promise<ListProjectFiles200> => {
+
   return potatoFetch<ListProjectFiles200>(getListProjectFilesUrl(projectId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -1968,21 +2333,34 @@ export const listProjectFiles = async (projectId: ProjectId, options?: RequestIn
 export const getCreateProjectFileUploadUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/files`
 }
 
 export const createProjectFileUpload = async (projectId: ProjectId,
-    createProjectFileUploadBody: CreateProjectFileUploadBody, options?: RequestInit): Promise<CreateProjectFileUpload200> => {
-  
-  return potatoFetch<CreateProjectFileUpload200>(getCreateProjectFileUploadUrl(projectId),
-  {      
+    createProjectFileUploadBody: CreateProjectFileUploadBody, options?: Parameters<typeof potatoFetch>[1]): Promise<CreateProjectFileUpload200> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<CreateProjectFileUpload200>(getCreateProjectFileUploadUrl(projectId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createProjectFileUploadBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createProjectFileUploadBody)
   }
 );}
 
@@ -1992,20 +2370,20 @@ export const getFinalizeProjectFileUploadUrl = (projectId: ProjectId,
     fileId: ProjectFileId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/files/${fileId}/finalize`
 }
 
 export const finalizeProjectFileUpload = async (projectId: ProjectId,
-    fileId: ProjectFileId, options?: RequestInit): Promise<ProjectFile> => {
-  
+    fileId: ProjectFileId, options?: Parameters<typeof potatoFetch>[1]): Promise<ProjectFile> => {
+
   return potatoFetch<ProjectFile>(getFinalizeProjectFileUploadUrl(projectId,fileId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -2015,20 +2393,20 @@ export const getDeleteProjectFileUrl = (projectId: ProjectId,
     fileId: ProjectFileId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/files/${fileId}`
 }
 
 export const deleteProjectFile = async (projectId: ProjectId,
-    fileId: ProjectFileId, options?: RequestInit): Promise<void> => {
-  
+    fileId: ProjectFileId, options?: Parameters<typeof potatoFetch>[1]): Promise<void> => {
+
   return potatoFetch<void>(getDeleteProjectFileUrl(projectId,fileId),
-  {      
+  {
     ...options,
     method: 'DELETE'
-    
-    
+
+
   }
 );}
 
@@ -2039,9 +2417,9 @@ export const getListPipelineRunItemsUrl = (runId: RunId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -2051,14 +2429,14 @@ export const getListPipelineRunItemsUrl = (runId: RunId,
 }
 
 export const listPipelineRunItems = async (runId: RunId,
-    params?: ListPipelineRunItemsParams, options?: RequestInit): Promise<ListPipelineRunItems200> => {
-  
+    params?: ListPipelineRunItemsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListPipelineRunItems200> => {
+
   return potatoFetch<ListPipelineRunItems200>(getListPipelineRunItemsUrl(runId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -2068,20 +2446,20 @@ export const getGetPipelineRunItemUrl = (runId: RunId,
     itemId: RunItemId,) => {
 
 
-  
+
 
   return `/api/v2-beta/runs/${runId}/items/${itemId}`
 }
 
 export const getPipelineRunItem = async (runId: RunId,
-    itemId: RunItemId, options?: RequestInit): Promise<RunItem> => {
-  
+    itemId: RunItemId, options?: Parameters<typeof potatoFetch>[1]): Promise<RunItem> => {
+
   return potatoFetch<RunItem>(getGetPipelineRunItemUrl(runId,itemId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -2090,19 +2468,19 @@ export const getPipelineRunItem = async (runId: RunId,
 export const getListPipelineChecksUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/checks`
 }
 
-export const listPipelineChecks = async (pipelineId: PipelineId, options?: RequestInit): Promise<ListPipelineChecks200> => {
-  
+export const listPipelineChecks = async (pipelineId: PipelineId, options?: Parameters<typeof potatoFetch>[1]): Promise<ListPipelineChecks200> => {
+
   return potatoFetch<ListPipelineChecks200>(getListPipelineChecksUrl(pipelineId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -2111,21 +2489,55 @@ export const listPipelineChecks = async (pipelineId: PipelineId, options?: Reque
 export const getCreatePipelineCheckUrl = (pipelineId: PipelineId,) => {
 
 
-  
+
 
   return `/api/v2-beta/pipelines/${pipelineId}/checks`
 }
 
 export const createPipelineCheck = async (pipelineId: PipelineId,
-    createPipelineCheckBody: CreatePipelineCheckBody, options?: RequestInit): Promise<CheckJob> => {
-  
-  return potatoFetch<CheckJob>(getCreatePipelineCheckUrl(pipelineId),
-  {      
+    createPipelineCheckBody: CreatePipelineCheckBody, options?: Parameters<typeof potatoFetch>[1]): Promise<CheckJob> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<CheckJob>(getCreatePipelineCheckUrl(pipelineId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createPipelineCheckBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createPipelineCheckBody)
+  }
+);}
+
+
+
+export const getRunPipelineLintsUrl = (pipelineId: PipelineId,) => {
+
+
+
+
+  return `/api/v2-beta/pipelines/${pipelineId}/lints`
+}
+
+export const runPipelineLints = async (pipelineId: PipelineId, options?: Parameters<typeof potatoFetch>[1]): Promise<RunLintsResult> => {
+
+  return potatoFetch<RunLintsResult>(getRunPipelineLintsUrl(pipelineId),
+  {
+    ...options,
+    method: 'POST'
+
+
   }
 );}
 
@@ -2134,19 +2546,19 @@ export const createPipelineCheck = async (pipelineId: PipelineId,
 export const getGetPipelineCheckUrl = (checkRunId: CheckRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/checks/${checkRunId}`
 }
 
-export const getPipelineCheck = async (checkRunId: CheckRunId, options?: RequestInit): Promise<CheckJob> => {
-  
+export const getPipelineCheck = async (checkRunId: CheckRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<CheckJob> => {
+
   return potatoFetch<CheckJob>(getGetPipelineCheckUrl(checkRunId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -2155,21 +2567,34 @@ export const getPipelineCheck = async (checkRunId: CheckRunId, options?: Request
 export const getCreateBatchInferenceRunUrl = (projectId: ProjectId,) => {
 
 
-  
+
 
   return `/api/v2-beta/projects/${projectId}/batch-inference-runs`
 }
 
 export const createBatchInferenceRun = async (projectId: ProjectId,
-    createBatchInferenceRunBody: CreateBatchInferenceRunBody, options?: RequestInit): Promise<BatchInferenceRun> => {
-  
-  return potatoFetch<BatchInferenceRun>(getCreateBatchInferenceRunUrl(projectId),
-  {      
+    createBatchInferenceRunBody: CreateBatchInferenceRunBody, options?: Parameters<typeof potatoFetch>[1]): Promise<BatchInferenceRun> => {
+
+    const getHeaders = (h?: NonNullable<RequestInit['headers']>): Record<string, string | readonly string[]> => {
+    if (!h) return {};
+    if (h instanceof Headers) return Object.fromEntries(h.entries());
+    if (Symbol.iterator in h) {
+      return Object.fromEntries(
+        Array.from(h as Iterable<Iterable<string>>, (entry) => Array.from(entry) as [string, string]),
+      );
+    }
+    const headers: Record<string, string | readonly string[]> = {};
+    for (const [name, value] of Object.entries<string | readonly string[] | undefined>(h)) {
+      if (value !== undefined) headers[name] = value;
+    }
+    return headers;
+  };
+return potatoFetch<BatchInferenceRun>(getCreateBatchInferenceRunUrl(projectId),
+  {
     ...options,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createBatchInferenceRunBody,)
+    headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
+    body: JSON.stringify(createBatchInferenceRunBody)
   }
 );}
 
@@ -2180,9 +2605,9 @@ export const getListBatchInferenceRunsUrl = (projectId: ProjectId,
   const normalizedParams = new URLSearchParams();
 
   Object.entries(params || {}).forEach(([key, value]) => {
-    
+
     if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
+      normalizedParams.append(key, value === null ? 'null' : String(value))
     }
   });
 
@@ -2192,14 +2617,14 @@ export const getListBatchInferenceRunsUrl = (projectId: ProjectId,
 }
 
 export const listBatchInferenceRuns = async (projectId: ProjectId,
-    params?: ListBatchInferenceRunsParams, options?: RequestInit): Promise<ListBatchInferenceRuns200> => {
-  
+    params?: ListBatchInferenceRunsParams, options?: Parameters<typeof potatoFetch>[1]): Promise<ListBatchInferenceRuns200> => {
+
   return potatoFetch<ListBatchInferenceRuns200>(getListBatchInferenceRunsUrl(projectId,params),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -2208,19 +2633,19 @@ export const listBatchInferenceRuns = async (projectId: ProjectId,
 export const getGetBatchInferenceRunUrl = (batchInferenceRunId: BatchInferenceRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/batch-inference-runs/${batchInferenceRunId}`
 }
 
-export const getBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRunId, options?: RequestInit): Promise<BatchInferenceRun> => {
-  
+export const getBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<BatchInferenceRun> => {
+
   return potatoFetch<BatchInferenceRun>(getGetBatchInferenceRunUrl(batchInferenceRunId),
-  {      
+  {
     ...options,
     method: 'GET'
-    
-    
+
+
   }
 );}
 
@@ -2229,19 +2654,19 @@ export const getBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRu
 export const getConfirmBatchInferenceRunUrl = (batchInferenceRunId: BatchInferenceRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/batch-inference-runs/${batchInferenceRunId}/confirm`
 }
 
-export const confirmBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRunId, options?: RequestInit): Promise<BatchInferenceRun> => {
-  
+export const confirmBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<BatchInferenceRun> => {
+
   return potatoFetch<BatchInferenceRun>(getConfirmBatchInferenceRunUrl(batchInferenceRunId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -2250,19 +2675,19 @@ export const confirmBatchInferenceRun = async (batchInferenceRunId: BatchInferen
 export const getResumeBatchInferenceRunUrl = (batchInferenceRunId: BatchInferenceRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/batch-inference-runs/${batchInferenceRunId}/resume`
 }
 
-export const resumeBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRunId, options?: RequestInit): Promise<BatchInferenceRun> => {
-  
+export const resumeBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<BatchInferenceRun> => {
+
   return potatoFetch<BatchInferenceRun>(getResumeBatchInferenceRunUrl(batchInferenceRunId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
 
@@ -2271,18 +2696,21 @@ export const resumeBatchInferenceRun = async (batchInferenceRunId: BatchInferenc
 export const getCancelBatchInferenceRunUrl = (batchInferenceRunId: BatchInferenceRunId,) => {
 
 
-  
+
 
   return `/api/v2-beta/batch-inference-runs/${batchInferenceRunId}/cancel`
 }
 
-export const cancelBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRunId, options?: RequestInit): Promise<BatchInferenceRun> => {
-  
+export const cancelBatchInferenceRun = async (batchInferenceRunId: BatchInferenceRunId, options?: Parameters<typeof potatoFetch>[1]): Promise<BatchInferenceRun> => {
+
   return potatoFetch<BatchInferenceRun>(getCancelBatchInferenceRunUrl(batchInferenceRunId),
-  {      
+  {
     ...options,
     method: 'POST'
-    
-    
+
+
   }
 );}
+
+
+