@toloka-platform/sdk 0.1.0-preview.5 → 0.1.0-preview.7

package/openapi/gen/api.ts

@@ -2,6 +2,8 @@ import type {
   AddDatasetItems200,
   AddDatasetItemsBody,
   AttachPipelineDatasetBody,
+  BaseModel,
+  BaseModelId,
   CheckJob,
   CheckRunId,
   CopyPipelineBody,
@@ -15,6 +17,7 @@ import type {
   CreateProjectBody,
   CreateProjectFileUpload200,
   CreateProjectFileUploadBody,
+  CreateProjectModelBody,
   CurrentUser,
   Dataset,
   DatasetId,
@@ -24,10 +27,13 @@ import type {
   ExportPipeline200,
   GetDatasetInferredFields200,
   ImportPipelineBody,
+  ListBaseModels200,
   ListDatasetFields200,
   ListDatasetFieldsParams,
   ListDatasetItems200,
   ListDatasetItemsParams,
+  ListModelVersions200,
+  ListModelVersionsParams,
   ListPipelineChecks200,
   ListPipelineRunItems200,
   ListPipelineRunItemsParams,
@@ -36,11 +42,17 @@ import type {
   ListProjectDatasets200,
   ListProjectDatasetsParams,
   ListProjectFiles200,
+  ListProjectModels200,
+  ListProjectModelsParams,
   ListProjectPipelines200,
   ListProjectPipelinesParams,
   ListProjectSecrets200,
   ListProjects200,
   ListProjectsParams,
+  Model,
+  ModelId,
+  ModelVersion,
+  ModelVersionId,
   PatchPipelineNodeBody,
   Pipeline,
   PipelineCostEstimate,
@@ -59,1081 +71,990 @@ import type {
   RunItem,
   RunItemId,
   RunJob,
+  SampleDatasetItemsBody,
+  SampleJob,
+  SampleResult,
   SetProjectSecretBody,
   UpdatePipelineBody,
   UpdateProjectBody,
   UploadId,
   UploadJob,
-  ValidatePipelineGraphBody
-} from './models';
+  ValidatePipelineGraphBody,
+} from "./models";
 
-import { potatoFetch } from '../../src/transport';
-export const getGetCurrentUserUrl = () => {
-
-
-  
+import { potatoFetch } from "../../src/transport";
+export const getListBaseModelsUrl = () => {
+  return `/api/v2-beta/base-models`;
+};
 
-  return `/api/v2-beta/me`
-}
-
-export const getCurrentUser = async ( options?: RequestInit): Promise<CurrentUser> => {
-  
-  return potatoFetch<CurrentUser>(getGetCurrentUserUrl(),
-  {      
+export const listBaseModels = async (options?: RequestInit): Promise<ListBaseModels200> => {
+  return potatoFetch<ListBaseModels200>(getListBaseModelsUrl(), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
+    method: "GET",
+  });
+};
 
+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), {
+    ...options,
+    method: "GET",
+  });
+};
 
-export const getListProjectsUrl = (params?: ListProjectsParams,) => {
+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?${stringifiedParams}` : `/api/v2-beta/projects`
-}
-
-export const listProjects = async (params?: ListProjectsParams, options?: RequestInit): Promise<ListProjects200> => {
-  
-  return potatoFetch<ListProjects200>(getListProjectsUrl(params),
-  {      
+  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), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getCreateProjectUrl = () => {
-
-
-  
-
-  return `/api/v2-beta/projects`
-}
-
-export const createProject = async (createProjectBody: CreateProjectBody, options?: RequestInit): Promise<Project> => {
-  
-  return potatoFetch<Project>(getCreateProjectUrl(),
-  {      
+    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(
-      createProjectBody,)
-  }
-);}
-
-
-
-export const getGetProjectByIdUrl = (projectId: ProjectId,) => {
+    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());
+    }
+  });
 
-  return `/api/v2-beta/projects/${projectId}`
-}
+  const stringifiedParams = normalizedParams.toString();
 
-export const getProjectById = async (projectId: ProjectId, options?: RequestInit): Promise<Project> => {
-  
-  return potatoFetch<Project>(getGetProjectByIdUrl(projectId),
-  {      
+  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), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getUpdateProjectUrl = (projectId: ProjectId,) => {
-
-
-  
+    method: "GET",
+  });
+};
 
-  return `/api/v2-beta/projects/${projectId}`
-}
+export const getGetModelVersionUrl = (modelVersionId: ModelVersionId) => {
+  return `/api/v2-beta/model-versions/${modelVersionId}`;
+};
 
-export const updateProject = async (projectId: ProjectId,
-    updateProjectBody: UpdateProjectBody, options?: RequestInit): Promise<Project> => {
-  
-  return potatoFetch<Project>(getUpdateProjectUrl(projectId),
-  {      
+export const getModelVersion = async (
+  modelVersionId: ModelVersionId,
+  options?: RequestInit,
+): Promise<ModelVersion> => {
+  return potatoFetch<ModelVersion>(getGetModelVersionUrl(modelVersionId), {
+    ...options,
+    method: "GET",
+  });
+};
+
+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> => {
+  return potatoFetch<Model>(getArchiveProjectModelUrl(projectId, modelId), {
     ...options,
-    method: 'PATCH',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      updateProjectBody,)
-  }
-);}
+    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 getGetCurrentUserUrl = () => {
+  return `/api/v2-beta/me`;
+};
 
+export const getCurrentUser = async (options?: RequestInit): Promise<CurrentUser> => {
+  return potatoFetch<CurrentUser>(getGetCurrentUserUrl(), {
+    ...options,
+    method: "GET",
+  });
+};
 
-export const getListProjectPipelinesUrl = (projectId: ProjectId,
-    params?: ListProjectPipelinesParams,) => {
+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/${projectId}/pipelines?${stringifiedParams}` : `/api/v2-beta/projects/${projectId}/pipelines`
-}
+  return stringifiedParams.length > 0
+    ? `/api/v2-beta/projects?${stringifiedParams}`
+    : `/api/v2-beta/projects`;
+};
 
-export const listProjectPipelines = async (projectId: ProjectId,
-    params?: ListProjectPipelinesParams, options?: RequestInit): Promise<ListProjectPipelines200> => {
-  
-  return potatoFetch<ListProjectPipelines200>(getListProjectPipelinesUrl(projectId,params),
-  {      
+export const listProjects = async (
+  params?: ListProjectsParams,
+  options?: RequestInit,
+): Promise<ListProjects200> => {
+  return potatoFetch<ListProjects200>(getListProjectsUrl(params), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getGetPipelineByIdUrl = (pipelineId: PipelineId,) => {
-
-
-  
-
-  return `/api/v2-beta/pipelines/${pipelineId}`
-}
+    method: "GET",
+  });
+};
 
-export const getPipelineById = async (pipelineId: PipelineId, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getGetPipelineByIdUrl(pipelineId),
-  {      
+export const getCreateProjectUrl = () => {
+  return `/api/v2-beta/projects`;
+};
+
+export const createProject = async (
+  createProjectBody: CreateProjectBody,
+  options?: RequestInit,
+): Promise<Project> => {
+  return potatoFetch<Project>(getCreateProjectUrl(), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getUpdatePipelineUrl = (pipelineId: PipelineId,) => {
-
-
-  
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createProjectBody),
+  });
+};
 
-  return `/api/v2-beta/pipelines/${pipelineId}`
-}
+export const getGetProjectByIdUrl = (projectId: ProjectId) => {
+  return `/api/v2-beta/projects/${projectId}`;
+};
 
-export const updatePipeline = async (pipelineId: PipelineId,
-    updatePipelineBody: UpdatePipelineBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getUpdatePipelineUrl(pipelineId),
-  {      
+export const getProjectById = async (
+  projectId: ProjectId,
+  options?: RequestInit,
+): Promise<Project> => {
+  return potatoFetch<Project>(getGetProjectByIdUrl(projectId), {
     ...options,
-    method: 'PATCH',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      updatePipelineBody,)
-  }
-);}
-
-
+    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 getListProjectDatasetsUrl = (projectId: ProjectId,
-    params?: ListProjectDatasetsParams,) => {
+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}/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),
-  {      
+  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), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getCreateDatasetUrl = (projectId: ProjectId,) => {
-
-
-  
+    method: "GET",
+  });
+};
 
-  return `/api/v2-beta/projects/${projectId}/datasets`
-}
+export const getGetPipelineByIdUrl = (pipelineId: PipelineId) => {
+  return `/api/v2-beta/pipelines/${pipelineId}`;
+};
 
-export const createDataset = async (projectId: ProjectId,
-    createDatasetBody: CreateDatasetBody, options?: RequestInit): Promise<Dataset> => {
-  
-  return potatoFetch<Dataset>(getCreateDatasetUrl(projectId),
-  {      
+export const getPipelineById = async (
+  pipelineId: PipelineId,
+  options?: RequestInit,
+): Promise<Pipeline> => {
+  return potatoFetch<Pipeline>(getGetPipelineByIdUrl(pipelineId), {
     ...options,
-    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 getDatasetById = async (datasetId: DatasetId, options?: RequestInit): Promise<Dataset> => {
-  
-  return potatoFetch<Dataset>(getGetDatasetByIdUrl(datasetId),
-  {      
+    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: 'GET'
-    
-    
-  }
-);}
-
-
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(updatePipelineBody),
+  });
+};
 
-export const getListDatasetFieldsUrl = (datasetId: DatasetId,
-    params?: ListDatasetFieldsParams,) => {
+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/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),
-  {      
+  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), {
     ...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),
-  {      
+    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(
-      createDatasetFieldBody,)
-  }
-);}
-
-
-
-export const getGetDatasetInferredFieldsUrl = (datasetId: DatasetId,) => {
-
-
-  
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createDatasetBody),
+  });
+};
 
-  return `/api/v2-beta/datasets/${datasetId}/inferred-fields`
-}
+export const getGetDatasetByIdUrl = (datasetId: DatasetId) => {
+  return `/api/v2-beta/datasets/${datasetId}`;
+};
 
-export const getDatasetInferredFields = async (datasetId: DatasetId, options?: RequestInit): Promise<GetDatasetInferredFields200> => {
-  
-  return potatoFetch<GetDatasetInferredFields200>(getGetDatasetInferredFieldsUrl(datasetId),
-  {      
+export const getDatasetById = async (
+  datasetId: DatasetId,
+  options?: RequestInit,
+): Promise<Dataset> => {
+  return potatoFetch<Dataset>(getGetDatasetByIdUrl(datasetId), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getAddDatasetItemsUrl = (datasetId: DatasetId,) => {
+    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());
+    }
+  });
 
-  return `/api/v2-beta/datasets/${datasetId}/items`
-}
+  const stringifiedParams = normalizedParams.toString();
 
-export const addDatasetItems = async (datasetId: DatasetId,
-    addDatasetItemsBody: AddDatasetItemsBody, options?: RequestInit): Promise<AddDatasetItems200> => {
-  
-  return potatoFetch<AddDatasetItems200>(getAddDatasetItemsUrl(datasetId),
-  {      
+  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), {
+    ...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(
-      addDatasetItemsBody,)
-  }
-);}
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createDatasetFieldBody),
+  });
+};
 
+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,) => {
+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`
-}
-
-export const listDatasetItems = async (datasetId: DatasetId,
-    params?: ListDatasetItemsParams, options?: RequestInit): Promise<ListDatasetItems200> => {
-  
-  return potatoFetch<ListDatasetItems200>(getListDatasetItemsUrl(datasetId,params),
-  {      
+  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), {
     ...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),
-  {      
+    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,)
-  }
-);}
-
-
-
-export const getFinalizeDatasetUploadUrl = (uploadId: UploadId,) => {
-
-
-  
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createDatasetUploadBody),
+  });
+};
 
-  return `/api/v2-beta/uploads/${uploadId}/finalize`
-}
+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),
-  {      
+export const finalizeDatasetUpload = async (
+  uploadId: UploadId,
+  options?: RequestInit,
+): Promise<UploadJob> => {
+  return potatoFetch<UploadJob>(getFinalizeDatasetUploadUrl(uploadId), {
     ...options,
-    method: 'POST'
-    
-    
-  }
-);}
-
-
-
-export const getGetDatasetUploadUrl = (uploadId: UploadId,) => {
-
-
-  
+    method: "POST",
+  });
+};
 
-  return `/api/v2-beta/uploads/${uploadId}`
-}
+export const getCancelDatasetUploadUrl = (uploadId: UploadId) => {
+  return `/api/v2-beta/uploads/${uploadId}/cancel`;
+};
 
-export const getDatasetUpload = async (uploadId: UploadId, options?: RequestInit): Promise<UploadJob> => {
-  
-  return potatoFetch<UploadJob>(getGetDatasetUploadUrl(uploadId),
-  {      
+export const cancelDatasetUpload = async (
+  uploadId: UploadId,
+  options?: RequestInit,
+): Promise<void> => {
+  return potatoFetch<void>(getCancelDatasetUploadUrl(uploadId), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getImportPipelineUrl = (projectId: ProjectId,) => {
-
-
-  
+    method: "POST",
+  });
+};
 
-  return `/api/v2-beta/projects/${projectId}/pipelines/import`
-}
+export const getGetDatasetUploadUrl = (uploadId: UploadId) => {
+  return `/api/v2-beta/uploads/${uploadId}`;
+};
 
-export const importPipeline = async (projectId: ProjectId,
-    importPipelineBody: ImportPipelineBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getImportPipelineUrl(projectId),
-  {      
+export const getDatasetUpload = async (
+  uploadId: UploadId,
+  options?: RequestInit,
+): Promise<UploadJob> => {
+  return potatoFetch<UploadJob>(getGetDatasetUploadUrl(uploadId), {
     ...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),
-  {      
+    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(
-      attachPipelineDatasetBody,)
-  }
-);}
-
-
-
-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),
-  {      
+    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: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getCopyPipelineUrl = (pipelineId: PipelineId,) => {
-
-
-  
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(attachPipelineDatasetBody),
+  });
+};
 
-  return `/api/v2-beta/pipelines/${pipelineId}/copy`
-}
+export const getExportPipelineUrl = (pipelineId: PipelineId) => {
+  return `/api/v2-beta/pipelines/${pipelineId}/export`;
+};
 
-export const copyPipeline = async (pipelineId: PipelineId,
-    copyPipelineBody: CopyPipelineBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getCopyPipelineUrl(pipelineId),
-  {      
+export const exportPipeline = async (
+  pipelineId: PipelineId,
+  options?: RequestInit,
+): Promise<ExportPipeline200> => {
+  return potatoFetch<ExportPipeline200>(getExportPipelineUrl(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),
-  {      
+    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(
-      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),
-  {      
+    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'
-    
-    
-  }
-);}
+    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,) => {
+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`
-}
-
-export const listPipelineRuns = async (pipelineId: PipelineId,
-    params?: ListPipelineRunsParams, options?: RequestInit): Promise<ListPipelineRuns200> => {
-  
-  return potatoFetch<ListPipelineRuns200>(getListPipelineRunsUrl(pipelineId,params),
-  {      
+  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), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getGetPipelineRunUrl = (runId: RunId,) => {
-
-
-  
+    method: "GET",
+  });
+};
 
-  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'
-    
-    
-  }
-);}
-
-
-
-export const getGetPipelineRunCostUrl = (runId: RunId,) => {
-
-
-  
+    method: "GET",
+  });
+};
 
-  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'
-    
-    
-  }
-);}
-
-
-
-export const getCancelPipelineRunUrl = (runId: RunId,) => {
-
-
-  
+    method: "GET",
+  });
+};
 
-  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 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),
-  {      
+    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(
-      createDatasetExportBody,)
-  }
-);}
-
-
-
-export const getGetDatasetExportUrl = (exportId: ExportId,) => {
-
-
-  
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(sampleDatasetItemsBody),
+  });
+};
 
-  return `/api/v2-beta/exports/${exportId}`
-}
+export const getGetDatasetSampleUrl = (sampleId: string) => {
+  return `/api/v2-beta/samples/${sampleId}`;
+};
 
-export const getDatasetExport = async (exportId: ExportId, options?: RequestInit): Promise<ExportJob> => {
-  
-  return potatoFetch<ExportJob>(getGetDatasetExportUrl(exportId),
-  {      
+export const getDatasetSample = async (
+  sampleId: string,
+  options?: RequestInit,
+): Promise<SampleJob> => {
+  return potatoFetch<SampleJob>(getGetDatasetSampleUrl(sampleId), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getGetPipelineGraphSnapshotUrl = (pipelineId: PipelineId,) => {
-
-
-  
-
-  return `/api/v2-beta/pipelines/${pipelineId}/graph`
-}
-
-export const getPipelineGraphSnapshot = async (pipelineId: PipelineId, options?: RequestInit): Promise<PipelineGraphSnapshot> => {
-  
-  return potatoFetch<PipelineGraphSnapshot>(getGetPipelineGraphSnapshotUrl(pipelineId),
-  {      
+    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: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getReplacePipelineGraphUrl = (pipelineId: PipelineId,) => {
-
-
-  
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createDatasetExportBody),
+  });
+};
 
-  return `/api/v2-beta/pipelines/${pipelineId}/graph`
-}
+export const getGetDatasetExportUrl = (exportId: ExportId) => {
+  return `/api/v2-beta/exports/${exportId}`;
+};
 
-export const replacePipelineGraph = async (pipelineId: PipelineId,
-    replacePipelineGraphBody: ReplacePipelineGraphBody, options?: RequestInit): Promise<Pipeline> => {
-  
-  return potatoFetch<Pipeline>(getReplacePipelineGraphUrl(pipelineId),
-  {      
+export const getDatasetExport = async (
+  exportId: ExportId,
+  options?: RequestInit,
+): Promise<ExportJob> => {
+  return potatoFetch<ExportJob>(getGetDatasetExportUrl(exportId), {
     ...options,
-    method: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      replacePipelineGraphBody,)
-  }
-);}
-
-
-
-export const getValidatePipelineGraphUrl = (pipelineId: PipelineId,) => {
-
-
-  
+    method: "GET",
+  });
+};
 
-  return `/api/v2-beta/pipelines/${pipelineId}/graph/validate`
-}
+export const getGetPipelineGraphSnapshotUrl = (pipelineId: PipelineId) => {
+  return `/api/v2-beta/pipelines/${pipelineId}/graph`;
+};
 
-export const validatePipelineGraph = async (pipelineId: PipelineId,
-    validatePipelineGraphBody: ValidatePipelineGraphBody, options?: RequestInit): Promise<PipelineValidationReport> => {
-  
-  return potatoFetch<PipelineValidationReport>(getValidatePipelineGraphUrl(pipelineId),
-  {      
+export const getPipelineGraphSnapshot = async (
+  pipelineId: PipelineId,
+  options?: RequestInit,
+): Promise<PipelineGraphSnapshot> => {
+  return potatoFetch<PipelineGraphSnapshot>(getGetPipelineGraphSnapshotUrl(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),
-  {      
+    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: '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),
-  {      
+    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: '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),
-  {      
+    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: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      setProjectSecretBody,)
-  }
-);}
-
-
-
-export const getListProjectFilesUrl = (projectId: ProjectId,) => {
-
-
-  
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(patchPipelineNodeBody),
+  });
+};
 
-  return `/api/v2-beta/projects/${projectId}/files`
-}
+export const getListProjectSecretsUrl = (projectId: ProjectId) => {
+  return `/api/v2-beta/projects/${projectId}/secrets`;
+};
 
-export const listProjectFiles = async (projectId: ProjectId, options?: RequestInit): Promise<ListProjectFiles200> => {
-  
-  return potatoFetch<ListProjectFiles200>(getListProjectFilesUrl(projectId),
-  {      
+export const listProjectSecrets = async (
+  projectId: ProjectId,
+  options?: RequestInit,
+): Promise<ListProjectSecrets200> => {
+  return potatoFetch<ListProjectSecrets200>(getListProjectSecretsUrl(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),
-  {      
+    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: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(
-      createProjectFileUploadBody,)
-  }
-);}
-
-
-
-export const getFinalizeProjectFileUploadUrl = (projectId: ProjectId,
-    fileId: ProjectFileId,) => {
-
-
-  
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(setProjectSecretBody),
+  });
+};
 
-  return `/api/v2-beta/projects/${projectId}/files/${fileId}/finalize`
-}
+export const getListProjectFilesUrl = (projectId: ProjectId) => {
+  return `/api/v2-beta/projects/${projectId}/files`;
+};
 
-export const finalizeProjectFileUpload = async (projectId: ProjectId,
-    fileId: ProjectFileId, options?: RequestInit): Promise<ProjectFile> => {
-  
-  return potatoFetch<ProjectFile>(getFinalizeProjectFileUploadUrl(projectId,fileId),
-  {      
+export const listProjectFiles = async (
+  projectId: ProjectId,
+  options?: RequestInit,
+): Promise<ListProjectFiles200> => {
+  return potatoFetch<ListProjectFiles200>(getListProjectFilesUrl(projectId), {
     ...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),
-  {      
+    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: 'DELETE'
-    
-    
-  }
-);}
-
-
+    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,) => {
+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`
-}
-
-export const listPipelineRunItems = async (runId: RunId,
-    params?: ListPipelineRunItemsParams, options?: RequestInit): Promise<ListPipelineRunItems200> => {
-  
-  return potatoFetch<ListPipelineRunItems200>(getListPipelineRunItemsUrl(runId,params),
-  {      
+  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), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-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),
-  {      
+    method: "GET",
+  });
+};
+
+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), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
-
-
-
-export const getListPipelineChecksUrl = (pipelineId: PipelineId,) => {
-
-
-  
+    method: "GET",
+  });
+};
 
-  return `/api/v2-beta/pipelines/${pipelineId}/checks`
-}
+export const getListPipelineChecksUrl = (pipelineId: PipelineId) => {
+  return `/api/v2-beta/pipelines/${pipelineId}/checks`;
+};
 
-export const listPipelineChecks = async (pipelineId: PipelineId, options?: RequestInit): Promise<ListPipelineChecks200> => {
-  
-  return potatoFetch<ListPipelineChecks200>(getListPipelineChecksUrl(pipelineId),
-  {      
+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),
-  {      
+    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,)
-  }
-);}
-
-
-
-export const getGetPipelineCheckUrl = (checkRunId: CheckRunId,) => {
-
-
-  
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createPipelineCheckBody),
+  });
+};
 
-  return `/api/v2-beta/checks/${checkRunId}`
-}
+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),
-  {      
+export const getPipelineCheck = async (
+  checkRunId: CheckRunId,
+  options?: RequestInit,
+): Promise<CheckJob> => {
+  return potatoFetch<CheckJob>(getGetPipelineCheckUrl(checkRunId), {
     ...options,
-    method: 'GET'
-    
-    
-  }
-);}
+    method: "GET",
+  });
+};