windmill-client 0.1.0

package/src/services/JobService.ts

@@ -0,0 +1,1247 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CompletedJob } from '../models/CompletedJob';
+import type { FlowPreview } from '../models/FlowPreview';
+import type { Job } from '../models/Job';
+import type { Preview } from '../models/Preview';
+import type { QueuedJob } from '../models/QueuedJob';
+import type { ScriptArgs } from '../models/ScriptArgs';
+
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+
+export class JobService {
+
+    /**
+     * run script by path
+     * @returns string job created
+     * @throws ApiError
+     */
+    public static runScriptByPath({
+        workspace,
+        path,
+        requestBody,
+        scheduledFor,
+        scheduledInSecs,
+        parentJob,
+        invisibleToOwner,
+    }: {
+        workspace: string,
+        path: string,
+        /**
+         * script args
+         */
+        requestBody: ScriptArgs,
+        /**
+         * when to schedule this job (leave empty for immediate run)
+         */
+        scheduledFor?: string,
+        /**
+         * schedule the script to execute in the number of seconds starting now
+         */
+        scheduledInSecs?: number,
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string,
+        /**
+         * make the run invisible to the the script owner (default false)
+         */
+        invisibleToOwner?: boolean,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/run/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'scheduled_for': scheduledFor,
+                'scheduled_in_secs': scheduledInSecs,
+                'parent_job': parentJob,
+                'invisible_to_owner': invisibleToOwner,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * run script by path
+     * @returns any job result
+     * @throws ApiError
+     */
+    public static runWaitResultScriptByPath({
+        workspace,
+        path,
+        requestBody,
+        parentJob,
+        includeHeader,
+        queueLimit,
+    }: {
+        workspace: string,
+        path: string,
+        /**
+         * script args
+         */
+        requestBody: ScriptArgs,
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string,
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string,
+        /**
+         * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
+         *
+         */
+        queueLimit?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/run_wait_result/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'parent_job': parentJob,
+                'include_header': includeHeader,
+                'queue_limit': queueLimit,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * run script by path with get
+     * @returns any job result
+     * @throws ApiError
+     */
+    public static runWaitResultScriptByPathGet({
+        workspace,
+        path,
+        parentJob,
+        includeHeader,
+        queueLimit,
+        payload,
+    }: {
+        workspace: string,
+        path: string,
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string,
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string,
+        /**
+         * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
+         *
+         */
+        queueLimit?: string,
+        /**
+         * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
+         * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
+         *
+         */
+        payload?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/run_wait_result/p/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'parent_job': parentJob,
+                'include_header': includeHeader,
+                'queue_limit': queueLimit,
+                'payload': payload,
+            },
+        });
+    }
+
+    /**
+     * run flow by path and wait until completion
+     * @returns any job result
+     * @throws ApiError
+     */
+    public static runWaitResultFlowByPath({
+        workspace,
+        path,
+        requestBody,
+        includeHeader,
+        queueLimit,
+    }: {
+        workspace: string,
+        path: string,
+        /**
+         * script args
+         */
+        requestBody: ScriptArgs,
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string,
+        /**
+         * The maximum size of the queue for which the request would get rejected if that job would push it above that limit
+         *
+         */
+        queueLimit?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/run_wait_result/f/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'include_header': includeHeader,
+                'queue_limit': queueLimit,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * get job result by id
+     * @returns any job result
+     * @throws ApiError
+     */
+    public static resultById({
+        workspace,
+        flowJobId,
+        nodeId,
+    }: {
+        workspace: string,
+        flowJobId: string,
+        nodeId: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/result_by_id/{flow_job_id}/{node_id}',
+            path: {
+                'workspace': workspace,
+                'flow_job_id': flowJobId,
+                'node_id': nodeId,
+            },
+        });
+    }
+
+    /**
+     * run flow by path
+     * @returns string job created
+     * @throws ApiError
+     */
+    public static runFlowByPath({
+        workspace,
+        path,
+        requestBody,
+        scheduledFor,
+        scheduledInSecs,
+        parentJob,
+        includeHeader,
+        invisibleToOwner,
+    }: {
+        workspace: string,
+        path: string,
+        /**
+         * flow args
+         */
+        requestBody: ScriptArgs,
+        /**
+         * when to schedule this job (leave empty for immediate run)
+         */
+        scheduledFor?: string,
+        /**
+         * schedule the script to execute in the number of seconds starting now
+         */
+        scheduledInSecs?: number,
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string,
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string,
+        /**
+         * make the run invisible to the the flow owner (default false)
+         */
+        invisibleToOwner?: boolean,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/run/f/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+            query: {
+                'scheduled_for': scheduledFor,
+                'scheduled_in_secs': scheduledInSecs,
+                'parent_job': parentJob,
+                'include_header': includeHeader,
+                'invisible_to_owner': invisibleToOwner,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * run script by hash
+     * @returns string job created
+     * @throws ApiError
+     */
+    public static runScriptByHash({
+        workspace,
+        hash,
+        requestBody,
+        scheduledFor,
+        scheduledInSecs,
+        parentJob,
+        includeHeader,
+        invisibleToOwner,
+    }: {
+        workspace: string,
+        hash: string,
+        /**
+         * Partially filled args
+         */
+        requestBody: any,
+        /**
+         * when to schedule this job (leave empty for immediate run)
+         */
+        scheduledFor?: string,
+        /**
+         * schedule the script to execute in the number of seconds starting now
+         */
+        scheduledInSecs?: number,
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string,
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string,
+        /**
+         * make the run invisible to the the script owner (default false)
+         */
+        invisibleToOwner?: boolean,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/run/h/{hash}',
+            path: {
+                'workspace': workspace,
+                'hash': hash,
+            },
+            query: {
+                'scheduled_for': scheduledFor,
+                'scheduled_in_secs': scheduledInSecs,
+                'parent_job': parentJob,
+                'include_header': includeHeader,
+                'invisible_to_owner': invisibleToOwner,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * run script preview
+     * @returns string job created
+     * @throws ApiError
+     */
+    public static runScriptPreview({
+        workspace,
+        requestBody,
+        includeHeader,
+        invisibleToOwner,
+    }: {
+        workspace: string,
+        /**
+         * preview
+         */
+        requestBody: Preview,
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string,
+        /**
+         * make the run invisible to the the script owner (default false)
+         */
+        invisibleToOwner?: boolean,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/run/preview',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'include_header': includeHeader,
+                'invisible_to_owner': invisibleToOwner,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * run flow preview
+     * @returns string job created
+     * @throws ApiError
+     */
+    public static runFlowPreview({
+        workspace,
+        requestBody,
+        includeHeader,
+        invisibleToOwner,
+    }: {
+        workspace: string,
+        /**
+         * preview
+         */
+        requestBody: FlowPreview,
+        /**
+         * List of headers's keys (separated with ',') whove value are added to the args
+         * Header's key lowercased and '-'' replaced to '_' such that 'Content-Type' becomes the 'content_type' arg key
+         *
+         */
+        includeHeader?: string,
+        /**
+         * make the run invisible to the the script owner (default false)
+         */
+        invisibleToOwner?: boolean,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/run/preview_flow',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'include_header': includeHeader,
+                'invisible_to_owner': invisibleToOwner,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * list all available queued jobs
+     * @returns QueuedJob All available queued jobs
+     * @throws ApiError
+     */
+    public static listQueue({
+        workspace,
+        orderDesc,
+        createdBy,
+        parentJob,
+        scriptPathExact,
+        scriptPathStart,
+        scriptHash,
+        startedBefore,
+        startedAfter,
+        success,
+        jobKinds,
+        suspended,
+        running,
+        args,
+        result,
+        tag,
+    }: {
+        workspace: string,
+        /**
+         * order by desc order (default true)
+         */
+        orderDesc?: boolean,
+        /**
+         * mask to filter exact matching user creator
+         */
+        createdBy?: string,
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string,
+        /**
+         * mask to filter exact matching path
+         */
+        scriptPathExact?: string,
+        /**
+         * mask to filter matching starting path
+         */
+        scriptPathStart?: string,
+        /**
+         * mask to filter exact matching path
+         */
+        scriptHash?: string,
+        /**
+         * filter on created before (inclusive) timestamp
+         */
+        startedBefore?: string,
+        /**
+         * filter on created after (exclusive) timestamp
+         */
+        startedAfter?: string,
+        /**
+         * filter on successful jobs
+         */
+        success?: boolean,
+        /**
+         * filter on job kind (values 'preview', 'script', 'dependencies', 'flow') separated by,
+         */
+        jobKinds?: string,
+        /**
+         * filter on suspended jobs
+         */
+        suspended?: boolean,
+        /**
+         * filter on running jobs
+         */
+        running?: boolean,
+        /**
+         * filter on jobs containing those args as a json subset (@> in postgres)
+         */
+        args?: string,
+        /**
+         * filter on jobs containing those result as a json subset (@> in postgres)
+         */
+        result?: string,
+        /**
+         * filter on jobs with a given tag/worker group
+         */
+        tag?: string,
+    }): CancelablePromise<Array<QueuedJob>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/queue/list',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'order_desc': orderDesc,
+                'created_by': createdBy,
+                'parent_job': parentJob,
+                'script_path_exact': scriptPathExact,
+                'script_path_start': scriptPathStart,
+                'script_hash': scriptHash,
+                'started_before': startedBefore,
+                'started_after': startedAfter,
+                'success': success,
+                'job_kinds': jobKinds,
+                'suspended': suspended,
+                'running': running,
+                'args': args,
+                'result': result,
+                'tag': tag,
+            },
+        });
+    }
+
+    /**
+     * list all available completed jobs
+     * @returns CompletedJob All available completed jobs
+     * @throws ApiError
+     */
+    public static listCompletedJobs({
+        workspace,
+        orderDesc,
+        createdBy,
+        parentJob,
+        scriptPathExact,
+        scriptPathStart,
+        scriptHash,
+        startedBefore,
+        startedAfter,
+        success,
+        jobKinds,
+        args,
+        result,
+        tag,
+        isSkipped,
+        isFlowStep,
+    }: {
+        workspace: string,
+        /**
+         * order by desc order (default true)
+         */
+        orderDesc?: boolean,
+        /**
+         * mask to filter exact matching user creator
+         */
+        createdBy?: string,
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string,
+        /**
+         * mask to filter exact matching path
+         */
+        scriptPathExact?: string,
+        /**
+         * mask to filter matching starting path
+         */
+        scriptPathStart?: string,
+        /**
+         * mask to filter exact matching path
+         */
+        scriptHash?: string,
+        /**
+         * filter on created before (inclusive) timestamp
+         */
+        startedBefore?: string,
+        /**
+         * filter on created after (exclusive) timestamp
+         */
+        startedAfter?: string,
+        /**
+         * filter on successful jobs
+         */
+        success?: boolean,
+        /**
+         * filter on job kind (values 'preview', 'script', 'dependencies', 'flow') separated by,
+         */
+        jobKinds?: string,
+        /**
+         * filter on jobs containing those args as a json subset (@> in postgres)
+         */
+        args?: string,
+        /**
+         * filter on jobs containing those result as a json subset (@> in postgres)
+         */
+        result?: string,
+        /**
+         * filter on jobs with a given tag/worker group
+         */
+        tag?: string,
+        /**
+         * is the job skipped
+         */
+        isSkipped?: boolean,
+        /**
+         * is the job a flow step
+         */
+        isFlowStep?: boolean,
+    }): CancelablePromise<Array<CompletedJob>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/completed/list',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'order_desc': orderDesc,
+                'created_by': createdBy,
+                'parent_job': parentJob,
+                'script_path_exact': scriptPathExact,
+                'script_path_start': scriptPathStart,
+                'script_hash': scriptHash,
+                'started_before': startedBefore,
+                'started_after': startedAfter,
+                'success': success,
+                'job_kinds': jobKinds,
+                'args': args,
+                'result': result,
+                'tag': tag,
+                'is_skipped': isSkipped,
+                'is_flow_step': isFlowStep,
+            },
+        });
+    }
+
+    /**
+     * list all available jobs
+     * @returns Job All jobs
+     * @throws ApiError
+     */
+    public static listJobs({
+        workspace,
+        createdBy,
+        parentJob,
+        scriptPathExact,
+        scriptPathStart,
+        scriptHash,
+        startedBefore,
+        startedAfter,
+        jobKinds,
+        args,
+        tag,
+        result,
+        isSkipped,
+        isFlowStep,
+        success,
+    }: {
+        workspace: string,
+        /**
+         * mask to filter exact matching user creator
+         */
+        createdBy?: string,
+        /**
+         * The parent job that is at the origin and responsible for the execution of this script if any
+         */
+        parentJob?: string,
+        /**
+         * mask to filter exact matching path
+         */
+        scriptPathExact?: string,
+        /**
+         * mask to filter matching starting path
+         */
+        scriptPathStart?: string,
+        /**
+         * mask to filter exact matching path
+         */
+        scriptHash?: string,
+        /**
+         * filter on created before (inclusive) timestamp
+         */
+        startedBefore?: string,
+        /**
+         * filter on created after (exclusive) timestamp
+         */
+        startedAfter?: string,
+        /**
+         * filter on job kind (values 'preview', 'script', 'dependencies', 'flow') separated by,
+         */
+        jobKinds?: string,
+        /**
+         * filter on jobs containing those args as a json subset (@> in postgres)
+         */
+        args?: string,
+        /**
+         * filter on jobs with a given tag/worker group
+         */
+        tag?: string,
+        /**
+         * filter on jobs containing those result as a json subset (@> in postgres)
+         */
+        result?: string,
+        /**
+         * is the job skipped
+         */
+        isSkipped?: boolean,
+        /**
+         * is the job a flow step
+         */
+        isFlowStep?: boolean,
+        /**
+         * filter on successful jobs
+         */
+        success?: boolean,
+    }): CancelablePromise<Array<Job>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/list',
+            path: {
+                'workspace': workspace,
+            },
+            query: {
+                'created_by': createdBy,
+                'parent_job': parentJob,
+                'script_path_exact': scriptPathExact,
+                'script_path_start': scriptPathStart,
+                'script_hash': scriptHash,
+                'started_before': startedBefore,
+                'started_after': startedAfter,
+                'job_kinds': jobKinds,
+                'args': args,
+                'tag': tag,
+                'result': result,
+                'is_skipped': isSkipped,
+                'is_flow_step': isFlowStep,
+                'success': success,
+            },
+        });
+    }
+
+    /**
+     * get job
+     * @returns Job job details
+     * @throws ApiError
+     */
+    public static getJob({
+        workspace,
+        id,
+    }: {
+        workspace: string,
+        id: string,
+    }): CancelablePromise<Job> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs_u/get/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * get job updates
+     * @returns any job details
+     * @throws ApiError
+     */
+    public static getJobUpdates({
+        workspace,
+        id,
+        running,
+        logOffset,
+    }: {
+        workspace: string,
+        id: string,
+        running?: boolean,
+        logOffset?: number,
+    }): CancelablePromise<{
+        running?: boolean;
+        completed?: boolean;
+        new_logs?: string;
+        mem_peak?: number;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs_u/getupdate/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+            query: {
+                'running': running,
+                'log_offset': logOffset,
+            },
+        });
+    }
+
+    /**
+     * get completed job
+     * @returns CompletedJob job details
+     * @throws ApiError
+     */
+    public static getCompletedJob({
+        workspace,
+        id,
+    }: {
+        workspace: string,
+        id: string,
+    }): CancelablePromise<CompletedJob> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/completed/get/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * get completed job result
+     * @returns any result
+     * @throws ApiError
+     */
+    public static getCompletedJobResult({
+        workspace,
+        id,
+    }: {
+        workspace: string,
+        id: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/completed/get_result/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * delete completed job (erase content but keep run id)
+     * @returns CompletedJob job details
+     * @throws ApiError
+     */
+    public static deleteCompletedJob({
+        workspace,
+        id,
+    }: {
+        workspace: string,
+        id: string,
+    }): CancelablePromise<CompletedJob> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/completed/delete/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+        });
+    }
+
+    /**
+     * cancel queued job
+     * @returns string job canceled
+     * @throws ApiError
+     */
+    public static cancelQueuedJob({
+        workspace,
+        id,
+        requestBody,
+    }: {
+        workspace: string,
+        id: string,
+        /**
+         * reason
+         */
+        requestBody: {
+            reason?: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs_u/queue/cancel/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * force cancel queued job
+     * @returns string job canceled
+     * @throws ApiError
+     */
+    public static forceCancelQueuedJob({
+        workspace,
+        id,
+        requestBody,
+    }: {
+        workspace: string,
+        id: string,
+        /**
+         * reason
+         */
+        requestBody: {
+            reason?: string;
+        },
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs_u/queue/force_cancel/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * create an HMac signature given a job id and a resume id
+     * @returns string job signature
+     * @throws ApiError
+     */
+    public static createJobSignature({
+        workspace,
+        id,
+        resumeId,
+        approver,
+    }: {
+        workspace: string,
+        id: string,
+        resumeId: number,
+        approver?: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/job_signature/{id}/{resume_id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+            },
+            query: {
+                'approver': approver,
+            },
+        });
+    }
+
+    /**
+     * get resume urls given a job_id, resume_id and a nonce to resume a flow
+     * @returns any url endpoints
+     * @throws ApiError
+     */
+    public static getResumeUrls({
+        workspace,
+        id,
+        resumeId,
+        approver,
+    }: {
+        workspace: string,
+        id: string,
+        resumeId: number,
+        approver?: string,
+    }): CancelablePromise<{
+        approvalPage: string;
+        resume: string;
+        cancel: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/resume_urls/{id}/{resume_id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+            },
+            query: {
+                'approver': approver,
+            },
+        });
+    }
+
+    /**
+     * resume a job for a suspended flow
+     * @returns string job resumed
+     * @throws ApiError
+     */
+    public static resumeSuspendedJobGet({
+        workspace,
+        id,
+        resumeId,
+        signature,
+        payload,
+        approver,
+    }: {
+        workspace: string,
+        id: string,
+        resumeId: number,
+        signature: string,
+        /**
+         * The base64 encoded payload that has been encoded as a JSON. e.g how to encode such payload encodeURIComponent
+         * `encodeURIComponent(btoa(JSON.stringify({a: 2})))`
+         *
+         */
+        payload?: string,
+        approver?: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs_u/resume/{id}/{resume_id}/{signature}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
+            },
+            query: {
+                'payload': payload,
+                'approver': approver,
+            },
+        });
+    }
+
+    /**
+     * resume a job for a suspended flow
+     * @returns string job resumed
+     * @throws ApiError
+     */
+    public static resumeSuspendedJobPost({
+        workspace,
+        id,
+        resumeId,
+        signature,
+        requestBody,
+        approver,
+    }: {
+        workspace: string,
+        id: string,
+        resumeId: number,
+        signature: string,
+        requestBody: any,
+        approver?: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs_u/resume/{id}/{resume_id}/{signature}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
+            },
+            query: {
+                'approver': approver,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * resume a job for a suspended flow as an owner
+     * @returns string job resumed
+     * @throws ApiError
+     */
+    public static resumeSuspendedFlowAsOwner({
+        workspace,
+        id,
+        requestBody,
+    }: {
+        workspace: string,
+        id: string,
+        requestBody: any,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs/flow/resume/{id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * cancel a job for a suspended flow
+     * @returns string job resumed
+     * @throws ApiError
+     */
+    public static cancelSuspendedJobGet({
+        workspace,
+        id,
+        resumeId,
+        signature,
+        approver,
+    }: {
+        workspace: string,
+        id: string,
+        resumeId: number,
+        signature: string,
+        approver?: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs_u/cancel/{id}/{resume_id}/{signature}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
+            },
+            query: {
+                'approver': approver,
+            },
+        });
+    }
+
+    /**
+     * cancel a job for a suspended flow
+     * @returns string job resumed
+     * @throws ApiError
+     */
+    public static cancelSuspendedJobPost({
+        workspace,
+        id,
+        resumeId,
+        signature,
+        requestBody,
+        approver,
+    }: {
+        workspace: string,
+        id: string,
+        resumeId: number,
+        signature: string,
+        requestBody: any,
+        approver?: string,
+    }): CancelablePromise<string> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/jobs_u/cancel/{id}/{resume_id}/{signature}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
+            },
+            query: {
+                'approver': approver,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+
+    /**
+     * get parent flow job of suspended job
+     * @returns any parent flow details
+     * @throws ApiError
+     */
+    public static getSuspendedJobFlow({
+        workspace,
+        id,
+        resumeId,
+        signature,
+        approver,
+    }: {
+        workspace: string,
+        id: string,
+        resumeId: number,
+        signature: string,
+        approver?: string,
+    }): CancelablePromise<{
+        job: Job;
+        approvers: Array<{
+            resume_id: number;
+            approver: string;
+        }>;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs_u/get_flow/{id}/{resume_id}/{signature}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
+            },
+            query: {
+                'approver': approver,
+            },
+        });
+    }
+
+}