@toloka-platform/sdk 0.1.0-preview.3

package/openapi/gen/api.ts

@@ -0,0 +1,1117 @@
+import type {
+  AddDatasetItems200,
+  AddDatasetItemsBody,
+  AttachPipelineDatasetBody,
+  CheckJob,
+  CheckRunId,
+  CopyPipelineBody,
+  CreateDatasetBody,
+  CreateDatasetExportBody,
+  CreateDatasetField200,
+  CreateDatasetFieldBody,
+  CreateDatasetUpload200,
+  CreateDatasetUploadBody,
+  CreatePipelineCheckBody,
+  CreateProjectBody,
+  CreateProjectFileUpload200,
+  CreateProjectFileUploadBody,
+  CurrentUser,
+  Dataset,
+  DatasetId,
+  EstimatePipelineCostBody,
+  ExportId,
+  ExportJob,
+  ExportPipeline200,
+  GetDatasetInferredFields200,
+  ImportPipelineBody,
+  ListDatasetFields200,
+  ListDatasetFieldsParams,
+  ListDatasetItems200,
+  ListDatasetItemsParams,
+  ListPipelineChecks200,
+  ListPipelineRunItems200,
+  ListPipelineRunItemsParams,
+  ListPipelineRuns200,
+  ListPipelineRunsParams,
+  ListProjectDatasets200,
+  ListProjectDatasetsParams,
+  ListProjectFiles200,
+  ListProjectPipelines200,
+  ListProjectPipelinesParams,
+  ListProjectSecrets200,
+  ListProjects200,
+  ListProjectsParams,
+  PatchPipelineNodeBody,
+  Pipeline,
+  PipelineCostEstimate,
+  PipelineGraphSnapshot,
+  PipelineId,
+  PipelineValidationReport,
+  Project,
+  ProjectFile,
+  ProjectFileId,
+  ProjectId,
+  ProjectSecret,
+  ProjectSecretName,
+  ReplacePipelineGraphBody,
+  RunId,
+  RunItem,
+  RunItemId,
+  RunJob,
+  SetProjectSecretBody,
+  UpdatePipelineBody,
+  UpdateProjectBody,
+  UploadId,
+  UploadJob,
+  ValidatePipelineGraphBody
+} from './models';
+
+import { potatoFetch } from '../../src/transport';
+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 getListProjectsUrl = (params?: ListProjectsParams,) => {
+  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/projects?${stringifiedParams}` : `/api/v2-beta/projects`
+}
+
+export const listProjects = async (params?: ListProjectsParams, options?: RequestInit): Promise<ListProjects200> => {
+  
+  return potatoFetch<ListProjects200>(getListProjectsUrl(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(),
+  {      
+    ...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),
+  {      
+    ...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())
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  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 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,)
+  }
+);}
+
+
+
+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())
+    }
+  });
+
+  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),
+  {      
+    ...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,)
+  }
+);}
+
+
+
+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),
+  {      
+    ...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())
+    }
+  });
+
+  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),
+  {      
+    ...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,)
+  }
+);}
+
+
+
+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())
+    }
+  });
+
+  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),
+  {      
+    ...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,)
+  }
+);}
+
+
+
+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'
+    
+    
+  }
+);}
+
+
+
+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 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,)
+  }
+);}
+
+
+
+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())
+    }
+  });
+
+  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),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...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),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createDatasetExportBody,)
+  }
+);}
+
+
+
+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),
+  {      
+    ...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),
+  {      
+    ...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,)
+  }
+);}
+
+
+
+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 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())
+    }
+  });
+
+  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),
+  {      
+    ...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),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+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),
+  {      
+    ...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,)
+  }
+);}
+
+
+
+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'
+    
+    
+  }
+);}