@prefecthq/prefect-ui-library 2.9.18 → 2.10.0

package/src/services/WorkspaceFlowRunsApi.ts

@@ -0,0 +1,140 @@
+import { RunGraphData } from '@prefecthq/graphs'
+import { StateUpdate, SchemaResponse } from '@/models'
+import { FlowRunHistoryResponse } from '@/models/api/FlowRunHistoryResponse'
+import { FlowRunResponse } from '@/models/api/FlowRunResponse'
+import { OrchestrationResult } from '@/models/api/OrchestrationResult'
+import { OrchestrationResultResponse } from '@/models/api/OrchestrationResultResponse'
+import { RunGraphDataResponse } from '@/models/api/RunGraphDataResponse'
+import { FlowRunsFilter, FlowRunsHistoryFilter } from '@/models/Filters'
+import { FlowRun } from '@/models/FlowRun'
+import { FlowRunInputKeyset } from '@/models/FlowRunInputKeyset'
+import { RunHistory } from '@/models/RunHistory'
+import { SchemaResponseV2, SchemaV2, SchemaValuesV2 } from '@/schemas'
+import { BatchProcessor } from '@/services/BatchProcessor'
+import { mapper } from '@/services/Mapper'
+import { WorkspaceApi } from '@/services/WorkspaceApi'
+import { Schema, SchemaValues } from '@/types/schemas'
+import { toMap } from '@/utilities'
+
+export class WorkspaceFlowRunsApi extends WorkspaceApi {
+
+  protected override routePrefix = '/flow_runs'
+
+  private readonly batcher = new BatchProcessor<string, FlowRun>(async ids => {
+    if (ids.length === 1) {
+      const [id] = ids
+      const { data } = await this.get<FlowRunResponse>(`/${id}`)
+
+      return () => mapper.map('FlowRunResponse', data, 'FlowRun')
+    }
+
+    const flowRuns = await this.getFlowRuns({
+      flowRuns: {
+        id: ids,
+      },
+    })
+
+    return toMap(flowRuns, 'id')
+  }, { maxBatchSize: 200 })
+
+  public getFlowRun(id: string): Promise<FlowRun> {
+    return this.batcher.batch(id)
+  }
+
+  public async getFlowRuns(filter: FlowRunsFilter = {}): Promise<FlowRun[]> {
+    const request = mapper.map('FlowRunsFilter', filter, 'FlowRunsFilterRequest')
+    const { data } = await this.post<FlowRunResponse[]>('/filter', request)
+
+    return mapper.map('FlowRunResponse', data, 'FlowRun')
+  }
+
+  public async getFlowRunsCount(filter: FlowRunsFilter = {}): Promise<number> {
+    const request = mapper.map('FlowRunsFilter', filter, 'FlowRunsFilterRequest')
+    const { data } = await this.post<number>('/count', request)
+
+    return data
+  }
+
+  public async getFlowRunsHistory(filter: FlowRunsHistoryFilter): Promise<RunHistory[]> {
+    const request = mapper.map('FlowRunsHistoryFilter', filter, 'FlowRunsHistoryFilterRequest')
+    const { data } = await this.post<FlowRunHistoryResponse[]>('/history', request)
+
+    return mapper.map('FlowRunHistoryResponse', data, 'RunHistory')
+  }
+
+  public async getFlowRunsAverageLateness(filter: FlowRunsFilter): Promise<number | null> {
+    const request = mapper.map('FlowRunsFilter', filter, 'FlowRunsFilterRequest')
+    const { data } = await this.post<number>('/lateness', request)
+
+    return data
+  }
+
+  public async getFlowRunsGraph(id: string): Promise<RunGraphData> {
+    const { data } = await this.get<RunGraphDataResponse>(`/${id}/graph-v2`)
+
+    return mapper.map('RunGraphDataResponse', data, 'RunGraphData')
+  }
+
+  public async getFlowRunInputDescription(id: string, keyset: FlowRunInputKeyset | undefined): Promise <string | null> {
+    if (!keyset) {
+      return null
+    }
+
+    try {
+      const { data } = await this.get<string | null>(`/${id}/input/${keyset.description}`)
+      return data
+    } catch (error) {
+      console.error('Flow run input description not found')
+      return null
+    }
+  }
+
+  public async getFlowRunInputSchema(id: string, keyset: FlowRunInputKeyset): Promise<Schema> {
+    const { data } = await this.get<SchemaResponse>(`/${id}/input/${keyset.schema}`)
+
+    return mapper.map('SchemaResponse', data, 'Schema')
+  }
+
+  public async getFlowRunInputSchemaV2(id: string, keyset: FlowRunInputKeyset): Promise<SchemaV2> {
+    const { data } = await this.get<SchemaResponseV2>(`/${id}/input/${keyset.schema}`)
+
+    return data
+  }
+
+  public retryFlowRun(id: string): Promise<void> {
+    return this.setFlowRunState(id, {
+      state: {
+        type: 'scheduled',
+        name: 'AwaitingRetry',
+        message: 'Retry from the UI',
+      },
+    })
+  }
+
+  public setFlowRunState(id: string, body: StateUpdate): Promise<void> {
+    const requestBody = mapper.map('StateUpdate', body, 'StateUpdateRequest')
+    return this.post(`/${id}/set_state`, { state: requestBody.state, force: true })
+  }
+
+  public async resumeFlowRun(id: string, values?: SchemaValues): Promise<OrchestrationResult> {
+    if (values) {
+      const { data } = await this.post<OrchestrationResultResponse>(`/${id}/resume`, { 'run_input': values })
+
+      return mapper.map('OrchestrationResultResponse', data, 'OrchestrationResult')
+    }
+
+    const { data } = await this.post<OrchestrationResultResponse>(`/${id}/resume`)
+
+    return mapper.map('OrchestrationResultResponse', data, 'OrchestrationResult')
+  }
+
+  public async resumeFlowRunV2(id: string, values: SchemaValuesV2): Promise<OrchestrationResult> {
+    const { data } = await this.post<OrchestrationResultResponse>(`/${id}/resume`, { 'run_input': values })
+
+    return mapper.map('OrchestrationResultResponse', data, 'OrchestrationResult')
+  }
+
+  public deleteFlowRun(flowRunId: string): Promise<void> {
+    return this.delete(`/${flowRunId}`)
+  }
+}

package/src/services/WorkspaceFlowsApi.ts

@@ -0,0 +1,51 @@
+import { Flow, FlowResponse } from '@/models'
+import { FlowsFilter } from '@/models/Filters'
+import { BatchProcessor } from '@/services/BatchProcessor'
+import { mapper } from '@/services/Mapper'
+import { WorkspaceApi } from '@/services/WorkspaceApi'
+import { toMap } from '@/utilities'
+
+export class WorkspaceFlowsApi extends WorkspaceApi {
+
+  protected override routePrefix = '/flows'
+
+  private readonly batcher = new BatchProcessor<string, Flow>(async ids => {
+    if (ids.length === 1) {
+      const [id] = ids
+      const { data } = await this.get<FlowResponse>(`${id}`)
+
+      return () => mapper.map('FlowResponse', data, 'Flow')
+    }
+
+    const flows = await this.getFlows({
+      flows: {
+        id: ids,
+      },
+    })
+
+    return toMap(flows, 'id')
+  }, { maxBatchSize: 200 })
+
+  public getFlow(flowId: string): Promise<Flow> {
+    return this.batcher.batch(flowId)
+  }
+
+  public async getFlows(filter: FlowsFilter = {}): Promise<Flow[]> {
+    const request = mapper.map('FlowsFilter', filter, 'FlowsFilterRequest')
+    const { data } = await this.post<FlowResponse[]>('filter', request)
+
+    return mapper.map('FlowResponse', data, 'Flow')
+  }
+
+  public async getFlowsCount(filter: FlowsFilter = {}): Promise<number> {
+    const request = mapper.map('FlowsFilter', filter, 'FlowsFilterRequest')
+    const { data } = await this.post<number>('count', request)
+
+    return data
+  }
+
+  public deleteFlow(flowId: string): Promise<void> {
+    return this.delete(`/${flowId}`)
+  }
+
+}

package/src/services/WorkspaceLogsApi.ts

@@ -0,0 +1,18 @@
+import { LogResponse } from '@/models/api/LogResponse'
+import { LogsFilter } from '@/models/Filters'
+import { Log } from '@/models/Log'
+import { mapper } from '@/services/Mapper'
+import { WorkspaceApi } from '@/services/WorkspaceApi'
+
+export class WorkspaceLogsApi extends WorkspaceApi {
+
+  protected override routePrefix = '/logs'
+
+  public async getLogs(filter: LogsFilter = {}): Promise<Log[]> {
+    const request = mapper.map('LogsFilter', filter, 'LogsFilterRequest')
+    const { data } = await this.post<LogResponse[]>('/filter', request)
+
+    return mapper.map('LogResponse', data, 'Log')
+  }
+
+}

package/src/services/WorkspaceNotificationsApi.ts

@@ -0,0 +1,39 @@
+import { NotificationResponse } from '@/models/api/NotificationResponse'
+import { NotificationsFilter } from '@/models/Filters'
+import { Notification } from '@/models/Notification'
+import { NotificationCreate } from '@/models/NotificationCreate'
+import { NotificationUpdate } from '@/models/NotificationUpdate'
+import { mapper } from '@/services/Mapper'
+import { WorkspaceApi } from '@/services/WorkspaceApi'
+
+export class WorkspaceNotificationsApi extends WorkspaceApi {
+
+  protected override routePrefix = '/flow_run_notification_policies'
+
+  public async getNotification(notificationId: string): Promise<Notification> {
+    const { data } = await this.get<NotificationResponse>(`/${notificationId}`)
+
+    return mapper.map('NotificationResponse', data, 'Notification')
+  }
+
+  public async createNotification(notification: NotificationCreate): Promise<Notification> {
+    const { data } = await this.post<NotificationResponse>('/', mapper.map('NotificationCreate', notification, 'NotificationCreateRequest'))
+
+    return mapper.map('NotificationResponse', data, 'Notification')
+  }
+
+  public async getNotifications(filter: NotificationsFilter = {}): Promise<Notification[]> {
+    const request = mapper.map('NotificationsFilter', filter, 'NotificationsFilterRequest')
+    const { data } = await this.post<NotificationResponse[]>('/filter', request)
+
+    return mapper.map('NotificationResponse', data, 'Notification')
+  }
+
+  public updateNotification(notificationId: string, notification: NotificationUpdate): Promise<void> {
+    return this.patch(`/${notificationId}`, mapper.map('NotificationUpdate', notification, 'NotificationUpdateRequest'))
+  }
+
+  public deleteNotification(notificationId: string): Promise<void> {
+    return this.delete(`/${notificationId}`)
+  }
+}

package/src/services/WorkspaceSavedSearchesApi.ts

@@ -0,0 +1,46 @@
+import { isDefined } from '@prefecthq/prefect-design'
+import { SavedSearchResponse } from '@/models/api/SavedSearchResponse'
+import { SavedSearchesFilter } from '@/models/Filters'
+import { SavedSearch, SavedSearchCreate } from '@/models/SavedSearch'
+import { mapper } from '@/services/Mapper'
+import { WorkspaceApi } from '@/services/WorkspaceApi'
+
+export class WorkspaceSavedSearchesApi extends WorkspaceApi {
+
+  protected override routePrefix = '/saved_searches'
+
+  public async getSavedSearches(filter: SavedSearchesFilter = {}): Promise<SavedSearch[]> {
+    const request = mapper.map('SavedSearchesFilter', filter, 'SavedSearchesFilterRequest')
+    const { data } = await this.post<SavedSearchResponse[]>('/filter', request)
+
+    const mapped = data.map(savedSearch => {
+      try {
+        return mapper.map('SavedSearchResponse', savedSearch, 'SavedSearch')
+      } catch (error) {
+        console.error(error)
+      }
+
+      return undefined
+    }).filter(isDefined)
+
+    return mapped
+  }
+
+  public async getSavedSearch(id: string): Promise<SavedSearch> {
+    const { data } = await this.get<SavedSearchResponse>(`/${id}`)
+    return mapper.map('SavedSearchResponse', data, 'SavedSearch')
+  }
+
+  public async createSavedSearch(search: SavedSearchCreate): Promise<SavedSearch> {
+    const request = mapper.map('SavedSearchCreate', search, 'SavedSearchCreateRequest')
+
+    const { data } = await this.put<SavedSearchResponse>('/', request)
+    return mapper.map('SavedSearchResponse', data, 'SavedSearch')
+  }
+
+  public deleteSavedSearch(id: string): Promise<void> {
+    return this.delete(`/${id}`)
+  }
+
+}
+

package/src/services/WorkspaceSchemasWorkspaceApi.ts

@@ -0,0 +1,52 @@
+import { isRecord } from '..'
+import { mapper } from '@/schemas/mapper'
+import { Schema, SchemaProperty } from '@/schemas/types/schema'
+import { SchemaValue, SchemaValues } from '@/schemas/types/schemaValues'
+import { SchemaValuesValidationResponse } from '@/schemas/types/schemaValuesValidationResponse'
+import { WorkspaceApi, mocker } from '@/services'
+
+export class WorkspaceSchemasWorkspaceApi extends WorkspaceApi {
+
+  protected override routePrefix = '/ui/schemas/'
+
+  public async validateSchemaValues(values: SchemaValues, schema: Schema): Promise<SchemaValuesValidationResponse> {
+    const { data } = await this.post<SchemaValuesValidationResponse>('/validate', {
+      schema: mapper.map('Schema', schema, 'SchemaResponse'),
+      values,
+    })
+
+    return data
+  }
+
+  public async validateSchemaValue(value: SchemaValue, property: SchemaProperty, schema: Schema): Promise<SchemaValuesValidationResponse> {
+    const propertyName = mocker.create('noun')
+    const propertySchema: Schema = {
+      definitions: schema.definitions,
+      properties: {
+        [propertyName]: property,
+      },
+    }
+
+    const values: SchemaValues = {
+      [propertyName]: value,
+    }
+
+    const response = await this.validateSchemaValues(values, propertySchema)
+
+    if (!response.valid) {
+      const [errors] = response.errors
+
+      if (!isRecord(errors)) {
+        throw new Error('Unexpected schema validation error response')
+      }
+
+      return {
+        valid: false,
+        errors: errors.errors,
+      }
+    }
+
+    return response
+  }
+
+}

package/src/services/WorkspaceTaskRunsApi.ts

@@ -0,0 +1,67 @@
+import { TaskRunHistoryResponse } from '@/models/api/TaskRunHistoryResponse'
+import { TaskRunResponse } from '@/models/api/TaskRunResponse'
+import { TaskRunsFilter, TaskRunsHistoryFilter } from '@/models/Filters'
+import { StateUpdate } from '@/models/StateUpdate'
+import { TaskRun } from '@/models/TaskRun'
+import { TaskRunHistory } from '@/models/TaskRunHistory'
+import { BatchProcessor } from '@/services/BatchProcessor'
+import { mapper } from '@/services/Mapper'
+import { WorkspaceApi } from '@/services/WorkspaceApi'
+import { toMap } from '@/utilities'
+
+export class WorkspaceTaskRunsApi extends WorkspaceApi {
+
+  protected override routePrefix = '/task_runs'
+
+  private readonly batcher = new BatchProcessor<string, TaskRun>(async ids => {
+    if (ids.length === 1) {
+      const [id] = ids
+      const { data } = await this.get<TaskRunResponse>(`/${id}`)
+
+      return () => mapper.map('TaskRunResponse', data, 'TaskRun')
+    }
+
+    const taskRuns = await this.getTaskRuns({
+      taskRuns: {
+        id: ids,
+      },
+    })
+
+    return toMap(taskRuns, 'id')
+  }, { maxBatchSize: 200 })
+
+  public getTaskRun(taskRunId: string): Promise<TaskRun> {
+    return this.batcher.batch(taskRunId)
+  }
+
+  public async getTaskRuns(filter: TaskRunsFilter = {}): Promise<TaskRun[]> {
+    const request = mapper.map('TaskRunsFilter', filter, 'TaskRunsFilterRequest')
+    const { data } = await this.post<TaskRunResponse[]>('/filter', request)
+
+    return mapper.map('TaskRunResponse', data, 'TaskRun')
+  }
+
+  public async getTaskRunsCount(filter: TaskRunsFilter = {}): Promise<number> {
+    const request = mapper.map('TaskRunsFilter', filter, 'TaskRunsFilterRequest')
+    const { data } = await this.post<number>('/count', request)
+
+    return data
+  }
+
+  public setTaskRunState(id: string, body: StateUpdate): Promise<void> {
+    const requestBody = mapper.map('StateUpdate', body, 'StateUpdateRequest')
+
+    return this.post(`/${id}/set_state`, { state: requestBody.state, force: true })
+  }
+
+  public deleteTaskRun(taskRunId: string): Promise<void> {
+    return this.delete(`/${taskRunId}`)
+  }
+
+  public async getTaskRunsHistory(filter: TaskRunsHistoryFilter): Promise<TaskRunHistory[]> {
+    const request = mapper.map('TaskRunsHistoryFilter', filter, 'TaskRunsHistoryFilterRequest')
+    const { data } = await this.post<TaskRunHistoryResponse[]>('/history', request)
+
+    return mapper.map('TaskRunHistoryResponse', data, 'TaskRunHistory')
+  }
+}

package/src/services/WorkspaceVariablesApi.ts

@@ -0,0 +1,51 @@
+import { Variable, VariableCreate, VariableEdit, VariablesFilter } from '@/models'
+import { VariableResponse } from '@/models/api/VariableResponse'
+import { mapper } from '@/services'
+import { WorkspaceApi } from '@/services/WorkspaceApi'
+
+export class WorkspaceVariablesApi extends WorkspaceApi {
+  protected override routePrefix = '/variables'
+
+  public async getVariable(variableId: string): Promise<Variable> {
+    const { data } = await this.get<VariableResponse>(`/${variableId}`)
+    return mapper.map('VariableResponse', data, 'Variable')
+  }
+
+  public async getVariableByName(variableName: string): Promise<Variable | null> {
+    const { data } = await this.get<VariableResponse | null>(`/name/${variableName}`)
+    if (data) {
+      return mapper.map('VariableResponse', data, 'Variable')
+    }
+
+    return null
+  }
+
+  public async getVariables(filter: VariablesFilter = {}): Promise<Variable[]> {
+    const request = mapper.map('VariablesFilter', filter, 'VariablesFilterRequest')
+    const { data } = await this.post<VariableResponse[]>('/filter', request)
+    return mapper.map('VariableResponse', data, 'Variable')
+  }
+
+  public async getVariablesCount(filter: VariablesFilter = {}): Promise<number> {
+    const request = mapper.map('VariablesFilter', filter, 'VariablesFilterRequest')
+    const { data } = await this.post<number>('/count', request)
+    return data
+  }
+
+  public async createVariable(body: VariableCreate): Promise<Variable> {
+    const requestBody = mapper.map('VariableCreate', body, 'VariableCreateRequest')
+    const { data } = await this.post<VariableResponse>('/', requestBody)
+    return mapper.map('VariableResponse', data, 'Variable')
+  }
+
+  public async editVariable(variableId: string, body: VariableEdit): Promise<Variable> {
+    const requestBody = mapper.map('VariableEdit', body, 'VariableEditRequest')
+    const { data } = await this.patch<VariableResponse>(`/${variableId}`, requestBody)
+
+    return mapper.map('VariableResponse', data, 'Variable')
+  }
+
+  public deleteVariable(variableId: string): Promise<void> {
+    return this.delete(`/${variableId}`)
+  }
+}

package/src/services/WorkspaceWorkPoolQueuesApi.ts

@@ -0,0 +1,51 @@
+import { WorkPoolQueueCreate, WorkPoolQueue, WorkPoolQueueEdit, WorkPoolQueueResponse } from '@/models'
+import { WorkPoolQueuesFilter } from '@/models/Filters'
+import { mapper, WorkspaceApi } from '@/services'
+
+export class WorkspaceWorkPoolQueuesApi extends WorkspaceApi {
+
+  protected override routePrefix = '/work_pools/'
+
+  public async createWorkPoolQueue(workPoolName: string, request: WorkPoolQueueCreate): Promise<WorkPoolQueue> {
+    const body = mapper.map('WorkPoolQueueCreate', request, 'WorkPoolQueueCreateRequest')
+
+    const { data } = await this.post<WorkPoolQueueResponse>(`/${workPoolName}/queues`, body)
+
+    return mapper.map('WorkPoolQueueResponse', data, 'WorkPoolQueue')
+  }
+
+  public async getWorkPoolQueues(workPoolName: string, filter: WorkPoolQueuesFilter = {}): Promise<WorkPoolQueue[]> {
+    const body = mapper.map('WorkPoolQueuesFilter', filter, 'WorkPoolQueuesFilterRequest')
+    const { data } = await this.post<WorkPoolQueueResponse[]>(`/${workPoolName}/queues/filter`, body)
+
+    return mapper.map('WorkPoolQueueResponse', data, 'WorkPoolQueue')
+  }
+
+  public async getWorkPoolQueueByName(workPoolName: string, queueName: string): Promise<WorkPoolQueue> {
+    const { data } = await this.get<WorkPoolQueueResponse>(`/${workPoolName}/queues/${queueName}`)
+
+    return mapper.map('WorkPoolQueueResponse', data, 'WorkPoolQueue')
+  }
+
+  public updateWorkPoolQueue(workPoolName: string, queueName: string, request: WorkPoolQueueEdit): Promise<void> {
+    const body = mapper.map('WorkPoolQueueEdit', request, 'WorkPoolQueueEditRequest')
+
+    return this.patch(`/${workPoolName}/queues/${queueName}`, body)
+  }
+
+  public pauseWorkPoolQueue(workPoolName: string, queueName: string): Promise<void> {
+    return this.patch(`/${workPoolName}/queues/${queueName}`, { 'is_paused': true })
+  }
+
+  public resumeWorkPoolQueue(workPoolName: string, queueName: string): Promise<void> {
+    return this.patch(`/${workPoolName}/queues/${queueName}`, { 'is_paused': false })
+  }
+
+  public deleteWorkPoolQueue(workPoolName: string, queueName: string): Promise<void> {
+    return this.delete(`/${workPoolName}/queues/${queueName}`)
+  }
+
+  public updateWorkPoolQueuePriority(workPoolName: string, queueName: string, priority: number): Promise<void> {
+    return this.patch(`/${workPoolName}/queues/${queueName}/update_priority`, { priority })
+  }
+}

package/src/services/WorkspaceWorkPoolWorkersApi.ts

@@ -0,0 +1,27 @@
+import { WorkPoolWorker } from '@/models'
+import { WorkPoolWorkerResponse } from '@/models/api/WorkPoolWorkerResponse'
+import { WorkPoolWorkersFilter } from '@/models/Filters'
+import { mapper, WorkspaceApi } from '@/services'
+
+export type WorkerDeleteArg = {
+  workPoolName: string,
+  workerName: string,
+}
+
+export class WorkspaceWorkPoolWorkersApi extends WorkspaceApi {
+  protected override routePrefix = '/work_pools/'
+
+  public async getWorkers(workPoolName: string, filter: WorkPoolWorkersFilter = {}): Promise<WorkPoolWorker[]> {
+    const request = mapper.map('WorkPoolWorkersFilter', filter, 'WorkPoolWorkersFilterRequest')
+    const encodedWorkPoolName = encodeURI(workPoolName)
+    const { data } = await this.post<WorkPoolWorkerResponse[]>(`/${encodedWorkPoolName}/workers/filter`, request)
+
+    return mapper.map('WorkPoolWorkerResponse', data, 'WorkPoolWorker')
+  }
+
+  public deleteWorker(arg: WorkerDeleteArg): Promise<void> {
+    const encodedWorkPoolName = encodeURI(arg.workPoolName)
+    const encodedWorkerName = encodeURI(arg.workerName)
+    return this.delete(`/${encodedWorkPoolName}/workers/${encodedWorkerName}`)
+  }
+}

package/src/services/WorkspaceWorkPoolsApi.ts

@@ -0,0 +1,88 @@
+import { WorkPool, WorkPoolCreate, WorkPoolEdit, WorkPoolResponse, WorkerScheduledFlowRunResponse, WorkerScheduledFlowRun, WorkerScheduledFlowRuns, BatchLookupError } from '@/models'
+import { WorkPoolsFilter } from '@/models/Filters'
+import { mapper, WorkspaceApi } from '@/services'
+
+
+export class WorkspaceWorkPoolsApi extends WorkspaceApi {
+
+  protected override routePrefix = '/work_pools/'
+
+  public async createWorkPool(request: WorkPoolCreate): Promise<WorkPool> {
+    const body = mapper.map('WorkPoolCreate', request, 'WorkPoolCreateRequest')
+    const { data } = await this.post<WorkPoolResponse>('/', body)
+
+    return mapper.map('WorkPoolResponse', data, 'WorkPool')
+  }
+
+  public async getWorkPoolByName(name: string): Promise<WorkPool> {
+    const encodedWorkPoolName = encodeURI(name)
+    const { data } = await this.get<WorkPoolResponse>(`/${encodedWorkPoolName}`)
+
+    return mapper.map('WorkPoolResponse', data, 'WorkPool')
+  }
+
+  public async getWorkPools(filter: WorkPoolsFilter = {}): Promise<WorkPool[]> {
+    const request = mapper.map('WorkPoolsFilter', filter, 'WorkPoolsFilterRequest')
+    const { data } = await this.post<WorkPoolResponse[]>('/filter', request)
+
+    return mapper.map('WorkPoolResponse', data, 'WorkPool')
+  }
+
+  public async getWorkPoolsCount(filter: WorkPoolsFilter = {}): Promise<number> {
+    const request = mapper.map('WorkPoolsFilter', filter, 'WorkPoolsFilterRequest')
+    const { data } = await this.post<number>('/count', request)
+
+    return data
+  }
+
+  public async getWorkPoolById(id: string): Promise<WorkPool> {
+    const filter = {
+      workPools: {
+        id: [id],
+      },
+    }
+    const request = mapper.map('WorkPoolsFilter', filter, 'WorkPoolsFilterRequest')
+    const { data } = await this.post<WorkPoolResponse[]>('/filter', request)
+    const [workPool] = data
+    if (!workPool.id) {
+      throw new BatchLookupError(id)
+    }
+    return mapper.map('WorkPoolResponse', workPool, 'WorkPool')
+  }
+
+  public updateWorkPool(name: string, request: WorkPoolEdit): Promise<void> {
+    const body = mapper.map('WorkPoolEdit', request, 'WorkPoolEditRequest')
+    const encodedWorkPoolName = encodeURI(name)
+
+    return this.patch(`/${encodedWorkPoolName}`, body)
+  }
+
+  public pauseWorkPool(name: string): Promise<void> {
+    const encodedWorkPoolName = encodeURI(name)
+    return this.patch(`/${encodedWorkPoolName}`, { 'is_paused': true })
+  }
+
+  public resumeWorkPool(name: string): Promise<void> {
+    const encodedWorkPoolName = encodeURI(name)
+    return this.patch(`/${encodedWorkPoolName}`, { 'is_paused': false })
+  }
+
+  public deleteWorkPool(name: string): Promise<void> {
+    const encodedWorkPoolName = encodeURI(name)
+    return this.delete(`/${encodedWorkPoolName}`)
+  }
+
+  public async getWorkPoolScheduledRuns(name: string, request: WorkerScheduledFlowRuns): Promise<WorkerScheduledFlowRun[]> {
+    const body = mapper.map('WorkerScheduledFlowRuns', request, 'WorkerScheduledFlowRunsRequest')
+    const encodedWorkPoolName = encodeURI(name)
+    const { data } = await this.post<WorkerScheduledFlowRunResponse[]>(`/${encodedWorkPoolName}/get_scheduled_flow_runs`, body)
+
+    return mapper.map('WorkerScheduledFlowRunResponse', data, 'WorkerScheduledFlowRun')
+  }
+
+  public async getWorkPoolLateRuns(name: string, request: WorkerScheduledFlowRuns): Promise<WorkerScheduledFlowRun[]> {
+    const data = await this.getWorkPoolScheduledRuns(name, request)
+
+    return data.filter(run => run.flowRun.stateName === 'Late')
+  }
+}