@toloka-platform/sdk 0.1.0 → 0.2.0-preview.2

package/openapi/gen/api.ts

@@ -18,14 +18,18 @@ import type {
   CreateProjectFileUpload200,
   CreateProjectFileUploadBody,
   CreateProjectModelBody,
+  CreateProjectTrainingBody,
+  CreateTrainingRunBody,
   CurrentUser,
   Dataset,
   DatasetId,
   EstimatePipelineCostBody,
+  EstimateTrainingCostBody,
   ExportId,
   ExportJob,
   ExportPipeline200,
   GetDatasetInferredFields200,
+  GetTrainingRunLogsParams,
   ImportPipelineBody,
   ListBaseModels200,
   ListDatasetFields200,
@@ -47,11 +51,16 @@ import type {
   ListProjectPipelines200,
   ListProjectPipelinesParams,
   ListProjectSecrets200,
+  ListProjectTrainings200,
+  ListProjectTrainingsParams,
   ListProjects200,
   ListProjectsParams,
+  ListTrainingRuns200,
+  ListTrainingRunsParams,
   Model,
   ModelId,
   ModelVersion,
+  ModelVersionContentDownload,
   ModelVersionId,
   PatchPipelineNodeBody,
   Pipeline,
@@ -59,6 +68,7 @@ import type {
   PipelineGraphSnapshot,
   PipelineId,
   PipelineValidationReport,
+  PrepareTrainingCostEstimateInputsBody,
   Project,
   ProjectFile,
   ProjectFileId,
@@ -66,6 +76,7 @@ import type {
   ProjectSecret,
   ProjectSecretName,
   ReplacePipelineGraphBody,
+  ReplaceTrainingConfigurationBody,
   RunCost,
   RunId,
   RunItem,
@@ -75,986 +86,1680 @@ import type {
   SampleJob,
   SampleResult,
   SetProjectSecretBody,
+  Training,
+  TrainingCostEstimate,
+  TrainingCostEstimateInputSet,
+  TrainingId,
+  TrainingRun,
+  TrainingRunId,
+  TrainingRunLogs,
   UpdatePipelineBody,
   UpdateProjectBody,
+  UpdateTrainingMetadataBody,
   UploadId,
   UploadJob,
-  ValidatePipelineGraphBody,
-} from "./models";
+  ValidatePipelineGraphBody
+} from './models';
 
-import { potatoFetch } from "../../src/transport";
+import { potatoFetch } from '../../src/transport';
 export const getListBaseModelsUrl = () => {
-  return `/api/v2-beta/base-models`;
-};
 
-export const listBaseModels = async (options?: RequestInit): Promise<ListBaseModels200> => {
-  return potatoFetch<ListBaseModels200>(getListBaseModelsUrl(), {
+
+  
+
+  return `/api/v2-beta/base-models`
+}
+
+export const listBaseModels = async ( options?: RequestInit): Promise<ListBaseModels200> => {
+  
+  return potatoFetch<ListBaseModels200>(getListBaseModelsUrl(),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetBaseModelUrl = (baseModelId: BaseModelId,) => {
+
 
-export const getGetBaseModelUrl = (baseModelId: BaseModelId) => {
-  return `/api/v2-beta/base-models/${baseModelId}`;
-};
+  
 
-export const getBaseModel = async (
-  baseModelId: BaseModelId,
-  options?: RequestInit,
-): Promise<BaseModel> => {
-  return potatoFetch<BaseModel>(getGetBaseModelUrl(baseModelId), {
+  return `/api/v2-beta/base-models/${baseModelId}`
+}
+
+export const getBaseModel = async (baseModelId: BaseModelId, options?: RequestInit): Promise<BaseModel> => {
+  
+  return potatoFetch<BaseModel>(getGetBaseModelUrl(baseModelId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
-export const getListProjectModelsUrl = (projectId: ProjectId, params?: ListProjectModelsParams) => {
+export const getListProjectModelsUrl = (projectId: ProjectId,
+    params?: ListProjectModelsParams,) => {
   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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/projects/${projectId}/models?${stringifiedParams}`
-    : `/api/v2-beta/projects/${projectId}/models`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/projects/${projectId}/models?${stringifiedParams}` : `/api/v2-beta/projects/${projectId}/models`
+}
 
-export const listProjectModels = async (
-  projectId: ProjectId,
-  params?: ListProjectModelsParams,
-  options?: RequestInit,
-): Promise<ListProjectModels200> => {
-  return potatoFetch<ListProjectModels200>(getListProjectModelsUrl(projectId, params), {
+export const listProjectModels = async (projectId: ProjectId,
+    params?: ListProjectModelsParams, options?: RequestInit): Promise<ListProjectModels200> => {
+  
+  return potatoFetch<ListProjectModels200>(getListProjectModelsUrl(projectId,params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(createProjectModelBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
-export const getListModelVersionsUrl = (
-  projectId: ProjectId,
-  modelId: ModelId,
-  params?: ListModelVersionsParams,
-) => {
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createProjectModelBody,)
+  }
+);}
+
+
+
+export const getListModelVersionsUrl = (projectId: ProjectId,
+    modelId: ModelId,
+    params?: ListModelVersionsParams,) => {
   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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/projects/${projectId}/models/${modelId}/versions?${stringifiedParams}`
-    : `/api/v2-beta/projects/${projectId}/models/${modelId}/versions`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/projects/${projectId}/models/${modelId}/versions?${stringifiedParams}` : `/api/v2-beta/projects/${projectId}/models/${modelId}/versions`
+}
 
-export const listModelVersions = async (
-  projectId: ProjectId,
-  modelId: ModelId,
-  params?: ListModelVersionsParams,
-  options?: RequestInit,
-): Promise<ListModelVersions200> => {
-  return potatoFetch<ListModelVersions200>(getListModelVersionsUrl(projectId, modelId, params), {
+export const listModelVersions = async (projectId: ProjectId,
+    modelId: ModelId,
+    params?: ListModelVersionsParams, options?: RequestInit): Promise<ListModelVersions200> => {
+  
+  return potatoFetch<ListModelVersions200>(getListModelVersionsUrl(projectId,modelId,params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetModelVersionUrl = (modelVersionId: ModelVersionId,) => {
+
+
+  
+
+  return `/api/v2-beta/model-versions/${modelVersionId}`
+}
 
-export const getGetModelVersionUrl = (modelVersionId: ModelVersionId) => {
-  return `/api/v2-beta/model-versions/${modelVersionId}`;
-};
+export const getModelVersion = async (modelVersionId: ModelVersionId, options?: RequestInit): Promise<ModelVersion> => {
+  
+  return potatoFetch<ModelVersion>(getGetModelVersionUrl(modelVersionId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetModelVersionContentUrl = (modelVersionId: ModelVersionId,) => {
+
+
+  
+
+  return `/api/v2-beta/model-versions/${modelVersionId}/content`
+}
+
+export const getModelVersionContent = async (modelVersionId: ModelVersionId, options?: RequestInit): Promise<ModelVersionContentDownload> => {
+  
+  return potatoFetch<ModelVersionContentDownload>(getGetModelVersionContentUrl(modelVersionId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getArchiveProjectModelUrl = (projectId: ProjectId,
+    modelId: ModelId,) => {
 
-export const getModelVersion = async (
-  modelVersionId: ModelVersionId,
-  options?: RequestInit,
-): Promise<ModelVersion> => {
-  return potatoFetch<ModelVersion>(getGetModelVersionUrl(modelVersionId), {
+
+  
+
+  return `/api/v2-beta/projects/${projectId}/models/${modelId}/archive`
+}
+
+export const archiveProjectModel = async (projectId: ProjectId,
+    modelId: ModelId, options?: RequestInit): Promise<Model> => {
+  
+  return potatoFetch<Model>(getArchiveProjectModelUrl(projectId,modelId),
+  {      
     ...options,
-    method: "GET",
+    method: 'POST'
+    
+    
+  }
+);}
+
+
+
+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> => {
+  
+  return potatoFetch<Model>(getGetProjectModelUrl(projectId,modelId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getListProjectTrainingsUrl = (projectId: ProjectId,
+    params?: ListProjectTrainingsParams,) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? 'null' : value.toString())
+    }
   });
-};
 
-export const getArchiveProjectModelUrl = (projectId: ProjectId, modelId: ModelId) => {
-  return `/api/v2-beta/projects/${projectId}/models/${modelId}/archive`;
-};
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/api/v2-beta/projects/${projectId}/trainings?${stringifiedParams}` : `/api/v2-beta/projects/${projectId}/trainings`
+}
+
+export const listProjectTrainings = async (projectId: ProjectId,
+    params?: ListProjectTrainingsParams, options?: RequestInit): Promise<ListProjectTrainings200> => {
+  
+  return potatoFetch<ListProjectTrainings200>(getListProjectTrainingsUrl(projectId,params),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createProjectTrainingBody,)
+  }
+);}
+
+
+
+export const getGetTrainingUrl = (trainingId: TrainingId,) => {
+
+
+  
+
+  return `/api/v2-beta/trainings/${trainingId}`
+}
+
+export const getTraining = async (trainingId: TrainingId, options?: RequestInit): Promise<Training> => {
+  
+  return potatoFetch<Training>(getGetTrainingUrl(trainingId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      updateTrainingMetadataBody,)
+  }
+);}
+
+
+
+export const getReplaceTrainingConfigurationUrl = (trainingId: TrainingId,) => {
 
-export const archiveProjectModel = async (
-  projectId: ProjectId,
-  modelId: ModelId,
-  options?: RequestInit,
-): Promise<Model> => {
-  return potatoFetch<Model>(getArchiveProjectModelUrl(projectId, modelId), {
+
+  
+
+  return `/api/v2-beta/trainings/${trainingId}/configuration`
+}
+
+export const replaceTrainingConfiguration = async (trainingId: TrainingId,
+    replaceTrainingConfigurationBody: ReplaceTrainingConfigurationBody, options?: RequestInit): Promise<Training> => {
+  
+  return potatoFetch<Training>(getReplaceTrainingConfigurationUrl(trainingId),
+  {      
+    ...options,
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      replaceTrainingConfigurationBody,)
+  }
+);}
+
+
+
+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),
+  {      
     ...options,
-    method: "POST",
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      prepareTrainingCostEstimateInputsBody,)
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      estimateTrainingCostBody,)
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createTrainingRunBody,)
+  }
+);}
+
+
+
+export const getListTrainingRunsUrl = (trainingId: TrainingId,
+    params?: ListTrainingRunsParams,) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? 'null' : value.toString())
+    }
   });
-};
 
-export const getGetProjectModelUrl = (projectId: ProjectId, modelId: ModelId) => {
-  return `/api/v2-beta/projects/${projectId}/models/${modelId}`;
-};
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/api/v2-beta/trainings/${trainingId}/runs?${stringifiedParams}` : `/api/v2-beta/trainings/${trainingId}/runs`
+}
+
+export const listTrainingRuns = async (trainingId: TrainingId,
+    params?: ListTrainingRunsParams, options?: RequestInit): Promise<ListTrainingRuns200> => {
+  
+  return potatoFetch<ListTrainingRuns200>(getListTrainingRunsUrl(trainingId,params),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetTrainingRunUrl = (trainingRunId: TrainingRunId,) => {
+
 
-export const getProjectModel = async (
-  projectId: ProjectId,
-  modelId: ModelId,
-  options?: RequestInit,
-): Promise<Model> => {
-  return potatoFetch<Model>(getGetProjectModelUrl(projectId, modelId), {
+  
+
+  return `/api/v2-beta/training-runs/${trainingRunId}`
+}
+
+export const getTrainingRun = async (trainingRunId: TrainingRunId, options?: RequestInit): Promise<TrainingRun> => {
+  
+  return potatoFetch<TrainingRun>(getGetTrainingRunUrl(trainingRunId),
+  {      
     ...options,
-    method: "GET",
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetTrainingRunLogsUrl = (trainingRunId: TrainingRunId,
+    params?: GetTrainingRunLogsParams,) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? 'null' : value.toString())
+    }
   });
-};
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/api/v2-beta/training-runs/${trainingRunId}/logs?${stringifiedParams}` : `/api/v2-beta/training-runs/${trainingRunId}/logs`
+}
+
+export const getTrainingRunLogs = async (trainingRunId: TrainingRunId,
+    params?: GetTrainingRunLogsParams, options?: RequestInit): Promise<TrainingRunLogs> => {
+  
+  return potatoFetch<TrainingRunLogs>(getGetTrainingRunLogsUrl(trainingRunId,params),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getResumeTrainingRunUrl = (trainingRunId: TrainingRunId,) => {
+
+
+  
+
+  return `/api/v2-beta/training-runs/${trainingRunId}/resume`
+}
+
+export const resumeTrainingRun = async (trainingRunId: TrainingRunId, options?: RequestInit): Promise<TrainingRun> => {
+  
+  return potatoFetch<TrainingRun>(getResumeTrainingRunUrl(trainingRunId),
+  {      
+    ...options,
+    method: 'POST'
+    
+    
+  }
+);}
+
+
+
+export const getCancelTrainingRunUrl = (trainingRunId: TrainingRunId,) => {
+
+
+  
+
+  return `/api/v2-beta/training-runs/${trainingRunId}/cancel`
+}
+
+export const cancelTrainingRun = async (trainingRunId: TrainingRunId, options?: RequestInit): Promise<TrainingRun> => {
+  
+  return potatoFetch<TrainingRun>(getCancelTrainingRunUrl(trainingRunId),
+  {      
+    ...options,
+    method: 'POST'
+    
+    
+  }
+);}
+
+
 
 export const getGetCurrentUserUrl = () => {
-  return `/api/v2-beta/me`;
-};
 
-export const getCurrentUser = async (options?: RequestInit): Promise<CurrentUser> => {
-  return potatoFetch<CurrentUser>(getGetCurrentUserUrl(), {
+
+  
+
+  return `/api/v2-beta/me`
+}
+
+export const getCurrentUser = async ( options?: RequestInit): Promise<CurrentUser> => {
+  
+  return potatoFetch<CurrentUser>(getGetCurrentUserUrl(),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
-export const getListProjectsUrl = (params?: ListProjectsParams) => {
+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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/projects?${stringifiedParams}`
-    : `/api/v2-beta/projects`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/projects?${stringifiedParams}` : `/api/v2-beta/projects`
+}
 
-export const listProjects = async (
-  params?: ListProjectsParams,
-  options?: RequestInit,
-): Promise<ListProjects200> => {
-  return potatoFetch<ListProjects200>(getListProjectsUrl(params), {
+export const listProjects = async (params?: ListProjectsParams, options?: RequestInit): Promise<ListProjects200> => {
+  
+  return potatoFetch<ListProjects200>(getListProjectsUrl(params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
 export const getCreateProjectUrl = () => {
-  return `/api/v2-beta/projects`;
-};
-
-export const createProject = async (
-  createProjectBody: CreateProjectBody,
-  options?: RequestInit,
-): Promise<Project> => {
-  return potatoFetch<Project>(getCreateProjectUrl(), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(createProjectBody),
-  });
-};
 
-export const getGetProjectByIdUrl = (projectId: ProjectId) => {
-  return `/api/v2-beta/projects/${projectId}`;
-};
 
-export const getProjectById = async (
-  projectId: ProjectId,
-  options?: RequestInit,
-): Promise<Project> => {
-  return potatoFetch<Project>(getGetProjectByIdUrl(projectId), {
+  
+
+  return `/api/v2-beta/projects`
+}
+
+export const createProject = async (createProjectBody: CreateProjectBody, options?: RequestInit): Promise<Project> => {
+  
+  return potatoFetch<Project>(getCreateProjectUrl(),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "PATCH",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(updateProjectBody),
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createProjectBody,)
+  }
+);}
+
+
+
+export const getGetProjectByIdUrl = (projectId: ProjectId,) => {
 
-export const getListProjectPipelinesUrl = (
-  projectId: ProjectId,
-  params?: ListProjectPipelinesParams,
-) => {
+
+  
+
+  return `/api/v2-beta/projects/${projectId}`
+}
+
+export const getProjectById = async (projectId: ProjectId, options?: RequestInit): Promise<Project> => {
+  
+  return potatoFetch<Project>(getGetProjectByIdUrl(projectId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      updateProjectBody,)
+  }
+);}
+
+
+
+export const getListProjectPipelinesUrl = (projectId: ProjectId,
+    params?: ListProjectPipelinesParams,) => {
   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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/projects/${projectId}/pipelines?${stringifiedParams}`
-    : `/api/v2-beta/projects/${projectId}/pipelines`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/projects/${projectId}/pipelines?${stringifiedParams}` : `/api/v2-beta/projects/${projectId}/pipelines`
+}
 
-export const listProjectPipelines = async (
-  projectId: ProjectId,
-  params?: ListProjectPipelinesParams,
-  options?: RequestInit,
-): Promise<ListProjectPipelines200> => {
-  return potatoFetch<ListProjectPipelines200>(getListProjectPipelinesUrl(projectId, params), {
+export const listProjectPipelines = async (projectId: ProjectId,
+    params?: ListProjectPipelinesParams, options?: RequestInit): Promise<ListProjectPipelines200> => {
+  
+  return potatoFetch<ListProjectPipelines200>(getListProjectPipelinesUrl(projectId,params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
 
-export const getGetPipelineByIdUrl = (pipelineId: PipelineId) => {
-  return `/api/v2-beta/pipelines/${pipelineId}`;
-};
 
-export const getPipelineById = async (
-  pipelineId: PipelineId,
-  options?: RequestInit,
-): Promise<Pipeline> => {
-  return potatoFetch<Pipeline>(getGetPipelineByIdUrl(pipelineId), {
+
+export const getGetPipelineByIdUrl = (pipelineId: PipelineId,) => {
+
+
+  
+
+  return `/api/v2-beta/pipelines/${pipelineId}`
+}
+
+export const getPipelineById = async (pipelineId: PipelineId, options?: RequestInit): Promise<Pipeline> => {
+  
+  return potatoFetch<Pipeline>(getGetPipelineByIdUrl(pipelineId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "PATCH",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(updatePipelineBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      updatePipelineBody,)
+  }
+);}
 
-export const getListProjectDatasetsUrl = (
-  projectId: ProjectId,
-  params?: ListProjectDatasetsParams,
-) => {
+
+
+export const getListProjectDatasetsUrl = (projectId: ProjectId,
+    params?: ListProjectDatasetsParams,) => {
   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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/projects/${projectId}/datasets?${stringifiedParams}`
-    : `/api/v2-beta/projects/${projectId}/datasets`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/projects/${projectId}/datasets?${stringifiedParams}` : `/api/v2-beta/projects/${projectId}/datasets`
+}
 
-export const listProjectDatasets = async (
-  projectId: ProjectId,
-  params?: ListProjectDatasetsParams,
-  options?: RequestInit,
-): Promise<ListProjectDatasets200> => {
-  return potatoFetch<ListProjectDatasets200>(getListProjectDatasetsUrl(projectId, params), {
+export const listProjectDatasets = async (projectId: ProjectId,
+    params?: ListProjectDatasetsParams, options?: RequestInit): Promise<ListProjectDatasets200> => {
+  
+  return potatoFetch<ListProjectDatasets200>(getListProjectDatasetsUrl(projectId,params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(createDatasetBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getCreateDatasetUrl = (projectId: ProjectId,) => {
+
 
-export const getGetDatasetByIdUrl = (datasetId: DatasetId) => {
-  return `/api/v2-beta/datasets/${datasetId}`;
-};
+  
 
-export const getDatasetById = async (
-  datasetId: DatasetId,
-  options?: RequestInit,
-): Promise<Dataset> => {
-  return potatoFetch<Dataset>(getGetDatasetByIdUrl(datasetId), {
+  return `/api/v2-beta/projects/${projectId}/datasets`
+}
+
+export const createDataset = async (projectId: ProjectId,
+    createDatasetBody: CreateDatasetBody, options?: RequestInit): Promise<Dataset> => {
+  
+  return potatoFetch<Dataset>(getCreateDatasetUrl(projectId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createDatasetBody,)
+  }
+);}
+
+
+
+export const getGetDatasetByIdUrl = (datasetId: DatasetId,) => {
+
+
+  
+
+  return `/api/v2-beta/datasets/${datasetId}`
+}
 
-export const getListDatasetFieldsUrl = (datasetId: DatasetId, params?: ListDatasetFieldsParams) => {
+export const getDatasetById = async (datasetId: DatasetId, options?: RequestInit): Promise<Dataset> => {
+  
+  return potatoFetch<Dataset>(getGetDatasetByIdUrl(datasetId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getListDatasetFieldsUrl = (datasetId: DatasetId,
+    params?: ListDatasetFieldsParams,) => {
   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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/datasets/${datasetId}/fields?${stringifiedParams}`
-    : `/api/v2-beta/datasets/${datasetId}/fields`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/datasets/${datasetId}/fields?${stringifiedParams}` : `/api/v2-beta/datasets/${datasetId}/fields`
+}
 
-export const listDatasetFields = async (
-  datasetId: DatasetId,
-  params?: ListDatasetFieldsParams,
-  options?: RequestInit,
-): Promise<ListDatasetFields200> => {
-  return potatoFetch<ListDatasetFields200>(getListDatasetFieldsUrl(datasetId, params), {
+export const listDatasetFields = async (datasetId: DatasetId,
+    params?: ListDatasetFieldsParams, options?: RequestInit): Promise<ListDatasetFields200> => {
+  
+  return potatoFetch<ListDatasetFields200>(getListDatasetFieldsUrl(datasetId,params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(createDatasetFieldBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
-export const getGetDatasetInferredFieldsUrl = (datasetId: DatasetId) => {
-  return `/api/v2-beta/datasets/${datasetId}/inferred-fields`;
-};
+export const getCreateDatasetFieldUrl = (datasetId: DatasetId,) => {
 
-export const getDatasetInferredFields = async (
-  datasetId: DatasetId,
-  options?: RequestInit,
-): Promise<GetDatasetInferredFields200> => {
-  return potatoFetch<GetDatasetInferredFields200>(getGetDatasetInferredFieldsUrl(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),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(addDatasetItemsBody),
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createDatasetFieldBody,)
+  }
+);}
+
+
 
-export const getListDatasetItemsUrl = (datasetId: DatasetId, params?: ListDatasetItemsParams) => {
+export const getGetDatasetInferredFieldsUrl = (datasetId: DatasetId,) => {
+
+
+  
+
+  return `/api/v2-beta/datasets/${datasetId}/inferred-fields`
+}
+
+export const getDatasetInferredFields = async (datasetId: DatasetId, options?: RequestInit): Promise<GetDatasetInferredFields200> => {
+  
+  return potatoFetch<GetDatasetInferredFields200>(getGetDatasetInferredFieldsUrl(datasetId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      addDatasetItemsBody,)
+  }
+);}
+
+
+
+export const getListDatasetItemsUrl = (datasetId: DatasetId,
+    params?: ListDatasetItemsParams,) => {
   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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/datasets/${datasetId}/items?${stringifiedParams}`
-    : `/api/v2-beta/datasets/${datasetId}/items`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/datasets/${datasetId}/items?${stringifiedParams}` : `/api/v2-beta/datasets/${datasetId}/items`
+}
 
-export const listDatasetItems = async (
-  datasetId: DatasetId,
-  params?: ListDatasetItemsParams,
-  options?: RequestInit,
-): Promise<ListDatasetItems200> => {
-  return potatoFetch<ListDatasetItems200>(getListDatasetItemsUrl(datasetId, params), {
+export const listDatasetItems = async (datasetId: DatasetId,
+    params?: ListDatasetItemsParams, options?: RequestInit): Promise<ListDatasetItems200> => {
+  
+  return potatoFetch<ListDatasetItems200>(getListDatasetItemsUrl(datasetId,params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(createDatasetUploadBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
-export const getFinalizeDatasetUploadUrl = (uploadId: UploadId) => {
-  return `/api/v2-beta/uploads/${uploadId}/finalize`;
-};
+export const getCreateDatasetUploadUrl = (datasetId: DatasetId,) => {
 
-export const finalizeDatasetUpload = async (
-  uploadId: UploadId,
-  options?: RequestInit,
-): Promise<UploadJob> => {
-  return potatoFetch<UploadJob>(getFinalizeDatasetUploadUrl(uploadId), {
+
+  
+
+  return `/api/v2-beta/datasets/${datasetId}/uploads`
+}
+
+export const createDatasetUpload = async (datasetId: DatasetId,
+    createDatasetUploadBody: CreateDatasetUploadBody, options?: RequestInit): Promise<CreateDatasetUpload200> => {
+  
+  return potatoFetch<CreateDatasetUpload200>(getCreateDatasetUploadUrl(datasetId),
+  {      
     ...options,
-    method: "POST",
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createDatasetUploadBody,)
+  }
+);}
 
-export const getCancelDatasetUploadUrl = (uploadId: UploadId) => {
-  return `/api/v2-beta/uploads/${uploadId}/cancel`;
-};
 
-export const cancelDatasetUpload = async (
-  uploadId: UploadId,
-  options?: RequestInit,
-): Promise<void> => {
-  return potatoFetch<void>(getCancelDatasetUploadUrl(uploadId), {
+
+export const getFinalizeDatasetUploadUrl = (uploadId: UploadId,) => {
+
+
+  
+
+  return `/api/v2-beta/uploads/${uploadId}/finalize`
+}
+
+export const finalizeDatasetUpload = async (uploadId: UploadId, options?: RequestInit): Promise<UploadJob> => {
+  
+  return potatoFetch<UploadJob>(getFinalizeDatasetUploadUrl(uploadId),
+  {      
     ...options,
-    method: "POST",
-  });
-};
+    method: 'POST'
+    
+    
+  }
+);}
+
 
-export const getGetDatasetUploadUrl = (uploadId: UploadId) => {
-  return `/api/v2-beta/uploads/${uploadId}`;
-};
 
-export const getDatasetUpload = async (
-  uploadId: UploadId,
-  options?: RequestInit,
-): Promise<UploadJob> => {
-  return potatoFetch<UploadJob>(getGetDatasetUploadUrl(uploadId), {
+export const getCancelDatasetUploadUrl = (uploadId: UploadId,) => {
+
+
+  
+
+  return `/api/v2-beta/uploads/${uploadId}/cancel`
+}
+
+export const cancelDatasetUpload = async (uploadId: UploadId, options?: RequestInit): Promise<void> => {
+  
+  return potatoFetch<void>(getCancelDatasetUploadUrl(uploadId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(importPipelineBody),
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(attachPipelineDatasetBody),
-  });
-};
+    method: 'POST'
+    
+    
+  }
+);}
+
 
-export const getExportPipelineUrl = (pipelineId: PipelineId) => {
-  return `/api/v2-beta/pipelines/${pipelineId}/export`;
-};
 
-export const exportPipeline = async (
-  pipelineId: PipelineId,
-  options?: RequestInit,
-): Promise<ExportPipeline200> => {
-  return potatoFetch<ExportPipeline200>(getExportPipelineUrl(pipelineId), {
+export const getGetDatasetUploadUrl = (uploadId: UploadId,) => {
+
+
+  
+
+  return `/api/v2-beta/uploads/${uploadId}`
+}
+
+export const getDatasetUpload = async (uploadId: UploadId, options?: RequestInit): Promise<UploadJob> => {
+  
+  return potatoFetch<UploadJob>(getGetDatasetUploadUrl(uploadId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(copyPipelineBody),
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(estimatePipelineCostBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
 
-export const getCreatePipelineRunUrl = (pipelineId: PipelineId) => {
-  return `/api/v2-beta/pipelines/${pipelineId}/runs`;
-};
 
-export const createPipelineRun = async (
-  pipelineId: PipelineId,
-  options?: RequestInit,
-): Promise<RunJob> => {
-  return potatoFetch<RunJob>(getCreatePipelineRunUrl(pipelineId), {
+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),
+  {      
     ...options,
-    method: "POST",
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      importPipelineBody,)
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      attachPipelineDatasetBody,)
+  }
+);}
+
+
 
-export const getListPipelineRunsUrl = (pipelineId: PipelineId, params?: ListPipelineRunsParams) => {
+export const getExportPipelineUrl = (pipelineId: PipelineId,) => {
+
+
+  
+
+  return `/api/v2-beta/pipelines/${pipelineId}/export`
+}
+
+export const exportPipeline = async (pipelineId: PipelineId, options?: RequestInit): Promise<ExportPipeline200> => {
+  
+  return potatoFetch<ExportPipeline200>(getExportPipelineUrl(pipelineId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      copyPipelineBody,)
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      estimatePipelineCostBody,)
+  }
+);}
+
+
+
+export const getCreatePipelineRunUrl = (pipelineId: PipelineId,) => {
+
+
+  
+
+  return `/api/v2-beta/pipelines/${pipelineId}/runs`
+}
+
+export const createPipelineRun = async (pipelineId: PipelineId, options?: RequestInit): Promise<RunJob> => {
+  
+  return potatoFetch<RunJob>(getCreatePipelineRunUrl(pipelineId),
+  {      
+    ...options,
+    method: 'POST'
+    
+    
+  }
+);}
+
+
+
+export const getListPipelineRunsUrl = (pipelineId: PipelineId,
+    params?: ListPipelineRunsParams,) => {
   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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/pipelines/${pipelineId}/runs?${stringifiedParams}`
-    : `/api/v2-beta/pipelines/${pipelineId}/runs`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/pipelines/${pipelineId}/runs?${stringifiedParams}` : `/api/v2-beta/pipelines/${pipelineId}/runs`
+}
 
-export const listPipelineRuns = async (
-  pipelineId: PipelineId,
-  params?: ListPipelineRunsParams,
-  options?: RequestInit,
-): Promise<ListPipelineRuns200> => {
-  return potatoFetch<ListPipelineRuns200>(getListPipelineRunsUrl(pipelineId, params), {
+export const listPipelineRuns = async (pipelineId: PipelineId,
+    params?: ListPipelineRunsParams, options?: RequestInit): Promise<ListPipelineRuns200> => {
+  
+  return potatoFetch<ListPipelineRuns200>(getListPipelineRunsUrl(pipelineId,params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
-export const getGetPipelineRunUrl = (runId: RunId) => {
-  return `/api/v2-beta/runs/${runId}`;
-};
+export const getGetPipelineRunUrl = (runId: RunId,) => {
+
+
+  
+
+  return `/api/v2-beta/runs/${runId}`
+}
 
 export const getPipelineRun = async (runId: RunId, options?: RequestInit): Promise<RunJob> => {
-  return potatoFetch<RunJob>(getGetPipelineRunUrl(runId), {
+  
+  return potatoFetch<RunJob>(getGetPipelineRunUrl(runId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
 
-export const getGetPipelineRunCostUrl = (runId: RunId) => {
-  return `/api/v2-beta/runs/${runId}/cost`;
-};
+
+
+export const getGetPipelineRunCostUrl = (runId: RunId,) => {
+
+
+  
+
+  return `/api/v2-beta/runs/${runId}/cost`
+}
 
 export const getPipelineRunCost = async (runId: RunId, options?: RequestInit): Promise<RunCost> => {
-  return potatoFetch<RunCost>(getGetPipelineRunCostUrl(runId), {
+  
+  return potatoFetch<RunCost>(getGetPipelineRunCostUrl(runId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
-export const getCancelPipelineRunUrl = (runId: RunId) => {
-  return `/api/v2-beta/runs/${runId}/cancel`;
-};
+export const getCancelPipelineRunUrl = (runId: RunId,) => {
+
+
+  
+
+  return `/api/v2-beta/runs/${runId}/cancel`
+}
 
 export const cancelPipelineRun = async (runId: RunId, options?: RequestInit): Promise<RunJob> => {
-  return potatoFetch<RunJob>(getCancelPipelineRunUrl(runId), {
+  
+  return potatoFetch<RunJob>(getCancelPipelineRunUrl(runId),
+  {      
     ...options,
-    method: "POST",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(sampleDatasetItemsBody),
-  });
-};
+    method: 'POST'
+    
+    
+  }
+);}
+
+
+
+export const getSampleDatasetItemsUrl = (datasetId: DatasetId,) => {
 
-export const getGetDatasetSampleUrl = (sampleId: string) => {
-  return `/api/v2-beta/samples/${sampleId}`;
-};
 
-export const getDatasetSample = async (
-  sampleId: string,
-  options?: RequestInit,
-): Promise<SampleJob> => {
-  return potatoFetch<SampleJob>(getGetDatasetSampleUrl(sampleId), {
+  
+
+  return `/api/v2-beta/datasets/${datasetId}/sample`
+}
+
+export const sampleDatasetItems = async (datasetId: DatasetId,
+    sampleDatasetItemsBody: SampleDatasetItemsBody, options?: RequestInit): Promise<SampleResult> => {
+  
+  return potatoFetch<SampleResult>(getSampleDatasetItemsUrl(datasetId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(createDatasetExportBody),
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      sampleDatasetItemsBody,)
+  }
+);}
+
+
+
+export const getGetDatasetSampleUrl = (sampleId: string,) => {
 
-export const getGetDatasetExportUrl = (exportId: ExportId) => {
-  return `/api/v2-beta/exports/${exportId}`;
-};
 
-export const getDatasetExport = async (
-  exportId: ExportId,
-  options?: RequestInit,
-): Promise<ExportJob> => {
-  return potatoFetch<ExportJob>(getGetDatasetExportUrl(exportId), {
+  
+
+  return `/api/v2-beta/samples/${sampleId}`
+}
+
+export const getDatasetSample = async (sampleId: string, options?: RequestInit): Promise<SampleJob> => {
+  
+  return potatoFetch<SampleJob>(getGetDatasetSampleUrl(sampleId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getCreateDatasetExportUrl = (datasetId: DatasetId,) => {
+
+
+  
 
-export const getGetPipelineGraphSnapshotUrl = (pipelineId: PipelineId) => {
-  return `/api/v2-beta/pipelines/${pipelineId}/graph`;
-};
+  return `/api/v2-beta/datasets/${datasetId}/exports`
+}
 
-export const getPipelineGraphSnapshot = async (
-  pipelineId: PipelineId,
-  options?: RequestInit,
-): Promise<PipelineGraphSnapshot> => {
-  return potatoFetch<PipelineGraphSnapshot>(getGetPipelineGraphSnapshotUrl(pipelineId), {
+export const createDatasetExport = async (datasetId: DatasetId,
+    createDatasetExportBody: CreateDatasetExportBody, options?: RequestInit): Promise<ExportJob> => {
+  
+  return potatoFetch<ExportJob>(getCreateDatasetExportUrl(datasetId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "PUT",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(replacePipelineGraphBody),
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(validatePipelineGraphBody),
-  });
-};
-
-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), {
-    ...options,
-    method: "PATCH",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(patchPipelineNodeBody),
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createDatasetExportBody,)
+  }
+);}
+
+
+
+export const getGetDatasetExportUrl = (exportId: ExportId,) => {
+
 
-export const getListProjectSecretsUrl = (projectId: ProjectId) => {
-  return `/api/v2-beta/projects/${projectId}/secrets`;
-};
+  
 
-export const listProjectSecrets = async (
-  projectId: ProjectId,
-  options?: RequestInit,
-): Promise<ListProjectSecrets200> => {
-  return potatoFetch<ListProjectSecrets200>(getListProjectSecretsUrl(projectId), {
+  return `/api/v2-beta/exports/${exportId}`
+}
+
+export const getDatasetExport = async (exportId: ExportId, options?: RequestInit): Promise<ExportJob> => {
+  
+  return potatoFetch<ExportJob>(getGetDatasetExportUrl(exportId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "PUT",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(setProjectSecretBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetPipelineGraphSnapshotUrl = (pipelineId: PipelineId,) => {
+
+
+  
 
-export const getListProjectFilesUrl = (projectId: ProjectId) => {
-  return `/api/v2-beta/projects/${projectId}/files`;
-};
+  return `/api/v2-beta/pipelines/${pipelineId}/graph`
+}
 
-export const listProjectFiles = async (
-  projectId: ProjectId,
-  options?: RequestInit,
-): Promise<ListProjectFiles200> => {
-  return potatoFetch<ListProjectFiles200>(getListProjectFilesUrl(projectId), {
+export const getPipelineGraphSnapshot = async (pipelineId: PipelineId, options?: RequestInit): Promise<PipelineGraphSnapshot> => {
+  
+  return potatoFetch<PipelineGraphSnapshot>(getGetPipelineGraphSnapshotUrl(pipelineId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(createProjectFileUploadBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getReplacePipelineGraphUrl = (pipelineId: PipelineId,) => {
+
+
+  
 
-export const getFinalizeProjectFileUploadUrl = (projectId: ProjectId, fileId: ProjectFileId) => {
-  return `/api/v2-beta/projects/${projectId}/files/${fileId}/finalize`;
-};
+  return `/api/v2-beta/pipelines/${pipelineId}/graph`
+}
 
-export const finalizeProjectFileUpload = async (
-  projectId: ProjectId,
-  fileId: ProjectFileId,
-  options?: RequestInit,
-): Promise<ProjectFile> => {
-  return potatoFetch<ProjectFile>(getFinalizeProjectFileUploadUrl(projectId, fileId), {
+export const replacePipelineGraph = async (pipelineId: PipelineId,
+    replacePipelineGraphBody: ReplacePipelineGraphBody, options?: RequestInit): Promise<Pipeline> => {
+  
+  return potatoFetch<Pipeline>(getReplacePipelineGraphUrl(pipelineId),
+  {      
     ...options,
-    method: "POST",
-  });
-};
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      replacePipelineGraphBody,)
+  }
+);}
+
+
+
+export const getValidatePipelineGraphUrl = (pipelineId: PipelineId,) => {
 
-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> => {
-  return potatoFetch<void>(getDeleteProjectFileUrl(projectId, fileId), {
+  
+
+  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),
+  {      
     ...options,
-    method: "DELETE",
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      validatePipelineGraphBody,)
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      patchPipelineNodeBody,)
+  }
+);}
+
+
+
+export const getListProjectSecretsUrl = (projectId: ProjectId,) => {
+
+
+  
+
+  return `/api/v2-beta/projects/${projectId}/secrets`
+}
+
+export const listProjectSecrets = async (projectId: ProjectId, options?: RequestInit): Promise<ListProjectSecrets200> => {
+  
+  return potatoFetch<ListProjectSecrets200>(getListProjectSecretsUrl(projectId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      setProjectSecretBody,)
+  }
+);}
 
-export const getListPipelineRunItemsUrl = (runId: RunId, params?: ListPipelineRunItemsParams) => {
+
+
+export const getListProjectFilesUrl = (projectId: ProjectId,) => {
+
+
+  
+
+  return `/api/v2-beta/projects/${projectId}/files`
+}
+
+export const listProjectFiles = async (projectId: ProjectId, options?: RequestInit): Promise<ListProjectFiles200> => {
+  
+  return potatoFetch<ListProjectFiles200>(getListProjectFilesUrl(projectId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createProjectFileUploadBody,)
+  }
+);}
+
+
+
+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> => {
+  
+  return potatoFetch<ProjectFile>(getFinalizeProjectFileUploadUrl(projectId,fileId),
+  {      
+    ...options,
+    method: 'POST'
+    
+    
+  }
+);}
+
+
+
+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> => {
+  
+  return potatoFetch<void>(getDeleteProjectFileUrl(projectId,fileId),
+  {      
+    ...options,
+    method: 'DELETE'
+    
+    
+  }
+);}
+
+
+
+export const getListPipelineRunItemsUrl = (runId: RunId,
+    params?: ListPipelineRunItemsParams,) => {
   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' : value.toString())
     }
   });
 
   const stringifiedParams = normalizedParams.toString();
 
-  return stringifiedParams.length > 0
-    ? `/api/v2-beta/runs/${runId}/items?${stringifiedParams}`
-    : `/api/v2-beta/runs/${runId}/items`;
-};
+  return stringifiedParams.length > 0 ? `/api/v2-beta/runs/${runId}/items?${stringifiedParams}` : `/api/v2-beta/runs/${runId}/items`
+}
 
-export const listPipelineRunItems = async (
-  runId: RunId,
-  params?: ListPipelineRunItemsParams,
-  options?: RequestInit,
-): Promise<ListPipelineRunItems200> => {
-  return potatoFetch<ListPipelineRunItems200>(getListPipelineRunItemsUrl(runId, params), {
+export const listPipelineRunItems = async (runId: RunId,
+    params?: ListPipelineRunItemsParams, options?: RequestInit): Promise<ListPipelineRunItems200> => {
+  
+  return potatoFetch<ListPipelineRunItems200>(getListPipelineRunItemsUrl(runId,params),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetPipelineRunItemUrl = (runId: RunId,
+    itemId: RunItemId,) => {
+
 
-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> => {
-  return potatoFetch<RunItem>(getGetPipelineRunItemUrl(runId, itemId), {
+  return `/api/v2-beta/runs/${runId}/items/${itemId}`
+}
+
+export const getPipelineRunItem = async (runId: RunId,
+    itemId: RunItemId, options?: RequestInit): Promise<RunItem> => {
+  
+  return potatoFetch<RunItem>(getGetPipelineRunItemUrl(runId,itemId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
 
-export const getListPipelineChecksUrl = (pipelineId: PipelineId) => {
-  return `/api/v2-beta/pipelines/${pipelineId}/checks`;
-};
+export const getListPipelineChecksUrl = (pipelineId: PipelineId,) => {
 
-export const listPipelineChecks = async (
-  pipelineId: PipelineId,
-  options?: RequestInit,
-): Promise<ListPipelineChecks200> => {
-  return potatoFetch<ListPipelineChecks200>(getListPipelineChecksUrl(pipelineId), {
+
+  
+
+  return `/api/v2-beta/pipelines/${pipelineId}/checks`
+}
+
+export const listPipelineChecks = async (pipelineId: PipelineId, options?: RequestInit): Promise<ListPipelineChecks200> => {
+  
+  return potatoFetch<ListPipelineChecks200>(getListPipelineChecksUrl(pipelineId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
-
-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), {
-    ...options,
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...options?.headers },
-    body: JSON.stringify(createPipelineCheckBody),
-  });
-};
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getCreatePipelineCheckUrl = (pipelineId: PipelineId,) => {
 
-export const getGetPipelineCheckUrl = (checkRunId: CheckRunId) => {
-  return `/api/v2-beta/checks/${checkRunId}`;
-};
 
-export const getPipelineCheck = async (
-  checkRunId: CheckRunId,
-  options?: RequestInit,
-): Promise<CheckJob> => {
-  return potatoFetch<CheckJob>(getGetPipelineCheckUrl(checkRunId), {
+  
+
+  return `/api/v2-beta/pipelines/${pipelineId}/checks`
+}
+
+export const createPipelineCheck = async (pipelineId: PipelineId,
+    createPipelineCheckBody: CreatePipelineCheckBody, options?: RequestInit): Promise<CheckJob> => {
+  
+  return potatoFetch<CheckJob>(getCreatePipelineCheckUrl(pipelineId),
+  {      
     ...options,
-    method: "GET",
-  });
-};
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createPipelineCheckBody,)
+  }
+);}
+
+
+
+export const getGetPipelineCheckUrl = (checkRunId: CheckRunId,) => {
+
+
+  
+
+  return `/api/v2-beta/checks/${checkRunId}`
+}
+
+export const getPipelineCheck = async (checkRunId: CheckRunId, options?: RequestInit): Promise<CheckJob> => {
+  
+  return potatoFetch<CheckJob>(getGetPipelineCheckUrl(checkRunId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}