orvanta_api/apis/
job_api.rs

1/*
2 * Orvanta API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: 6.5.0
7 * Contact: contact@orvanta.cloud
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18/// struct for typed errors of method [`batch_re_run_jobs`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum BatchReRunJobsError {
22    UnknownValue(serde_json::Value),
23}
24
25/// struct for typed errors of method [`cancel_persistent_queued_jobs`]
26#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum CancelPersistentQueuedJobsError {
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`cancel_queued_job`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum CancelQueuedJobError {
36    UnknownValue(serde_json::Value),
37}
38
39/// struct for typed errors of method [`cancel_selection`]
40#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum CancelSelectionError {
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`cancel_suspended_job_get`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum CancelSuspendedJobGetError {
50    UnknownValue(serde_json::Value),
51}
52
53/// struct for typed errors of method [`cancel_suspended_job_post`]
54#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum CancelSuspendedJobPostError {
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`count_completed_jobs`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum CountCompletedJobsError {
64    UnknownValue(serde_json::Value),
65}
66
67/// struct for typed errors of method [`count_jobs_by_tag`]
68#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum CountJobsByTagError {
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`create_job_signature`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum CreateJobSignatureError {
78    Status403(),
79    UnknownValue(serde_json::Value),
80}
81
82/// struct for typed errors of method [`delete_completed_job`]
83#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum DeleteCompletedJobError {
86    UnknownValue(serde_json::Value),
87}
88
89/// struct for typed errors of method [`delete_jobs`]
90#[derive(Debug, Clone, Serialize, Deserialize)]
91#[serde(untagged)]
92pub enum DeleteJobsError {
93    UnknownValue(serde_json::Value),
94}
95
96/// struct for typed errors of method [`export_completed_jobs`]
97#[derive(Debug, Clone, Serialize, Deserialize)]
98#[serde(untagged)]
99pub enum ExportCompletedJobsError {
100    UnknownValue(serde_json::Value),
101}
102
103/// struct for typed errors of method [`export_queued_jobs`]
104#[derive(Debug, Clone, Serialize, Deserialize)]
105#[serde(untagged)]
106pub enum ExportQueuedJobsError {
107    UnknownValue(serde_json::Value),
108}
109
110/// struct for typed errors of method [`force_cancel_queued_job`]
111#[derive(Debug, Clone, Serialize, Deserialize)]
112#[serde(untagged)]
113pub enum ForceCancelQueuedJobError {
114    UnknownValue(serde_json::Value),
115}
116
117/// struct for typed errors of method [`get_approval_info`]
118#[derive(Debug, Clone, Serialize, Deserialize)]
119#[serde(untagged)]
120pub enum GetApprovalInfoError {
121    UnknownValue(serde_json::Value),
122}
123
124/// struct for typed errors of method [`get_completed_count`]
125#[derive(Debug, Clone, Serialize, Deserialize)]
126#[serde(untagged)]
127pub enum GetCompletedCountError {
128    UnknownValue(serde_json::Value),
129}
130
131/// struct for typed errors of method [`get_completed_job`]
132#[derive(Debug, Clone, Serialize, Deserialize)]
133#[serde(untagged)]
134pub enum GetCompletedJobError {
135    UnknownValue(serde_json::Value),
136}
137
138/// struct for typed errors of method [`get_completed_job_logs_tail`]
139#[derive(Debug, Clone, Serialize, Deserialize)]
140#[serde(untagged)]
141pub enum GetCompletedJobLogsTailError {
142    UnknownValue(serde_json::Value),
143}
144
145/// struct for typed errors of method [`get_completed_job_result`]
146#[derive(Debug, Clone, Serialize, Deserialize)]
147#[serde(untagged)]
148pub enum GetCompletedJobResultError {
149    UnknownValue(serde_json::Value),
150}
151
152/// struct for typed errors of method [`get_completed_job_result_maybe`]
153#[derive(Debug, Clone, Serialize, Deserialize)]
154#[serde(untagged)]
155pub enum GetCompletedJobResultMaybeError {
156    UnknownValue(serde_json::Value),
157}
158
159/// struct for typed errors of method [`get_completed_job_timing`]
160#[derive(Debug, Clone, Serialize, Deserialize)]
161#[serde(untagged)]
162pub enum GetCompletedJobTimingError {
163    UnknownValue(serde_json::Value),
164}
165
166/// struct for typed errors of method [`get_db_clock`]
167#[derive(Debug, Clone, Serialize, Deserialize)]
168#[serde(untagged)]
169pub enum GetDbClockError {
170    UnknownValue(serde_json::Value),
171}
172
173/// struct for typed errors of method [`get_flow_all_logs`]
174#[derive(Debug, Clone, Serialize, Deserialize)]
175#[serde(untagged)]
176pub enum GetFlowAllLogsError {
177    UnknownValue(serde_json::Value),
178}
179
180/// struct for typed errors of method [`get_flow_debug_info`]
181#[derive(Debug, Clone, Serialize, Deserialize)]
182#[serde(untagged)]
183pub enum GetFlowDebugInfoError {
184    UnknownValue(serde_json::Value),
185}
186
187/// struct for typed errors of method [`get_flow_user_state`]
188#[derive(Debug, Clone, Serialize, Deserialize)]
189#[serde(untagged)]
190pub enum GetFlowUserStateError {
191    UnknownValue(serde_json::Value),
192}
193
194/// struct for typed errors of method [`get_job`]
195#[derive(Debug, Clone, Serialize, Deserialize)]
196#[serde(untagged)]
197pub enum GetJobError {
198    UnknownValue(serde_json::Value),
199}
200
201/// struct for typed errors of method [`get_job_args`]
202#[derive(Debug, Clone, Serialize, Deserialize)]
203#[serde(untagged)]
204pub enum GetJobArgsError {
205    UnknownValue(serde_json::Value),
206}
207
208/// struct for typed errors of method [`get_job_logs`]
209#[derive(Debug, Clone, Serialize, Deserialize)]
210#[serde(untagged)]
211pub enum GetJobLogsError {
212    UnknownValue(serde_json::Value),
213}
214
215/// struct for typed errors of method [`get_job_updates`]
216#[derive(Debug, Clone, Serialize, Deserialize)]
217#[serde(untagged)]
218pub enum GetJobUpdatesError {
219    UnknownValue(serde_json::Value),
220}
221
222/// struct for typed errors of method [`get_job_updates_sse`]
223#[derive(Debug, Clone, Serialize, Deserialize)]
224#[serde(untagged)]
225pub enum GetJobUpdatesSseError {
226    UnknownValue(serde_json::Value),
227}
228
229/// struct for typed errors of method [`get_log_file_from_store`]
230#[derive(Debug, Clone, Serialize, Deserialize)]
231#[serde(untagged)]
232pub enum GetLogFileFromStoreError {
233    Status404(),
234    UnknownValue(serde_json::Value),
235}
236
237/// struct for typed errors of method [`get_queue_count`]
238#[derive(Debug, Clone, Serialize, Deserialize)]
239#[serde(untagged)]
240pub enum GetQueueCountError {
241    UnknownValue(serde_json::Value),
242}
243
244/// struct for typed errors of method [`get_queue_position`]
245#[derive(Debug, Clone, Serialize, Deserialize)]
246#[serde(untagged)]
247pub enum GetQueuePositionError {
248    UnknownValue(serde_json::Value),
249}
250
251/// struct for typed errors of method [`get_resume_urls`]
252#[derive(Debug, Clone, Serialize, Deserialize)]
253#[serde(untagged)]
254pub enum GetResumeUrlsError {
255    Status403(),
256    UnknownValue(serde_json::Value),
257}
258
259/// struct for typed errors of method [`get_root_job_id`]
260#[derive(Debug, Clone, Serialize, Deserialize)]
261#[serde(untagged)]
262pub enum GetRootJobIdError {
263    UnknownValue(serde_json::Value),
264}
265
266/// struct for typed errors of method [`get_scheduled_for`]
267#[derive(Debug, Clone, Serialize, Deserialize)]
268#[serde(untagged)]
269pub enum GetScheduledForError {
270    UnknownValue(serde_json::Value),
271}
272
273/// struct for typed errors of method [`get_slack_approval_payload`]
274#[derive(Debug, Clone, Serialize, Deserialize)]
275#[serde(untagged)]
276pub enum GetSlackApprovalPayloadError {
277    UnknownValue(serde_json::Value),
278}
279
280/// struct for typed errors of method [`get_started_at_by_ids`]
281#[derive(Debug, Clone, Serialize, Deserialize)]
282#[serde(untagged)]
283pub enum GetStartedAtByIdsError {
284    UnknownValue(serde_json::Value),
285}
286
287/// struct for typed errors of method [`get_suspended_job_flow`]
288#[derive(Debug, Clone, Serialize, Deserialize)]
289#[serde(untagged)]
290pub enum GetSuspendedJobFlowError {
291    UnknownValue(serde_json::Value),
292}
293
294/// struct for typed errors of method [`get_teams_approval_payload`]
295#[derive(Debug, Clone, Serialize, Deserialize)]
296#[serde(untagged)]
297pub enum GetTeamsApprovalPayloadError {
298    UnknownValue(serde_json::Value),
299}
300
301/// struct for typed errors of method [`import_completed_jobs`]
302#[derive(Debug, Clone, Serialize, Deserialize)]
303#[serde(untagged)]
304pub enum ImportCompletedJobsError {
305    UnknownValue(serde_json::Value),
306}
307
308/// struct for typed errors of method [`import_queued_jobs`]
309#[derive(Debug, Clone, Serialize, Deserialize)]
310#[serde(untagged)]
311pub enum ImportQueuedJobsError {
312    UnknownValue(serde_json::Value),
313}
314
315/// struct for typed errors of method [`list_completed_jobs`]
316#[derive(Debug, Clone, Serialize, Deserialize)]
317#[serde(untagged)]
318pub enum ListCompletedJobsError {
319    UnknownValue(serde_json::Value),
320}
321
322/// struct for typed errors of method [`list_extended_jobs`]
323#[derive(Debug, Clone, Serialize, Deserialize)]
324#[serde(untagged)]
325pub enum ListExtendedJobsError {
326    UnknownValue(serde_json::Value),
327}
328
329/// struct for typed errors of method [`list_filtered_jobs_uuids`]
330#[derive(Debug, Clone, Serialize, Deserialize)]
331#[serde(untagged)]
332pub enum ListFilteredJobsUuidsError {
333    UnknownValue(serde_json::Value),
334}
335
336/// struct for typed errors of method [`list_filtered_queue_uuids`]
337#[derive(Debug, Clone, Serialize, Deserialize)]
338#[serde(untagged)]
339pub enum ListFilteredQueueUuidsError {
340    UnknownValue(serde_json::Value),
341}
342
343/// struct for typed errors of method [`list_jobs`]
344#[derive(Debug, Clone, Serialize, Deserialize)]
345#[serde(untagged)]
346pub enum ListJobsError {
347    UnknownValue(serde_json::Value),
348}
349
350/// struct for typed errors of method [`list_queue`]
351#[derive(Debug, Clone, Serialize, Deserialize)]
352#[serde(untagged)]
353pub enum ListQueueError {
354    UnknownValue(serde_json::Value),
355}
356
357/// struct for typed errors of method [`list_selected_job_groups`]
358#[derive(Debug, Clone, Serialize, Deserialize)]
359#[serde(untagged)]
360pub enum ListSelectedJobGroupsError {
361    UnknownValue(serde_json::Value),
362}
363
364/// struct for typed errors of method [`restart_flow_at_step`]
365#[derive(Debug, Clone, Serialize, Deserialize)]
366#[serde(untagged)]
367pub enum RestartFlowAtStepError {
368    UnknownValue(serde_json::Value),
369}
370
371/// struct for typed errors of method [`result_by_id`]
372#[derive(Debug, Clone, Serialize, Deserialize)]
373#[serde(untagged)]
374pub enum ResultByIdError {
375    UnknownValue(serde_json::Value),
376}
377
378/// struct for typed errors of method [`resume_suspended`]
379#[derive(Debug, Clone, Serialize, Deserialize)]
380#[serde(untagged)]
381pub enum ResumeSuspendedError {
382    UnknownValue(serde_json::Value),
383}
384
385/// struct for typed errors of method [`resume_suspended_flow_as_owner`]
386#[derive(Debug, Clone, Serialize, Deserialize)]
387#[serde(untagged)]
388pub enum ResumeSuspendedFlowAsOwnerError {
389    UnknownValue(serde_json::Value),
390}
391
392/// struct for typed errors of method [`resume_suspended_job_get`]
393#[derive(Debug, Clone, Serialize, Deserialize)]
394#[serde(untagged)]
395pub enum ResumeSuspendedJobGetError {
396    UnknownValue(serde_json::Value),
397}
398
399/// struct for typed errors of method [`resume_suspended_job_post`]
400#[derive(Debug, Clone, Serialize, Deserialize)]
401#[serde(untagged)]
402pub enum ResumeSuspendedJobPostError {
403    UnknownValue(serde_json::Value),
404}
405
406/// struct for typed errors of method [`run_and_stream_flow_by_path`]
407#[derive(Debug, Clone, Serialize, Deserialize)]
408#[serde(untagged)]
409pub enum RunAndStreamFlowByPathError {
410    UnknownValue(serde_json::Value),
411}
412
413/// struct for typed errors of method [`run_and_stream_flow_by_path_get`]
414#[derive(Debug, Clone, Serialize, Deserialize)]
415#[serde(untagged)]
416pub enum RunAndStreamFlowByPathGetError {
417    UnknownValue(serde_json::Value),
418}
419
420/// struct for typed errors of method [`run_and_stream_flow_by_version`]
421#[derive(Debug, Clone, Serialize, Deserialize)]
422#[serde(untagged)]
423pub enum RunAndStreamFlowByVersionError {
424    UnknownValue(serde_json::Value),
425}
426
427/// struct for typed errors of method [`run_and_stream_flow_by_version_get`]
428#[derive(Debug, Clone, Serialize, Deserialize)]
429#[serde(untagged)]
430pub enum RunAndStreamFlowByVersionGetError {
431    UnknownValue(serde_json::Value),
432}
433
434/// struct for typed errors of method [`run_and_stream_script_by_hash`]
435#[derive(Debug, Clone, Serialize, Deserialize)]
436#[serde(untagged)]
437pub enum RunAndStreamScriptByHashError {
438    UnknownValue(serde_json::Value),
439}
440
441/// struct for typed errors of method [`run_and_stream_script_by_hash_get`]
442#[derive(Debug, Clone, Serialize, Deserialize)]
443#[serde(untagged)]
444pub enum RunAndStreamScriptByHashGetError {
445    UnknownValue(serde_json::Value),
446}
447
448/// struct for typed errors of method [`run_and_stream_script_by_path`]
449#[derive(Debug, Clone, Serialize, Deserialize)]
450#[serde(untagged)]
451pub enum RunAndStreamScriptByPathError {
452    UnknownValue(serde_json::Value),
453}
454
455/// struct for typed errors of method [`run_and_stream_script_by_path_get`]
456#[derive(Debug, Clone, Serialize, Deserialize)]
457#[serde(untagged)]
458pub enum RunAndStreamScriptByPathGetError {
459    UnknownValue(serde_json::Value),
460}
461
462/// struct for typed errors of method [`run_code_flow_task`]
463#[derive(Debug, Clone, Serialize, Deserialize)]
464#[serde(untagged)]
465pub enum RunCodeFlowTaskError {
466    UnknownValue(serde_json::Value),
467}
468
469/// struct for typed errors of method [`run_dynamic_select`]
470#[derive(Debug, Clone, Serialize, Deserialize)]
471#[serde(untagged)]
472pub enum RunDynamicSelectError {
473    UnknownValue(serde_json::Value),
474}
475
476/// struct for typed errors of method [`run_flow_by_path`]
477#[derive(Debug, Clone, Serialize, Deserialize)]
478#[serde(untagged)]
479pub enum RunFlowByPathError {
480    UnknownValue(serde_json::Value),
481}
482
483/// struct for typed errors of method [`run_flow_by_version`]
484#[derive(Debug, Clone, Serialize, Deserialize)]
485#[serde(untagged)]
486pub enum RunFlowByVersionError {
487    UnknownValue(serde_json::Value),
488}
489
490/// struct for typed errors of method [`run_flow_dependencies_async`]
491#[derive(Debug, Clone, Serialize, Deserialize)]
492#[serde(untagged)]
493pub enum RunFlowDependenciesAsyncError {
494    UnknownValue(serde_json::Value),
495}
496
497/// struct for typed errors of method [`run_flow_preview`]
498#[derive(Debug, Clone, Serialize, Deserialize)]
499#[serde(untagged)]
500pub enum RunFlowPreviewError {
501    UnknownValue(serde_json::Value),
502}
503
504/// struct for typed errors of method [`run_flow_preview_and_wait_result`]
505#[derive(Debug, Clone, Serialize, Deserialize)]
506#[serde(untagged)]
507pub enum RunFlowPreviewAndWaitResultError {
508    UnknownValue(serde_json::Value),
509}
510
511/// struct for typed errors of method [`run_raw_script_dependencies`]
512#[derive(Debug, Clone, Serialize, Deserialize)]
513#[serde(untagged)]
514pub enum RunRawScriptDependenciesError {
515    UnknownValue(serde_json::Value),
516}
517
518/// struct for typed errors of method [`run_raw_script_dependencies_async`]
519#[derive(Debug, Clone, Serialize, Deserialize)]
520#[serde(untagged)]
521pub enum RunRawScriptDependenciesAsyncError {
522    UnknownValue(serde_json::Value),
523}
524
525/// struct for typed errors of method [`run_script_by_hash`]
526#[derive(Debug, Clone, Serialize, Deserialize)]
527#[serde(untagged)]
528pub enum RunScriptByHashError {
529    UnknownValue(serde_json::Value),
530}
531
532/// struct for typed errors of method [`run_script_by_hash_inline`]
533#[derive(Debug, Clone, Serialize, Deserialize)]
534#[serde(untagged)]
535pub enum RunScriptByHashInlineError {
536    UnknownValue(serde_json::Value),
537}
538
539/// struct for typed errors of method [`run_script_by_path`]
540#[derive(Debug, Clone, Serialize, Deserialize)]
541#[serde(untagged)]
542pub enum RunScriptByPathError {
543    UnknownValue(serde_json::Value),
544}
545
546/// struct for typed errors of method [`run_script_by_path_inline`]
547#[derive(Debug, Clone, Serialize, Deserialize)]
548#[serde(untagged)]
549pub enum RunScriptByPathInlineError {
550    UnknownValue(serde_json::Value),
551}
552
553/// struct for typed errors of method [`run_script_preview`]
554#[derive(Debug, Clone, Serialize, Deserialize)]
555#[serde(untagged)]
556pub enum RunScriptPreviewError {
557    UnknownValue(serde_json::Value),
558}
559
560/// struct for typed errors of method [`run_script_preview_and_wait_result`]
561#[derive(Debug, Clone, Serialize, Deserialize)]
562#[serde(untagged)]
563pub enum RunScriptPreviewAndWaitResultError {
564    UnknownValue(serde_json::Value),
565}
566
567/// struct for typed errors of method [`run_script_preview_inline`]
568#[derive(Debug, Clone, Serialize, Deserialize)]
569#[serde(untagged)]
570pub enum RunScriptPreviewInlineError {
571    UnknownValue(serde_json::Value),
572}
573
574/// struct for typed errors of method [`run_wait_result_flow_by_path`]
575#[derive(Debug, Clone, Serialize, Deserialize)]
576#[serde(untagged)]
577pub enum RunWaitResultFlowByPathError {
578    UnknownValue(serde_json::Value),
579}
580
581/// struct for typed errors of method [`run_wait_result_flow_by_version`]
582#[derive(Debug, Clone, Serialize, Deserialize)]
583#[serde(untagged)]
584pub enum RunWaitResultFlowByVersionError {
585    UnknownValue(serde_json::Value),
586}
587
588/// struct for typed errors of method [`run_wait_result_flow_by_version_get`]
589#[derive(Debug, Clone, Serialize, Deserialize)]
590#[serde(untagged)]
591pub enum RunWaitResultFlowByVersionGetError {
592    UnknownValue(serde_json::Value),
593}
594
595/// struct for typed errors of method [`run_wait_result_script_by_path`]
596#[derive(Debug, Clone, Serialize, Deserialize)]
597#[serde(untagged)]
598pub enum RunWaitResultScriptByPathError {
599    UnknownValue(serde_json::Value),
600}
601
602/// struct for typed errors of method [`run_wait_result_script_by_path_get`]
603#[derive(Debug, Clone, Serialize, Deserialize)]
604#[serde(untagged)]
605pub enum RunWaitResultScriptByPathGetError {
606    UnknownValue(serde_json::Value),
607}
608
609/// struct for typed errors of method [`set_flow_user_state`]
610#[derive(Debug, Clone, Serialize, Deserialize)]
611#[serde(untagged)]
612pub enum SetFlowUserStateError {
613    UnknownValue(serde_json::Value),
614}
615
616
617pub async fn batch_re_run_jobs(configuration: &configuration::Configuration, workspace: &str, batch_re_run_jobs_request: models::BatchReRunJobsRequest) -> Result<String, Error<BatchReRunJobsError>> {
618    let local_var_configuration = configuration;
619
620    let local_var_client = &local_var_configuration.client;
621
622    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/batch_rerun_jobs", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
623    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
624
625    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
626        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
627    }
628    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
629        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
630    };
631    local_var_req_builder = local_var_req_builder.json(&batch_re_run_jobs_request);
632
633    let local_var_req = local_var_req_builder.build()?;
634    let local_var_resp = local_var_client.execute(local_var_req).await?;
635
636    let local_var_status = local_var_resp.status();
637    let local_var_content = local_var_resp.text().await?;
638
639    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
640        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
641    } else {
642        let local_var_entity: Option<BatchReRunJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
643        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
644        Err(Error::ResponseError(local_var_error))
645    }
646}
647
648pub async fn cancel_persistent_queued_jobs(configuration: &configuration::Configuration, workspace: &str, path: &str, cancel_queued_job_request: models::CancelQueuedJobRequest) -> Result<String, Error<CancelPersistentQueuedJobsError>> {
649    let local_var_configuration = configuration;
650
651    let local_var_client = &local_var_configuration.client;
652
653    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/queue/cancel_persistent/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
654    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
655
656    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
657        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
658    }
659    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
660        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
661    };
662    local_var_req_builder = local_var_req_builder.json(&cancel_queued_job_request);
663
664    let local_var_req = local_var_req_builder.build()?;
665    let local_var_resp = local_var_client.execute(local_var_req).await?;
666
667    let local_var_status = local_var_resp.status();
668    let local_var_content = local_var_resp.text().await?;
669
670    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
671        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
672    } else {
673        let local_var_entity: Option<CancelPersistentQueuedJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
674        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
675        Err(Error::ResponseError(local_var_error))
676    }
677}
678
679pub async fn cancel_queued_job(configuration: &configuration::Configuration, workspace: &str, id: &str, cancel_queued_job_request: models::CancelQueuedJobRequest) -> Result<String, Error<CancelQueuedJobError>> {
680    let local_var_configuration = configuration;
681
682    let local_var_client = &local_var_configuration.client;
683
684    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/queue/cancel/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
685    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
686
687    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
688        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
689    }
690    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
691        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
692    };
693    local_var_req_builder = local_var_req_builder.json(&cancel_queued_job_request);
694
695    let local_var_req = local_var_req_builder.build()?;
696    let local_var_resp = local_var_client.execute(local_var_req).await?;
697
698    let local_var_status = local_var_resp.status();
699    let local_var_content = local_var_resp.text().await?;
700
701    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
702        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
703    } else {
704        let local_var_entity: Option<CancelQueuedJobError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
705        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
706        Err(Error::ResponseError(local_var_error))
707    }
708}
709
710pub async fn cancel_selection(configuration: &configuration::Configuration, workspace: &str, request_body: Vec<String>, force_cancel: Option<bool>, all_workspaces: Option<bool>) -> Result<Vec<String>, Error<CancelSelectionError>> {
711    let local_var_configuration = configuration;
712
713    let local_var_client = &local_var_configuration.client;
714
715    let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/cancel_selection", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
716    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
717
718    if let Some(ref local_var_str) = force_cancel {
719        local_var_req_builder = local_var_req_builder.query(&[("force_cancel", &local_var_str.to_string())]);
720    }
721    if let Some(ref local_var_str) = all_workspaces {
722        local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
723    }
724    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
725        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
726    }
727    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
728        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
729    };
730    local_var_req_builder = local_var_req_builder.json(&request_body);
731
732    let local_var_req = local_var_req_builder.build()?;
733    let local_var_resp = local_var_client.execute(local_var_req).await?;
734
735    let local_var_status = local_var_resp.status();
736    let local_var_content = local_var_resp.text().await?;
737
738    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
739        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
740    } else {
741        let local_var_entity: Option<CancelSelectionError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
742        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
743        Err(Error::ResponseError(local_var_error))
744    }
745}
746
747/// A GET without an `Authorization: Bearer` header (and any HEAD) decides nothing: it answers 200 with an HTML confirm page whose form POSTs back to this URL, so a link scanner, mail gateway or chat unfurler that fetches the link cannot approve or cancel anything. Only a GET with a bearer token acts directly. The rest of this description applies to the action itself.  The signed link is the whole capability only for a step with no approval conditions. For a step that requires a logged-in approver (and so for self-approval or required groups), the caller must also be an identified user who passes those conditions: a POST with a session, or a request with a bearer token. A GET carrying only the session cookie (a link opened in a browser) is refused with 403, and a logged-out request with 401; both name the approval page. Before such a step waits (or when its definition cannot be read), its link is refused with 400. A flow-level link (including one for a loop/branch iteration or a subflow step) that could approve such a step is redeemable only by an admin. A token must carry `jobs:write`. 
748pub async fn cancel_suspended_job_get(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, approver: Option<&str>) -> Result<String, Error<CancelSuspendedJobGetError>> {
749    let local_var_configuration = configuration;
750
751    let local_var_client = &local_var_configuration.client;
752
753    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/cancel/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
754    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
755
756    if let Some(ref local_var_str) = approver {
757        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
758    }
759    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
760        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
761    }
762    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
763        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
764    };
765
766    let local_var_req = local_var_req_builder.build()?;
767    let local_var_resp = local_var_client.execute(local_var_req).await?;
768
769    let local_var_status = local_var_resp.status();
770    let local_var_content = local_var_resp.text().await?;
771
772    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
773        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
774    } else {
775        let local_var_entity: Option<CancelSuspendedJobGetError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
776        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
777        Err(Error::ResponseError(local_var_error))
778    }
779}
780
781/// The signed link is the whole capability only for a step with no approval conditions. For a step that requires a logged-in approver (and so for self-approval or required groups), the caller must also be an identified user who passes those conditions: a POST with a session, or a request with a bearer token. A GET carrying only the session cookie (a link opened in a browser) is refused with 403, and a logged-out request with 401; both name the approval page. Before such a step waits (or when its definition cannot be read), its link is refused with 400. A flow-level link (including one for a loop/branch iteration or a subflow step) that could approve such a step is redeemable only by an admin. A token must carry `jobs:write`. 
782pub async fn cancel_suspended_job_post(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, body: serde_json::Value, approver: Option<&str>) -> Result<String, Error<CancelSuspendedJobPostError>> {
783    let local_var_configuration = configuration;
784
785    let local_var_client = &local_var_configuration.client;
786
787    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/cancel/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
788    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
789
790    if let Some(ref local_var_str) = approver {
791        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
792    }
793    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
794        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
795    }
796    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
797        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
798    };
799    local_var_req_builder = local_var_req_builder.json(&body);
800
801    let local_var_req = local_var_req_builder.build()?;
802    let local_var_resp = local_var_client.execute(local_var_req).await?;
803
804    let local_var_status = local_var_resp.status();
805    let local_var_content = local_var_resp.text().await?;
806
807    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
808        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
809    } else {
810        let local_var_entity: Option<CancelSuspendedJobPostError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
811        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
812        Err(Error::ResponseError(local_var_error))
813    }
814}
815
816pub async fn count_completed_jobs(configuration: &configuration::Configuration, workspace: &str, completed_after_s_ago: Option<i32>, success: Option<bool>, tags: Option<&str>, all_workspaces: Option<bool>) -> Result<i32, Error<CountCompletedJobsError>> {
817    let local_var_configuration = configuration;
818
819    let local_var_client = &local_var_configuration.client;
820
821    let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/count_jobs", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
822    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
823
824    if let Some(ref local_var_str) = completed_after_s_ago {
825        local_var_req_builder = local_var_req_builder.query(&[("completed_after_s_ago", &local_var_str.to_string())]);
826    }
827    if let Some(ref local_var_str) = success {
828        local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
829    }
830    if let Some(ref local_var_str) = tags {
831        local_var_req_builder = local_var_req_builder.query(&[("tags", &local_var_str.to_string())]);
832    }
833    if let Some(ref local_var_str) = all_workspaces {
834        local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
835    }
836    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
837        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
838    }
839    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
840        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
841    };
842
843    let local_var_req = local_var_req_builder.build()?;
844    let local_var_resp = local_var_client.execute(local_var_req).await?;
845
846    let local_var_status = local_var_resp.status();
847    let local_var_content = local_var_resp.text().await?;
848
849    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
850        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
851    } else {
852        let local_var_entity: Option<CountCompletedJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
853        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
854        Err(Error::ResponseError(local_var_error))
855    }
856}
857
858pub async fn count_jobs_by_tag(configuration: &configuration::Configuration, horizon_secs: Option<i32>, workspace_id: Option<&str>) -> Result<Vec<models::CountJobsByTag200ResponseInner>, Error<CountJobsByTagError>> {
859    let local_var_configuration = configuration;
860
861    let local_var_client = &local_var_configuration.client;
862
863    let local_var_uri_str = format!("{}/jobs/completed/count_by_tag", local_var_configuration.base_path);
864    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
865
866    if let Some(ref local_var_str) = horizon_secs {
867        local_var_req_builder = local_var_req_builder.query(&[("horizon_secs", &local_var_str.to_string())]);
868    }
869    if let Some(ref local_var_str) = workspace_id {
870        local_var_req_builder = local_var_req_builder.query(&[("workspace_id", &local_var_str.to_string())]);
871    }
872    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
873        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
874    }
875    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
876        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
877    };
878
879    let local_var_req = local_var_req_builder.build()?;
880    let local_var_resp = local_var_client.execute(local_var_req).await?;
881
882    let local_var_status = local_var_resp.status();
883    let local_var_content = local_var_resp.text().await?;
884
885    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
886        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
887    } else {
888        let local_var_entity: Option<CountJobsByTagError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
889        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
890        Err(Error::ResponseError(local_var_error))
891    }
892}
893
894/// Minting is authorised (#1967). A job's own ephemeral token mints for that job with any `approver` label. Any other caller mints only in their own name (`approver` must be omitted or equal their username), needs `jobs:write` when the token is scoped, and, unless a workspace admin, only for the step its flow is waiting on and only if they could approve that step. 
895pub async fn create_job_signature(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, approver: Option<&str>) -> Result<String, Error<CreateJobSignatureError>> {
896    let local_var_configuration = configuration;
897
898    let local_var_client = &local_var_configuration.client;
899
900    let local_var_uri_str = format!("{}/w/{workspace}/jobs/job_signature/{id}/{resume_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id);
901    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
902
903    if let Some(ref local_var_str) = approver {
904        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
905    }
906    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
907        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
908    }
909    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
910        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
911    };
912
913    let local_var_req = local_var_req_builder.build()?;
914    let local_var_resp = local_var_client.execute(local_var_req).await?;
915
916    let local_var_status = local_var_resp.status();
917    let local_var_content = local_var_resp.text().await?;
918
919    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
920        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
921    } else {
922        let local_var_entity: Option<CreateJobSignatureError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
923        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
924        Err(Error::ResponseError(local_var_error))
925    }
926}
927
928pub async fn delete_completed_job(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<models::CompletedJob, Error<DeleteCompletedJobError>> {
929    let local_var_configuration = configuration;
930
931    let local_var_client = &local_var_configuration.client;
932
933    let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/delete/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
934    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
935
936    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
937        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
938    }
939    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
940        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
941    };
942
943    let local_var_req = local_var_req_builder.build()?;
944    let local_var_resp = local_var_client.execute(local_var_req).await?;
945
946    let local_var_status = local_var_resp.status();
947    let local_var_content = local_var_resp.text().await?;
948
949    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
950        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
951    } else {
952        let local_var_entity: Option<DeleteCompletedJobError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
953        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
954        Err(Error::ResponseError(local_var_error))
955    }
956}
957
958pub async fn delete_jobs(configuration: &configuration::Configuration, workspace: &str, uuid_colon_colon_uuid: Vec<uuid::Uuid>) -> Result<String, Error<DeleteJobsError>> {
959    let local_var_configuration = configuration;
960
961    let local_var_client = &local_var_configuration.client;
962
963    let local_var_uri_str = format!("{}/w/{workspace}/jobs/delete", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
964    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
965
966    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
967        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
968    }
969    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
970        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
971    };
972    local_var_req_builder = local_var_req_builder.json(&uuid_colon_colon_uuid);
973
974    let local_var_req = local_var_req_builder.build()?;
975    let local_var_resp = local_var_client.execute(local_var_req).await?;
976
977    let local_var_status = local_var_resp.status();
978    let local_var_content = local_var_resp.text().await?;
979
980    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
981        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
982    } else {
983        let local_var_entity: Option<DeleteJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
984        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
985        Err(Error::ResponseError(local_var_error))
986    }
987}
988
989pub async fn export_completed_jobs(configuration: &configuration::Configuration, workspace: &str, page: Option<i32>, per_page: Option<i32>) -> Result<Vec<models::ExportableCompletedJob>, Error<ExportCompletedJobsError>> {
990    let local_var_configuration = configuration;
991
992    let local_var_client = &local_var_configuration.client;
993
994    let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/export", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
995    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
996
997    if let Some(ref local_var_str) = page {
998        local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
999    }
1000    if let Some(ref local_var_str) = per_page {
1001        local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
1002    }
1003    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1004        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1005    }
1006    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1007        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1008    };
1009
1010    let local_var_req = local_var_req_builder.build()?;
1011    let local_var_resp = local_var_client.execute(local_var_req).await?;
1012
1013    let local_var_status = local_var_resp.status();
1014    let local_var_content = local_var_resp.text().await?;
1015
1016    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1017        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1018    } else {
1019        let local_var_entity: Option<ExportCompletedJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1020        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1021        Err(Error::ResponseError(local_var_error))
1022    }
1023}
1024
1025pub async fn export_queued_jobs(configuration: &configuration::Configuration, workspace: &str, page: Option<i32>, per_page: Option<i32>) -> Result<Vec<models::ExportableQueuedJob>, Error<ExportQueuedJobsError>> {
1026    let local_var_configuration = configuration;
1027
1028    let local_var_client = &local_var_configuration.client;
1029
1030    let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/export", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1031    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1032
1033    if let Some(ref local_var_str) = page {
1034        local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
1035    }
1036    if let Some(ref local_var_str) = per_page {
1037        local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
1038    }
1039    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1040        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1041    }
1042    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1043        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1044    };
1045
1046    let local_var_req = local_var_req_builder.build()?;
1047    let local_var_resp = local_var_client.execute(local_var_req).await?;
1048
1049    let local_var_status = local_var_resp.status();
1050    let local_var_content = local_var_resp.text().await?;
1051
1052    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1053        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1054    } else {
1055        let local_var_entity: Option<ExportQueuedJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1056        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1057        Err(Error::ResponseError(local_var_error))
1058    }
1059}
1060
1061pub async fn force_cancel_queued_job(configuration: &configuration::Configuration, workspace: &str, id: &str, cancel_queued_job_request: models::CancelQueuedJobRequest) -> Result<String, Error<ForceCancelQueuedJobError>> {
1062    let local_var_configuration = configuration;
1063
1064    let local_var_client = &local_var_configuration.client;
1065
1066    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/queue/force_cancel/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1067    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1068
1069    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1070        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1071    }
1072    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1073        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1074    };
1075    local_var_req_builder = local_var_req_builder.json(&cancel_queued_job_request);
1076
1077    let local_var_req = local_var_req_builder.build()?;
1078    let local_var_resp = local_var_client.execute(local_var_req).await?;
1079
1080    let local_var_status = local_var_resp.status();
1081    let local_var_content = local_var_resp.text().await?;
1082
1083    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1084        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1085    } else {
1086        let local_var_entity: Option<ForceCancelQueuedJobError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1087        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1088        Err(Error::ResponseError(local_var_error))
1089    }
1090}
1091
1092/// Get approval info for a suspended flow/Code Flow job. Returns form schema, approval rules, and whether the current user can approve. Either a valid token query parameter or an authenticated session is required. Without the token, the caller must be able to read the job or be eligible to approve the step it is waiting on; otherwise the answer is a 404, as for a missing job. 
1093pub async fn get_approval_info(configuration: &configuration::Configuration, workspace: &str, job_id: &str, token: Option<&str>) -> Result<models::GetApprovalInfo200Response, Error<GetApprovalInfoError>> {
1094    let local_var_configuration = configuration;
1095
1096    let local_var_client = &local_var_configuration.client;
1097
1098    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/flow/approval_info/{job_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), job_id=crate::apis::urlencode(job_id));
1099    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1100
1101    if let Some(ref local_var_str) = token {
1102        local_var_req_builder = local_var_req_builder.query(&[("token", &local_var_str.to_string())]);
1103    }
1104    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1105        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1106    }
1107    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1108        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1109    };
1110
1111    let local_var_req = local_var_req_builder.build()?;
1112    let local_var_resp = local_var_client.execute(local_var_req).await?;
1113
1114    let local_var_status = local_var_resp.status();
1115    let local_var_content = local_var_resp.text().await?;
1116
1117    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1118        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1119    } else {
1120        let local_var_entity: Option<GetApprovalInfoError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1121        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1122        Err(Error::ResponseError(local_var_error))
1123    }
1124}
1125
1126pub async fn get_completed_count(configuration: &configuration::Configuration, workspace: &str) -> Result<models::GetCompletedCount200Response, Error<GetCompletedCountError>> {
1127    let local_var_configuration = configuration;
1128
1129    let local_var_client = &local_var_configuration.client;
1130
1131    let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/count", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1132    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1133
1134    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1135        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1136    }
1137    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1138        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1139    };
1140
1141    let local_var_req = local_var_req_builder.build()?;
1142    let local_var_resp = local_var_client.execute(local_var_req).await?;
1143
1144    let local_var_status = local_var_resp.status();
1145    let local_var_content = local_var_resp.text().await?;
1146
1147    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1148        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1149    } else {
1150        let local_var_entity: Option<GetCompletedCountError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1151        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1152        Err(Error::ResponseError(local_var_error))
1153    }
1154}
1155
1156pub async fn get_completed_job(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<models::CompletedJob, Error<GetCompletedJobError>> {
1157    let local_var_configuration = configuration;
1158
1159    let local_var_client = &local_var_configuration.client;
1160
1161    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/completed/get/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1162    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1163
1164    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1165        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1166    }
1167    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1168        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1169    };
1170
1171    let local_var_req = local_var_req_builder.build()?;
1172    let local_var_resp = local_var_client.execute(local_var_req).await?;
1173
1174    let local_var_status = local_var_resp.status();
1175    let local_var_content = local_var_resp.text().await?;
1176
1177    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1178        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1179    } else {
1180        let local_var_entity: Option<GetCompletedJobError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1181        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1182        Err(Error::ResponseError(local_var_error))
1183    }
1184}
1185
1186pub async fn get_completed_job_logs_tail(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<String, Error<GetCompletedJobLogsTailError>> {
1187    let local_var_configuration = configuration;
1188
1189    let local_var_client = &local_var_configuration.client;
1190
1191    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_completed_logs_tail/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1192    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1193
1194    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1195        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1196    }
1197    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1198        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1199    };
1200
1201    let local_var_req = local_var_req_builder.build()?;
1202    let local_var_resp = local_var_client.execute(local_var_req).await?;
1203
1204    let local_var_status = local_var_resp.status();
1205    let local_var_content = local_var_resp.text().await?;
1206
1207    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1208        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1209    } else {
1210        let local_var_entity: Option<GetCompletedJobLogsTailError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1211        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1212        Err(Error::ResponseError(local_var_error))
1213    }
1214}
1215
1216pub async fn get_completed_job_result(configuration: &configuration::Configuration, workspace: &str, id: &str, suspended_job: Option<&str>, resume_id: Option<i32>, secret: Option<&str>, approver: Option<&str>) -> Result<serde_json::Value, Error<GetCompletedJobResultError>> {
1217    let local_var_configuration = configuration;
1218
1219    let local_var_client = &local_var_configuration.client;
1220
1221    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/completed/get_result/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1222    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1223
1224    if let Some(ref local_var_str) = suspended_job {
1225        local_var_req_builder = local_var_req_builder.query(&[("suspended_job", &local_var_str.to_string())]);
1226    }
1227    if let Some(ref local_var_str) = resume_id {
1228        local_var_req_builder = local_var_req_builder.query(&[("resume_id", &local_var_str.to_string())]);
1229    }
1230    if let Some(ref local_var_str) = secret {
1231        local_var_req_builder = local_var_req_builder.query(&[("secret", &local_var_str.to_string())]);
1232    }
1233    if let Some(ref local_var_str) = approver {
1234        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1235    }
1236    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1237        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1238    }
1239    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1240        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1241    };
1242
1243    let local_var_req = local_var_req_builder.build()?;
1244    let local_var_resp = local_var_client.execute(local_var_req).await?;
1245
1246    let local_var_status = local_var_resp.status();
1247    let local_var_content = local_var_resp.text().await?;
1248
1249    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1250        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1251    } else {
1252        let local_var_entity: Option<GetCompletedJobResultError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1253        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1254        Err(Error::ResponseError(local_var_error))
1255    }
1256}
1257
1258pub async fn get_completed_job_result_maybe(configuration: &configuration::Configuration, workspace: &str, id: &str, get_started: Option<bool>) -> Result<models::GetCompletedJobResultMaybe200Response, Error<GetCompletedJobResultMaybeError>> {
1259    let local_var_configuration = configuration;
1260
1261    let local_var_client = &local_var_configuration.client;
1262
1263    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/completed/get_result_maybe/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1264    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1265
1266    if let Some(ref local_var_str) = get_started {
1267        local_var_req_builder = local_var_req_builder.query(&[("get_started", &local_var_str.to_string())]);
1268    }
1269    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1270        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1271    }
1272    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1273        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1274    };
1275
1276    let local_var_req = local_var_req_builder.build()?;
1277    let local_var_resp = local_var_client.execute(local_var_req).await?;
1278
1279    let local_var_status = local_var_resp.status();
1280    let local_var_content = local_var_resp.text().await?;
1281
1282    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1283        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1284    } else {
1285        let local_var_entity: Option<GetCompletedJobResultMaybeError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1286        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1287        Err(Error::ResponseError(local_var_error))
1288    }
1289}
1290
1291pub async fn get_completed_job_timing(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<models::GetCompletedJobTiming200Response, Error<GetCompletedJobTimingError>> {
1292    let local_var_configuration = configuration;
1293
1294    let local_var_client = &local_var_configuration.client;
1295
1296    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/completed/get_timing/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1297    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1298
1299    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1300        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1301    }
1302    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1303        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1304    };
1305
1306    let local_var_req = local_var_req_builder.build()?;
1307    let local_var_resp = local_var_client.execute(local_var_req).await?;
1308
1309    let local_var_status = local_var_resp.status();
1310    let local_var_content = local_var_resp.text().await?;
1311
1312    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1313        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1314    } else {
1315        let local_var_entity: Option<GetCompletedJobTimingError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1316        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1317        Err(Error::ResponseError(local_var_error))
1318    }
1319}
1320
1321pub async fn get_db_clock(configuration: &configuration::Configuration, ) -> Result<i32, Error<GetDbClockError>> {
1322    let local_var_configuration = configuration;
1323
1324    let local_var_client = &local_var_configuration.client;
1325
1326    let local_var_uri_str = format!("{}/jobs/db_clock", local_var_configuration.base_path);
1327    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1328
1329    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1330        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1331    }
1332    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1333        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1334    };
1335
1336    let local_var_req = local_var_req_builder.build()?;
1337    let local_var_resp = local_var_client.execute(local_var_req).await?;
1338
1339    let local_var_status = local_var_resp.status();
1340    let local_var_content = local_var_resp.text().await?;
1341
1342    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1343        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1344    } else {
1345        let local_var_entity: Option<GetDbClockError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1346        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1347        Err(Error::ResponseError(local_var_error))
1348    }
1349}
1350
1351pub async fn get_flow_all_logs(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<String, Error<GetFlowAllLogsError>> {
1352    let local_var_configuration = configuration;
1353
1354    let local_var_client = &local_var_configuration.client;
1355
1356    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_flow_all_logs/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1357    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1358
1359    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1360        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1361    }
1362    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1363        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1364    };
1365
1366    let local_var_req = local_var_req_builder.build()?;
1367    let local_var_resp = local_var_client.execute(local_var_req).await?;
1368
1369    let local_var_status = local_var_resp.status();
1370    let local_var_content = local_var_resp.text().await?;
1371
1372    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1373        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1374    } else {
1375        let local_var_entity: Option<GetFlowAllLogsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1376        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1377        Err(Error::ResponseError(local_var_error))
1378    }
1379}
1380
1381pub async fn get_flow_debug_info(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<serde_json::Value, Error<GetFlowDebugInfoError>> {
1382    let local_var_configuration = configuration;
1383
1384    let local_var_client = &local_var_configuration.client;
1385
1386    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_flow_debug_info/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1387    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1388
1389    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1390        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1391    }
1392    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1393        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1394    };
1395
1396    let local_var_req = local_var_req_builder.build()?;
1397    let local_var_resp = local_var_client.execute(local_var_req).await?;
1398
1399    let local_var_status = local_var_resp.status();
1400    let local_var_content = local_var_resp.text().await?;
1401
1402    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1403        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1404    } else {
1405        let local_var_entity: Option<GetFlowDebugInfoError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1406        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1407        Err(Error::ResponseError(local_var_error))
1408    }
1409}
1410
1411pub async fn get_flow_user_state(configuration: &configuration::Configuration, workspace: &str, id: &str, key: &str) -> Result<serde_json::Value, Error<GetFlowUserStateError>> {
1412    let local_var_configuration = configuration;
1413
1414    let local_var_client = &local_var_configuration.client;
1415
1416    let local_var_uri_str = format!("{}/w/{workspace}/jobs/flow/user_states/{id}/{key}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), key=crate::apis::urlencode(key));
1417    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1418
1419    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1420        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1421    }
1422    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1423        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1424    };
1425
1426    let local_var_req = local_var_req_builder.build()?;
1427    let local_var_resp = local_var_client.execute(local_var_req).await?;
1428
1429    let local_var_status = local_var_resp.status();
1430    let local_var_content = local_var_resp.text().await?;
1431
1432    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1433        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1434    } else {
1435        let local_var_entity: Option<GetFlowUserStateError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1436        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1437        Err(Error::ResponseError(local_var_error))
1438    }
1439}
1440
1441pub async fn get_job(configuration: &configuration::Configuration, workspace: &str, id: &str, no_logs: Option<bool>, no_code: Option<bool>, approval_token: Option<&str>) -> Result<models::Job, Error<GetJobError>> {
1442    let local_var_configuration = configuration;
1443
1444    let local_var_client = &local_var_configuration.client;
1445
1446    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1447    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1448
1449    if let Some(ref local_var_str) = no_logs {
1450        local_var_req_builder = local_var_req_builder.query(&[("no_logs", &local_var_str.to_string())]);
1451    }
1452    if let Some(ref local_var_str) = no_code {
1453        local_var_req_builder = local_var_req_builder.query(&[("no_code", &local_var_str.to_string())]);
1454    }
1455    if let Some(ref local_var_str) = approval_token {
1456        local_var_req_builder = local_var_req_builder.query(&[("approval_token", &local_var_str.to_string())]);
1457    }
1458    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1459        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1460    }
1461    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1462        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1463    };
1464
1465    let local_var_req = local_var_req_builder.build()?;
1466    let local_var_resp = local_var_client.execute(local_var_req).await?;
1467
1468    let local_var_status = local_var_resp.status();
1469    let local_var_content = local_var_resp.text().await?;
1470
1471    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1472        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1473    } else {
1474        let local_var_entity: Option<GetJobError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1475        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1476        Err(Error::ResponseError(local_var_error))
1477    }
1478}
1479
1480pub async fn get_job_args(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<serde_json::Value, Error<GetJobArgsError>> {
1481    let local_var_configuration = configuration;
1482
1483    let local_var_client = &local_var_configuration.client;
1484
1485    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_args/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1486    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1487
1488    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1489        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1490    }
1491    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1492        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1493    };
1494
1495    let local_var_req = local_var_req_builder.build()?;
1496    let local_var_resp = local_var_client.execute(local_var_req).await?;
1497
1498    let local_var_status = local_var_resp.status();
1499    let local_var_content = local_var_resp.text().await?;
1500
1501    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1502        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1503    } else {
1504        let local_var_entity: Option<GetJobArgsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1505        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1506        Err(Error::ResponseError(local_var_error))
1507    }
1508}
1509
1510pub async fn get_job_logs(configuration: &configuration::Configuration, workspace: &str, id: &str, remove_ansi_warnings: Option<bool>) -> Result<String, Error<GetJobLogsError>> {
1511    let local_var_configuration = configuration;
1512
1513    let local_var_client = &local_var_configuration.client;
1514
1515    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_logs/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1516    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1517
1518    if let Some(ref local_var_str) = remove_ansi_warnings {
1519        local_var_req_builder = local_var_req_builder.query(&[("remove_ansi_warnings", &local_var_str.to_string())]);
1520    }
1521    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1522        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1523    }
1524    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1525        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1526    };
1527
1528    let local_var_req = local_var_req_builder.build()?;
1529    let local_var_resp = local_var_client.execute(local_var_req).await?;
1530
1531    let local_var_status = local_var_resp.status();
1532    let local_var_content = local_var_resp.text().await?;
1533
1534    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1535        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1536    } else {
1537        let local_var_entity: Option<GetJobLogsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1538        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1539        Err(Error::ResponseError(local_var_error))
1540    }
1541}
1542
1543pub async fn get_job_updates(configuration: &configuration::Configuration, workspace: &str, id: &str, running: Option<bool>, log_offset: Option<i32>, stream_offset: Option<i32>, get_progress: Option<bool>, no_logs: Option<bool>) -> Result<models::GetJobUpdates200Response, Error<GetJobUpdatesError>> {
1544    let local_var_configuration = configuration;
1545
1546    let local_var_client = &local_var_configuration.client;
1547
1548    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/getupdate/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1549    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1550
1551    if let Some(ref local_var_str) = running {
1552        local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
1553    }
1554    if let Some(ref local_var_str) = log_offset {
1555        local_var_req_builder = local_var_req_builder.query(&[("log_offset", &local_var_str.to_string())]);
1556    }
1557    if let Some(ref local_var_str) = stream_offset {
1558        local_var_req_builder = local_var_req_builder.query(&[("stream_offset", &local_var_str.to_string())]);
1559    }
1560    if let Some(ref local_var_str) = get_progress {
1561        local_var_req_builder = local_var_req_builder.query(&[("get_progress", &local_var_str.to_string())]);
1562    }
1563    if let Some(ref local_var_str) = no_logs {
1564        local_var_req_builder = local_var_req_builder.query(&[("no_logs", &local_var_str.to_string())]);
1565    }
1566    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1567        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1568    }
1569    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1570        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1571    };
1572
1573    let local_var_req = local_var_req_builder.build()?;
1574    let local_var_resp = local_var_client.execute(local_var_req).await?;
1575
1576    let local_var_status = local_var_resp.status();
1577    let local_var_content = local_var_resp.text().await?;
1578
1579    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1580        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1581    } else {
1582        let local_var_entity: Option<GetJobUpdatesError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1583        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1584        Err(Error::ResponseError(local_var_error))
1585    }
1586}
1587
1588pub async fn get_job_updates_sse(configuration: &configuration::Configuration, workspace: &str, id: &str, running: Option<bool>, log_offset: Option<i32>, stream_offset: Option<i32>, get_progress: Option<bool>, only_result: Option<bool>, no_logs: Option<bool>, fast: Option<bool>) -> Result<String, Error<GetJobUpdatesSseError>> {
1589    let local_var_configuration = configuration;
1590
1591    let local_var_client = &local_var_configuration.client;
1592
1593    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/getupdate_sse/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1594    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1595
1596    if let Some(ref local_var_str) = running {
1597        local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
1598    }
1599    if let Some(ref local_var_str) = log_offset {
1600        local_var_req_builder = local_var_req_builder.query(&[("log_offset", &local_var_str.to_string())]);
1601    }
1602    if let Some(ref local_var_str) = stream_offset {
1603        local_var_req_builder = local_var_req_builder.query(&[("stream_offset", &local_var_str.to_string())]);
1604    }
1605    if let Some(ref local_var_str) = get_progress {
1606        local_var_req_builder = local_var_req_builder.query(&[("get_progress", &local_var_str.to_string())]);
1607    }
1608    if let Some(ref local_var_str) = only_result {
1609        local_var_req_builder = local_var_req_builder.query(&[("only_result", &local_var_str.to_string())]);
1610    }
1611    if let Some(ref local_var_str) = no_logs {
1612        local_var_req_builder = local_var_req_builder.query(&[("no_logs", &local_var_str.to_string())]);
1613    }
1614    if let Some(ref local_var_str) = fast {
1615        local_var_req_builder = local_var_req_builder.query(&[("fast", &local_var_str.to_string())]);
1616    }
1617    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1618        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1619    }
1620    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1621        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1622    };
1623
1624    let local_var_req = local_var_req_builder.build()?;
1625    let local_var_resp = local_var_client.execute(local_var_req).await?;
1626
1627    let local_var_status = local_var_resp.status();
1628    let local_var_content = local_var_resp.text().await?;
1629
1630    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1631        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1632    } else {
1633        let local_var_entity: Option<GetJobUpdatesSseError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1634        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1635        Err(Error::ResponseError(local_var_error))
1636    }
1637}
1638
1639/// `path` is `{job_id}/{file}.txt`. Requires a member of the workspace that owns the job; any other caller gets the same 404 as for a job that does not exist. 
1640pub async fn get_log_file_from_store(configuration: &configuration::Configuration, workspace: &str, path: &str) -> Result<String, Error<GetLogFileFromStoreError>> {
1641    let local_var_configuration = configuration;
1642
1643    let local_var_client = &local_var_configuration.client;
1644
1645    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_log_file/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
1646    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1647
1648    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1649        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1650    }
1651    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1652        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1653    };
1654
1655    let local_var_req = local_var_req_builder.build()?;
1656    let local_var_resp = local_var_client.execute(local_var_req).await?;
1657
1658    let local_var_status = local_var_resp.status();
1659    let local_var_content = local_var_resp.text().await?;
1660
1661    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1662        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1663    } else {
1664        let local_var_entity: Option<GetLogFileFromStoreError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1665        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1666        Err(Error::ResponseError(local_var_error))
1667    }
1668}
1669
1670pub async fn get_queue_count(configuration: &configuration::Configuration, workspace: &str, all_workspaces: Option<bool>) -> Result<models::GetQueueCount200Response, Error<GetQueueCountError>> {
1671    let local_var_configuration = configuration;
1672
1673    let local_var_client = &local_var_configuration.client;
1674
1675    let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/count", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1676    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1677
1678    if let Some(ref local_var_str) = all_workspaces {
1679        local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
1680    }
1681    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1682        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1683    }
1684    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1685        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1686    };
1687
1688    let local_var_req = local_var_req_builder.build()?;
1689    let local_var_resp = local_var_client.execute(local_var_req).await?;
1690
1691    let local_var_status = local_var_resp.status();
1692    let local_var_content = local_var_resp.text().await?;
1693
1694    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1695        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1696    } else {
1697        let local_var_entity: Option<GetQueueCountError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1698        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1699        Err(Error::ResponseError(local_var_error))
1700    }
1701}
1702
1703pub async fn get_queue_position(configuration: &configuration::Configuration, workspace: &str, scheduled_for: i32) -> Result<models::GetQueuePosition200Response, Error<GetQueuePositionError>> {
1704    let local_var_configuration = configuration;
1705
1706    let local_var_client = &local_var_configuration.client;
1707
1708    let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/position/{scheduled_for}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), scheduled_for=scheduled_for);
1709    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1710
1711    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1712        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1713    }
1714    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1715        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1716    };
1717
1718    let local_var_req = local_var_req_builder.build()?;
1719    let local_var_resp = local_var_client.execute(local_var_req).await?;
1720
1721    let local_var_status = local_var_resp.status();
1722    let local_var_content = local_var_resp.text().await?;
1723
1724    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1725        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1726    } else {
1727        let local_var_entity: Option<GetQueuePositionError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1728        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1729        Err(Error::ResponseError(local_var_error))
1730    }
1731}
1732
1733/// Minting is authorised (#1967). A job's own ephemeral token mints for that job with any `approver` label. Any other caller mints only in their own name (`approver` must be omitted or equal their username), needs `jobs:write` when the token is scoped, and, unless a workspace admin, only for the step its flow is waiting on and only if they could approve that step. A non-admin minting in their own name gets no flow-level link and an `approvalPage` without an approval token. 
1734pub async fn get_resume_urls(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, approver: Option<&str>, flow_level: Option<bool>) -> Result<models::GetResumeUrls200Response, Error<GetResumeUrlsError>> {
1735    let local_var_configuration = configuration;
1736
1737    let local_var_client = &local_var_configuration.client;
1738
1739    let local_var_uri_str = format!("{}/w/{workspace}/jobs/resume_urls/{id}/{resume_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id);
1740    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1741
1742    if let Some(ref local_var_str) = approver {
1743        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1744    }
1745    if let Some(ref local_var_str) = flow_level {
1746        local_var_req_builder = local_var_req_builder.query(&[("flow_level", &local_var_str.to_string())]);
1747    }
1748    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1749        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1750    }
1751    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1752        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1753    };
1754
1755    let local_var_req = local_var_req_builder.build()?;
1756    let local_var_resp = local_var_client.execute(local_var_req).await?;
1757
1758    let local_var_status = local_var_resp.status();
1759    let local_var_content = local_var_resp.text().await?;
1760
1761    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1762        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1763    } else {
1764        let local_var_entity: Option<GetResumeUrlsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1765        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1766        Err(Error::ResponseError(local_var_error))
1767    }
1768}
1769
1770pub async fn get_root_job_id(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<String, Error<GetRootJobIdError>> {
1771    let local_var_configuration = configuration;
1772
1773    let local_var_client = &local_var_configuration.client;
1774
1775    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_root_job_id/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1776    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1777
1778    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1779        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1780    }
1781    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1782        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1783    };
1784
1785    let local_var_req = local_var_req_builder.build()?;
1786    let local_var_resp = local_var_client.execute(local_var_req).await?;
1787
1788    let local_var_status = local_var_resp.status();
1789    let local_var_content = local_var_resp.text().await?;
1790
1791    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1792        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1793    } else {
1794        let local_var_entity: Option<GetRootJobIdError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1795        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1796        Err(Error::ResponseError(local_var_error))
1797    }
1798}
1799
1800pub async fn get_scheduled_for(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<i32, Error<GetScheduledForError>> {
1801    let local_var_configuration = configuration;
1802
1803    let local_var_client = &local_var_configuration.client;
1804
1805    let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/scheduled_for/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1806    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1807
1808    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1809        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1810    }
1811    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1812        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1813    };
1814
1815    let local_var_req = local_var_req_builder.build()?;
1816    let local_var_resp = local_var_client.execute(local_var_req).await?;
1817
1818    let local_var_status = local_var_resp.status();
1819    let local_var_content = local_var_resp.text().await?;
1820
1821    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1822        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1823    } else {
1824        let local_var_entity: Option<GetScheduledForError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1825        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1826        Err(Error::ResponseError(local_var_error))
1827    }
1828}
1829
1830pub async fn get_slack_approval_payload(configuration: &configuration::Configuration, workspace: &str, id: &str, slack_resource_path: &str, channel_id: &str, flow_step_id: &str, approver: Option<&str>, message: Option<&str>, default_args_json: Option<&str>, dynamic_enums_json: Option<&str>, resume_button_text: Option<&str>, cancel_button_text: Option<&str>) -> Result<(), Error<GetSlackApprovalPayloadError>> {
1831    let local_var_configuration = configuration;
1832
1833    let local_var_client = &local_var_configuration.client;
1834
1835    let local_var_uri_str = format!("{}/w/{workspace}/jobs/slack_approval/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1836    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1837
1838    if let Some(ref local_var_str) = approver {
1839        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1840    }
1841    if let Some(ref local_var_str) = message {
1842        local_var_req_builder = local_var_req_builder.query(&[("message", &local_var_str.to_string())]);
1843    }
1844    local_var_req_builder = local_var_req_builder.query(&[("slack_resource_path", &slack_resource_path.to_string())]);
1845    local_var_req_builder = local_var_req_builder.query(&[("channel_id", &channel_id.to_string())]);
1846    local_var_req_builder = local_var_req_builder.query(&[("flow_step_id", &flow_step_id.to_string())]);
1847    if let Some(ref local_var_str) = default_args_json {
1848        local_var_req_builder = local_var_req_builder.query(&[("default_args_json", &local_var_str.to_string())]);
1849    }
1850    if let Some(ref local_var_str) = dynamic_enums_json {
1851        local_var_req_builder = local_var_req_builder.query(&[("dynamic_enums_json", &local_var_str.to_string())]);
1852    }
1853    if let Some(ref local_var_str) = resume_button_text {
1854        local_var_req_builder = local_var_req_builder.query(&[("resume_button_text", &local_var_str.to_string())]);
1855    }
1856    if let Some(ref local_var_str) = cancel_button_text {
1857        local_var_req_builder = local_var_req_builder.query(&[("cancel_button_text", &local_var_str.to_string())]);
1858    }
1859    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1860        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1861    }
1862    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1863        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1864    };
1865
1866    let local_var_req = local_var_req_builder.build()?;
1867    let local_var_resp = local_var_client.execute(local_var_req).await?;
1868
1869    let local_var_status = local_var_resp.status();
1870    let local_var_content = local_var_resp.text().await?;
1871
1872    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1873        Ok(())
1874    } else {
1875        let local_var_entity: Option<GetSlackApprovalPayloadError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1876        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1877        Err(Error::ResponseError(local_var_error))
1878    }
1879}
1880
1881pub async fn get_started_at_by_ids(configuration: &configuration::Configuration, workspace: &str, request_body: Vec<String>) -> Result<Vec<String>, Error<GetStartedAtByIdsError>> {
1882    let local_var_configuration = configuration;
1883
1884    let local_var_client = &local_var_configuration.client;
1885
1886    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/queue/get_started_at_by_ids", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1887    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1888
1889    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1890        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1891    }
1892    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1893        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1894    };
1895    local_var_req_builder = local_var_req_builder.json(&request_body);
1896
1897    let local_var_req = local_var_req_builder.build()?;
1898    let local_var_resp = local_var_client.execute(local_var_req).await?;
1899
1900    let local_var_status = local_var_resp.status();
1901    let local_var_content = local_var_resp.text().await?;
1902
1903    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1904        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1905    } else {
1906        let local_var_entity: Option<GetStartedAtByIdsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1907        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1908        Err(Error::ResponseError(local_var_error))
1909    }
1910}
1911
1912pub async fn get_suspended_job_flow(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, approver: Option<&str>) -> Result<models::GetSuspendedJobFlow200Response, Error<GetSuspendedJobFlowError>> {
1913    let local_var_configuration = configuration;
1914
1915    let local_var_client = &local_var_configuration.client;
1916
1917    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_flow/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
1918    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1919
1920    if let Some(ref local_var_str) = approver {
1921        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1922    }
1923    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1924        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1925    }
1926    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1927        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1928    };
1929
1930    let local_var_req = local_var_req_builder.build()?;
1931    let local_var_resp = local_var_client.execute(local_var_req).await?;
1932
1933    let local_var_status = local_var_resp.status();
1934    let local_var_content = local_var_resp.text().await?;
1935
1936    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1937        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
1938    } else {
1939        let local_var_entity: Option<GetSuspendedJobFlowError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1940        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1941        Err(Error::ResponseError(local_var_error))
1942    }
1943}
1944
1945/// Posts a message to the workspace's connected Microsoft Teams team/channel with a link to the browser approval page -- there is no in-Teams interactive button (that needs a registered Azure Bot Service app). `channel_name` is resolved against the connected team's channels by display name. 
1946pub async fn get_teams_approval_payload(configuration: &configuration::Configuration, workspace: &str, id: &str, channel_name: &str, flow_step_id: &str, approver: Option<&str>, message: Option<&str>, resume_id: Option<i32>) -> Result<(), Error<GetTeamsApprovalPayloadError>> {
1947    let local_var_configuration = configuration;
1948
1949    let local_var_client = &local_var_configuration.client;
1950
1951    let local_var_uri_str = format!("{}/w/{workspace}/jobs/teams_approval/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1952    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1953
1954    if let Some(ref local_var_str) = approver {
1955        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1956    }
1957    if let Some(ref local_var_str) = message {
1958        local_var_req_builder = local_var_req_builder.query(&[("message", &local_var_str.to_string())]);
1959    }
1960    local_var_req_builder = local_var_req_builder.query(&[("channel_name", &channel_name.to_string())]);
1961    local_var_req_builder = local_var_req_builder.query(&[("flow_step_id", &flow_step_id.to_string())]);
1962    if let Some(ref local_var_str) = resume_id {
1963        local_var_req_builder = local_var_req_builder.query(&[("resume_id", &local_var_str.to_string())]);
1964    }
1965    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1966        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1967    }
1968    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1969        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1970    };
1971
1972    let local_var_req = local_var_req_builder.build()?;
1973    let local_var_resp = local_var_client.execute(local_var_req).await?;
1974
1975    let local_var_status = local_var_resp.status();
1976    let local_var_content = local_var_resp.text().await?;
1977
1978    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1979        Ok(())
1980    } else {
1981        let local_var_entity: Option<GetTeamsApprovalPayloadError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
1982        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1983        Err(Error::ResponseError(local_var_error))
1984    }
1985}
1986
1987pub async fn import_completed_jobs(configuration: &configuration::Configuration, workspace: &str, exportable_completed_job: Vec<models::ExportableCompletedJob>) -> Result<String, Error<ImportCompletedJobsError>> {
1988    let local_var_configuration = configuration;
1989
1990    let local_var_client = &local_var_configuration.client;
1991
1992    let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/import", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1993    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1994
1995    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1996        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1997    }
1998    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1999        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2000    };
2001    local_var_req_builder = local_var_req_builder.json(&exportable_completed_job);
2002
2003    let local_var_req = local_var_req_builder.build()?;
2004    let local_var_resp = local_var_client.execute(local_var_req).await?;
2005
2006    let local_var_status = local_var_resp.status();
2007    let local_var_content = local_var_resp.text().await?;
2008
2009    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2010        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2011    } else {
2012        let local_var_entity: Option<ImportCompletedJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2013        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2014        Err(Error::ResponseError(local_var_error))
2015    }
2016}
2017
2018pub async fn import_queued_jobs(configuration: &configuration::Configuration, workspace: &str, exportable_queued_job: Vec<models::ExportableQueuedJob>) -> Result<String, Error<ImportQueuedJobsError>> {
2019    let local_var_configuration = configuration;
2020
2021    let local_var_client = &local_var_configuration.client;
2022
2023    let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/import", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2024    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2025
2026    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2027        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2028    }
2029    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2030        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2031    };
2032    local_var_req_builder = local_var_req_builder.json(&exportable_queued_job);
2033
2034    let local_var_req = local_var_req_builder.build()?;
2035    let local_var_resp = local_var_client.execute(local_var_req).await?;
2036
2037    let local_var_status = local_var_resp.status();
2038    let local_var_content = local_var_resp.text().await?;
2039
2040    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2041        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2042    } else {
2043        let local_var_entity: Option<ImportQueuedJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2044        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2045        Err(Error::ResponseError(local_var_error))
2046    }
2047}
2048
2049pub async fn list_completed_jobs(configuration: &configuration::Configuration, workspace: &str, order_desc: Option<bool>, created_by: Option<&str>, label: Option<&str>, worker: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, success: Option<bool>, job_kinds: Option<&str>, args: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, tag: Option<&str>, page: Option<i32>, per_page: Option<i32>, is_skipped: Option<bool>, is_flow_step: Option<bool>, has_null_parent: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<models::CompletedJob>, Error<ListCompletedJobsError>> {
2050    let local_var_configuration = configuration;
2051
2052    let local_var_client = &local_var_configuration.client;
2053
2054    let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/list", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2055    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2056
2057    if let Some(ref local_var_str) = order_desc {
2058        local_var_req_builder = local_var_req_builder.query(&[("order_desc", &local_var_str.to_string())]);
2059    }
2060    if let Some(ref local_var_str) = created_by {
2061        local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
2062    }
2063    if let Some(ref local_var_str) = label {
2064        local_var_req_builder = local_var_req_builder.query(&[("label", &local_var_str.to_string())]);
2065    }
2066    if let Some(ref local_var_str) = worker {
2067        local_var_req_builder = local_var_req_builder.query(&[("worker", &local_var_str.to_string())]);
2068    }
2069    if let Some(ref local_var_str) = parent_job {
2070        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2071    }
2072    if let Some(ref local_var_str) = script_path_exact {
2073        local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
2074    }
2075    if let Some(ref local_var_str) = script_path_start {
2076        local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
2077    }
2078    if let Some(ref local_var_str) = schedule_path {
2079        local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
2080    }
2081    if let Some(ref local_var_str) = script_hash {
2082        local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
2083    }
2084    if let Some(ref local_var_str) = started_before {
2085        local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
2086    }
2087    if let Some(ref local_var_str) = started_after {
2088        local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
2089    }
2090    if let Some(ref local_var_str) = success {
2091        local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
2092    }
2093    if let Some(ref local_var_str) = job_kinds {
2094        local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
2095    }
2096    if let Some(ref local_var_str) = args {
2097        local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
2098    }
2099    if let Some(ref local_var_str) = result {
2100        local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
2101    }
2102    if let Some(ref local_var_str) = allow_wildcards {
2103        local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
2104    }
2105    if let Some(ref local_var_str) = tag {
2106        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2107    }
2108    if let Some(ref local_var_str) = page {
2109        local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
2110    }
2111    if let Some(ref local_var_str) = per_page {
2112        local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
2113    }
2114    if let Some(ref local_var_str) = is_skipped {
2115        local_var_req_builder = local_var_req_builder.query(&[("is_skipped", &local_var_str.to_string())]);
2116    }
2117    if let Some(ref local_var_str) = is_flow_step {
2118        local_var_req_builder = local_var_req_builder.query(&[("is_flow_step", &local_var_str.to_string())]);
2119    }
2120    if let Some(ref local_var_str) = has_null_parent {
2121        local_var_req_builder = local_var_req_builder.query(&[("has_null_parent", &local_var_str.to_string())]);
2122    }
2123    if let Some(ref local_var_str) = is_not_schedule {
2124        local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
2125    }
2126    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2127        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2128    }
2129    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2130        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2131    };
2132
2133    let local_var_req = local_var_req_builder.build()?;
2134    let local_var_resp = local_var_client.execute(local_var_req).await?;
2135
2136    let local_var_status = local_var_resp.status();
2137    let local_var_content = local_var_resp.text().await?;
2138
2139    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2140        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2141    } else {
2142        let local_var_entity: Option<ListCompletedJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2143        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2144        Err(Error::ResponseError(local_var_error))
2145    }
2146}
2147
2148pub async fn list_extended_jobs(configuration: &configuration::Configuration, workspace: &str, concurrency_key: Option<&str>, row_limit: Option<f64>, created_by: Option<&str>, label: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, running: Option<bool>, scheduled_for_before_now: Option<bool>, completed_before: Option<String>, completed_after: Option<String>, created_before_queue: Option<String>, created_after_queue: Option<String>, job_kinds: Option<&str>, args: Option<&str>, tag: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, page: Option<i32>, per_page: Option<i32>, trigger_kind: Option<&str>, is_skipped: Option<bool>, is_flow_step: Option<bool>, has_null_parent: Option<bool>, success: Option<bool>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<models::ExtendedJobs, Error<ListExtendedJobsError>> {
2149    let local_var_configuration = configuration;
2150
2151    let local_var_client = &local_var_configuration.client;
2152
2153    let local_var_uri_str = format!("{}/w/{workspace}/concurrency_groups/list_jobs", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2154    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2155
2156    if let Some(ref local_var_str) = concurrency_key {
2157        local_var_req_builder = local_var_req_builder.query(&[("concurrency_key", &local_var_str.to_string())]);
2158    }
2159    if let Some(ref local_var_str) = row_limit {
2160        local_var_req_builder = local_var_req_builder.query(&[("row_limit", &local_var_str.to_string())]);
2161    }
2162    if let Some(ref local_var_str) = created_by {
2163        local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
2164    }
2165    if let Some(ref local_var_str) = label {
2166        local_var_req_builder = local_var_req_builder.query(&[("label", &local_var_str.to_string())]);
2167    }
2168    if let Some(ref local_var_str) = parent_job {
2169        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2170    }
2171    if let Some(ref local_var_str) = script_path_exact {
2172        local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
2173    }
2174    if let Some(ref local_var_str) = script_path_start {
2175        local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
2176    }
2177    if let Some(ref local_var_str) = schedule_path {
2178        local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
2179    }
2180    if let Some(ref local_var_str) = script_hash {
2181        local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
2182    }
2183    if let Some(ref local_var_str) = started_before {
2184        local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
2185    }
2186    if let Some(ref local_var_str) = started_after {
2187        local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
2188    }
2189    if let Some(ref local_var_str) = running {
2190        local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
2191    }
2192    if let Some(ref local_var_str) = scheduled_for_before_now {
2193        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
2194    }
2195    if let Some(ref local_var_str) = completed_before {
2196        local_var_req_builder = local_var_req_builder.query(&[("completed_before", &local_var_str.to_string())]);
2197    }
2198    if let Some(ref local_var_str) = completed_after {
2199        local_var_req_builder = local_var_req_builder.query(&[("completed_after", &local_var_str.to_string())]);
2200    }
2201    if let Some(ref local_var_str) = created_before_queue {
2202        local_var_req_builder = local_var_req_builder.query(&[("created_before_queue", &local_var_str.to_string())]);
2203    }
2204    if let Some(ref local_var_str) = created_after_queue {
2205        local_var_req_builder = local_var_req_builder.query(&[("created_after_queue", &local_var_str.to_string())]);
2206    }
2207    if let Some(ref local_var_str) = job_kinds {
2208        local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
2209    }
2210    if let Some(ref local_var_str) = args {
2211        local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
2212    }
2213    if let Some(ref local_var_str) = tag {
2214        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2215    }
2216    if let Some(ref local_var_str) = result {
2217        local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
2218    }
2219    if let Some(ref local_var_str) = allow_wildcards {
2220        local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
2221    }
2222    if let Some(ref local_var_str) = page {
2223        local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
2224    }
2225    if let Some(ref local_var_str) = per_page {
2226        local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
2227    }
2228    if let Some(ref local_var_str) = trigger_kind {
2229        local_var_req_builder = local_var_req_builder.query(&[("trigger_kind", &local_var_str.to_string())]);
2230    }
2231    if let Some(ref local_var_str) = is_skipped {
2232        local_var_req_builder = local_var_req_builder.query(&[("is_skipped", &local_var_str.to_string())]);
2233    }
2234    if let Some(ref local_var_str) = is_flow_step {
2235        local_var_req_builder = local_var_req_builder.query(&[("is_flow_step", &local_var_str.to_string())]);
2236    }
2237    if let Some(ref local_var_str) = has_null_parent {
2238        local_var_req_builder = local_var_req_builder.query(&[("has_null_parent", &local_var_str.to_string())]);
2239    }
2240    if let Some(ref local_var_str) = success {
2241        local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
2242    }
2243    if let Some(ref local_var_str) = all_workspaces {
2244        local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
2245    }
2246    if let Some(ref local_var_str) = is_not_schedule {
2247        local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
2248    }
2249    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2250        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2251    }
2252    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2253        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2254    };
2255
2256    let local_var_req = local_var_req_builder.build()?;
2257    let local_var_resp = local_var_client.execute(local_var_req).await?;
2258
2259    let local_var_status = local_var_resp.status();
2260    let local_var_content = local_var_resp.text().await?;
2261
2262    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2263        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2264    } else {
2265        let local_var_entity: Option<ListExtendedJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2266        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2267        Err(Error::ResponseError(local_var_error))
2268    }
2269}
2270
2271pub async fn list_filtered_jobs_uuids(configuration: &configuration::Configuration, workspace: &str, created_by: Option<&str>, label: Option<&str>, worker: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, created_before: Option<String>, created_after: Option<String>, completed_before: Option<String>, completed_after: Option<String>, created_before_queue: Option<String>, created_after_queue: Option<String>, running: Option<bool>, scheduled_for_before_now: Option<bool>, job_kinds: Option<&str>, suspended: Option<bool>, args: Option<&str>, tag: Option<&str>, result: Option<&str>, page: Option<i32>, per_page: Option<i32>, is_skipped: Option<bool>, is_flow_step: Option<bool>, has_null_parent: Option<bool>, success: Option<bool>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<String>, Error<ListFilteredJobsUuidsError>> {
2272    let local_var_configuration = configuration;
2273
2274    let local_var_client = &local_var_configuration.client;
2275
2276    let local_var_uri_str = format!("{}/w/{workspace}/jobs/list_filtered_uuids", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2277    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2278
2279    if let Some(ref local_var_str) = created_by {
2280        local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
2281    }
2282    if let Some(ref local_var_str) = label {
2283        local_var_req_builder = local_var_req_builder.query(&[("label", &local_var_str.to_string())]);
2284    }
2285    if let Some(ref local_var_str) = worker {
2286        local_var_req_builder = local_var_req_builder.query(&[("worker", &local_var_str.to_string())]);
2287    }
2288    if let Some(ref local_var_str) = parent_job {
2289        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2290    }
2291    if let Some(ref local_var_str) = script_path_exact {
2292        local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
2293    }
2294    if let Some(ref local_var_str) = script_path_start {
2295        local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
2296    }
2297    if let Some(ref local_var_str) = schedule_path {
2298        local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
2299    }
2300    if let Some(ref local_var_str) = script_hash {
2301        local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
2302    }
2303    if let Some(ref local_var_str) = started_before {
2304        local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
2305    }
2306    if let Some(ref local_var_str) = started_after {
2307        local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
2308    }
2309    if let Some(ref local_var_str) = created_before {
2310        local_var_req_builder = local_var_req_builder.query(&[("created_before", &local_var_str.to_string())]);
2311    }
2312    if let Some(ref local_var_str) = created_after {
2313        local_var_req_builder = local_var_req_builder.query(&[("created_after", &local_var_str.to_string())]);
2314    }
2315    if let Some(ref local_var_str) = completed_before {
2316        local_var_req_builder = local_var_req_builder.query(&[("completed_before", &local_var_str.to_string())]);
2317    }
2318    if let Some(ref local_var_str) = completed_after {
2319        local_var_req_builder = local_var_req_builder.query(&[("completed_after", &local_var_str.to_string())]);
2320    }
2321    if let Some(ref local_var_str) = created_before_queue {
2322        local_var_req_builder = local_var_req_builder.query(&[("created_before_queue", &local_var_str.to_string())]);
2323    }
2324    if let Some(ref local_var_str) = created_after_queue {
2325        local_var_req_builder = local_var_req_builder.query(&[("created_after_queue", &local_var_str.to_string())]);
2326    }
2327    if let Some(ref local_var_str) = running {
2328        local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
2329    }
2330    if let Some(ref local_var_str) = scheduled_for_before_now {
2331        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
2332    }
2333    if let Some(ref local_var_str) = job_kinds {
2334        local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
2335    }
2336    if let Some(ref local_var_str) = suspended {
2337        local_var_req_builder = local_var_req_builder.query(&[("suspended", &local_var_str.to_string())]);
2338    }
2339    if let Some(ref local_var_str) = args {
2340        local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
2341    }
2342    if let Some(ref local_var_str) = tag {
2343        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2344    }
2345    if let Some(ref local_var_str) = result {
2346        local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
2347    }
2348    if let Some(ref local_var_str) = page {
2349        local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
2350    }
2351    if let Some(ref local_var_str) = per_page {
2352        local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
2353    }
2354    if let Some(ref local_var_str) = is_skipped {
2355        local_var_req_builder = local_var_req_builder.query(&[("is_skipped", &local_var_str.to_string())]);
2356    }
2357    if let Some(ref local_var_str) = is_flow_step {
2358        local_var_req_builder = local_var_req_builder.query(&[("is_flow_step", &local_var_str.to_string())]);
2359    }
2360    if let Some(ref local_var_str) = has_null_parent {
2361        local_var_req_builder = local_var_req_builder.query(&[("has_null_parent", &local_var_str.to_string())]);
2362    }
2363    if let Some(ref local_var_str) = success {
2364        local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
2365    }
2366    if let Some(ref local_var_str) = all_workspaces {
2367        local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
2368    }
2369    if let Some(ref local_var_str) = is_not_schedule {
2370        local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
2371    }
2372    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2373        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2374    }
2375    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2376        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2377    };
2378
2379    let local_var_req = local_var_req_builder.build()?;
2380    let local_var_resp = local_var_client.execute(local_var_req).await?;
2381
2382    let local_var_status = local_var_resp.status();
2383    let local_var_content = local_var_resp.text().await?;
2384
2385    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2386        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2387    } else {
2388        let local_var_entity: Option<ListFilteredJobsUuidsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2389        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2390        Err(Error::ResponseError(local_var_error))
2391    }
2392}
2393
2394pub async fn list_filtered_queue_uuids(configuration: &configuration::Configuration, workspace: &str, order_desc: Option<bool>, created_by: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, success: Option<bool>, scheduled_for_before_now: Option<bool>, job_kinds: Option<&str>, suspended: Option<bool>, running: Option<bool>, args: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, tag: Option<&str>, page: Option<i32>, per_page: Option<i32>, concurrency_key: Option<&str>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<String>, Error<ListFilteredQueueUuidsError>> {
2395    let local_var_configuration = configuration;
2396
2397    let local_var_client = &local_var_configuration.client;
2398
2399    let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/list_filtered_uuids", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2400    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2401
2402    if let Some(ref local_var_str) = order_desc {
2403        local_var_req_builder = local_var_req_builder.query(&[("order_desc", &local_var_str.to_string())]);
2404    }
2405    if let Some(ref local_var_str) = created_by {
2406        local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
2407    }
2408    if let Some(ref local_var_str) = parent_job {
2409        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2410    }
2411    if let Some(ref local_var_str) = script_path_exact {
2412        local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
2413    }
2414    if let Some(ref local_var_str) = script_path_start {
2415        local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
2416    }
2417    if let Some(ref local_var_str) = schedule_path {
2418        local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
2419    }
2420    if let Some(ref local_var_str) = script_hash {
2421        local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
2422    }
2423    if let Some(ref local_var_str) = started_before {
2424        local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
2425    }
2426    if let Some(ref local_var_str) = started_after {
2427        local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
2428    }
2429    if let Some(ref local_var_str) = success {
2430        local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
2431    }
2432    if let Some(ref local_var_str) = scheduled_for_before_now {
2433        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
2434    }
2435    if let Some(ref local_var_str) = job_kinds {
2436        local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
2437    }
2438    if let Some(ref local_var_str) = suspended {
2439        local_var_req_builder = local_var_req_builder.query(&[("suspended", &local_var_str.to_string())]);
2440    }
2441    if let Some(ref local_var_str) = running {
2442        local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
2443    }
2444    if let Some(ref local_var_str) = args {
2445        local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
2446    }
2447    if let Some(ref local_var_str) = result {
2448        local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
2449    }
2450    if let Some(ref local_var_str) = allow_wildcards {
2451        local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
2452    }
2453    if let Some(ref local_var_str) = tag {
2454        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2455    }
2456    if let Some(ref local_var_str) = page {
2457        local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
2458    }
2459    if let Some(ref local_var_str) = per_page {
2460        local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
2461    }
2462    if let Some(ref local_var_str) = concurrency_key {
2463        local_var_req_builder = local_var_req_builder.query(&[("concurrency_key", &local_var_str.to_string())]);
2464    }
2465    if let Some(ref local_var_str) = all_workspaces {
2466        local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
2467    }
2468    if let Some(ref local_var_str) = is_not_schedule {
2469        local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
2470    }
2471    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2472        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2473    }
2474    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2475        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2476    };
2477
2478    let local_var_req = local_var_req_builder.build()?;
2479    let local_var_resp = local_var_client.execute(local_var_req).await?;
2480
2481    let local_var_status = local_var_resp.status();
2482    let local_var_content = local_var_resp.text().await?;
2483
2484    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2485        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2486    } else {
2487        let local_var_entity: Option<ListFilteredQueueUuidsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2488        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2489        Err(Error::ResponseError(local_var_error))
2490    }
2491}
2492
2493pub async fn list_jobs(configuration: &configuration::Configuration, workspace: &str, created_by: Option<&str>, label: Option<&str>, worker: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, created_before: Option<String>, created_after: Option<String>, completed_before: Option<String>, completed_after: Option<String>, created_before_queue: Option<String>, created_after_queue: Option<String>, running: Option<bool>, scheduled_for_before_now: Option<bool>, job_kinds: Option<&str>, suspended: Option<bool>, args: Option<&str>, tag: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, per_page: Option<i32>, trigger_kind: Option<&str>, is_skipped: Option<bool>, is_flow_step: Option<bool>, has_null_parent: Option<bool>, success: Option<bool>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>, broad_filter: Option<&str>) -> Result<Vec<models::Job>, Error<ListJobsError>> {
2494    let local_var_configuration = configuration;
2495
2496    let local_var_client = &local_var_configuration.client;
2497
2498    let local_var_uri_str = format!("{}/w/{workspace}/jobs/list", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2499    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2500
2501    if let Some(ref local_var_str) = created_by {
2502        local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
2503    }
2504    if let Some(ref local_var_str) = label {
2505        local_var_req_builder = local_var_req_builder.query(&[("label", &local_var_str.to_string())]);
2506    }
2507    if let Some(ref local_var_str) = worker {
2508        local_var_req_builder = local_var_req_builder.query(&[("worker", &local_var_str.to_string())]);
2509    }
2510    if let Some(ref local_var_str) = parent_job {
2511        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2512    }
2513    if let Some(ref local_var_str) = script_path_exact {
2514        local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
2515    }
2516    if let Some(ref local_var_str) = script_path_start {
2517        local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
2518    }
2519    if let Some(ref local_var_str) = schedule_path {
2520        local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
2521    }
2522    if let Some(ref local_var_str) = script_hash {
2523        local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
2524    }
2525    if let Some(ref local_var_str) = started_before {
2526        local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
2527    }
2528    if let Some(ref local_var_str) = started_after {
2529        local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
2530    }
2531    if let Some(ref local_var_str) = created_before {
2532        local_var_req_builder = local_var_req_builder.query(&[("created_before", &local_var_str.to_string())]);
2533    }
2534    if let Some(ref local_var_str) = created_after {
2535        local_var_req_builder = local_var_req_builder.query(&[("created_after", &local_var_str.to_string())]);
2536    }
2537    if let Some(ref local_var_str) = completed_before {
2538        local_var_req_builder = local_var_req_builder.query(&[("completed_before", &local_var_str.to_string())]);
2539    }
2540    if let Some(ref local_var_str) = completed_after {
2541        local_var_req_builder = local_var_req_builder.query(&[("completed_after", &local_var_str.to_string())]);
2542    }
2543    if let Some(ref local_var_str) = created_before_queue {
2544        local_var_req_builder = local_var_req_builder.query(&[("created_before_queue", &local_var_str.to_string())]);
2545    }
2546    if let Some(ref local_var_str) = created_after_queue {
2547        local_var_req_builder = local_var_req_builder.query(&[("created_after_queue", &local_var_str.to_string())]);
2548    }
2549    if let Some(ref local_var_str) = running {
2550        local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
2551    }
2552    if let Some(ref local_var_str) = scheduled_for_before_now {
2553        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
2554    }
2555    if let Some(ref local_var_str) = job_kinds {
2556        local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
2557    }
2558    if let Some(ref local_var_str) = suspended {
2559        local_var_req_builder = local_var_req_builder.query(&[("suspended", &local_var_str.to_string())]);
2560    }
2561    if let Some(ref local_var_str) = args {
2562        local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
2563    }
2564    if let Some(ref local_var_str) = tag {
2565        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2566    }
2567    if let Some(ref local_var_str) = result {
2568        local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
2569    }
2570    if let Some(ref local_var_str) = allow_wildcards {
2571        local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
2572    }
2573    if let Some(ref local_var_str) = per_page {
2574        local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
2575    }
2576    if let Some(ref local_var_str) = trigger_kind {
2577        local_var_req_builder = local_var_req_builder.query(&[("trigger_kind", &local_var_str.to_string())]);
2578    }
2579    if let Some(ref local_var_str) = is_skipped {
2580        local_var_req_builder = local_var_req_builder.query(&[("is_skipped", &local_var_str.to_string())]);
2581    }
2582    if let Some(ref local_var_str) = is_flow_step {
2583        local_var_req_builder = local_var_req_builder.query(&[("is_flow_step", &local_var_str.to_string())]);
2584    }
2585    if let Some(ref local_var_str) = has_null_parent {
2586        local_var_req_builder = local_var_req_builder.query(&[("has_null_parent", &local_var_str.to_string())]);
2587    }
2588    if let Some(ref local_var_str) = success {
2589        local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
2590    }
2591    if let Some(ref local_var_str) = all_workspaces {
2592        local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
2593    }
2594    if let Some(ref local_var_str) = is_not_schedule {
2595        local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
2596    }
2597    if let Some(ref local_var_str) = broad_filter {
2598        local_var_req_builder = local_var_req_builder.query(&[("broad_filter", &local_var_str.to_string())]);
2599    }
2600    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2601        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2602    }
2603    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2604        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2605    };
2606
2607    let local_var_req = local_var_req_builder.build()?;
2608    let local_var_resp = local_var_client.execute(local_var_req).await?;
2609
2610    let local_var_status = local_var_resp.status();
2611    let local_var_content = local_var_resp.text().await?;
2612
2613    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2614        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2615    } else {
2616        let local_var_entity: Option<ListJobsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2617        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2618        Err(Error::ResponseError(local_var_error))
2619    }
2620}
2621
2622pub async fn list_queue(configuration: &configuration::Configuration, workspace: &str, order_desc: Option<bool>, created_by: Option<&str>, parent_job: Option<&str>, worker: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, trigger_path: Option<&str>, trigger_kind: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, success: Option<bool>, scheduled_for_before_now: Option<bool>, job_kinds: Option<&str>, suspended: Option<bool>, running: Option<bool>, args: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, tag: Option<&str>, page: Option<i32>, per_page: Option<i32>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<models::QueuedJob>, Error<ListQueueError>> {
2623    let local_var_configuration = configuration;
2624
2625    let local_var_client = &local_var_configuration.client;
2626
2627    let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/list", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2628    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2629
2630    if let Some(ref local_var_str) = order_desc {
2631        local_var_req_builder = local_var_req_builder.query(&[("order_desc", &local_var_str.to_string())]);
2632    }
2633    if let Some(ref local_var_str) = created_by {
2634        local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
2635    }
2636    if let Some(ref local_var_str) = parent_job {
2637        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2638    }
2639    if let Some(ref local_var_str) = worker {
2640        local_var_req_builder = local_var_req_builder.query(&[("worker", &local_var_str.to_string())]);
2641    }
2642    if let Some(ref local_var_str) = script_path_exact {
2643        local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
2644    }
2645    if let Some(ref local_var_str) = script_path_start {
2646        local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
2647    }
2648    if let Some(ref local_var_str) = schedule_path {
2649        local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
2650    }
2651    if let Some(ref local_var_str) = trigger_path {
2652        local_var_req_builder = local_var_req_builder.query(&[("trigger_path", &local_var_str.to_string())]);
2653    }
2654    if let Some(ref local_var_str) = trigger_kind {
2655        local_var_req_builder = local_var_req_builder.query(&[("trigger_kind", &local_var_str.to_string())]);
2656    }
2657    if let Some(ref local_var_str) = script_hash {
2658        local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
2659    }
2660    if let Some(ref local_var_str) = started_before {
2661        local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
2662    }
2663    if let Some(ref local_var_str) = started_after {
2664        local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
2665    }
2666    if let Some(ref local_var_str) = success {
2667        local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
2668    }
2669    if let Some(ref local_var_str) = scheduled_for_before_now {
2670        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
2671    }
2672    if let Some(ref local_var_str) = job_kinds {
2673        local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
2674    }
2675    if let Some(ref local_var_str) = suspended {
2676        local_var_req_builder = local_var_req_builder.query(&[("suspended", &local_var_str.to_string())]);
2677    }
2678    if let Some(ref local_var_str) = running {
2679        local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
2680    }
2681    if let Some(ref local_var_str) = args {
2682        local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
2683    }
2684    if let Some(ref local_var_str) = result {
2685        local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
2686    }
2687    if let Some(ref local_var_str) = allow_wildcards {
2688        local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
2689    }
2690    if let Some(ref local_var_str) = tag {
2691        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2692    }
2693    if let Some(ref local_var_str) = page {
2694        local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
2695    }
2696    if let Some(ref local_var_str) = per_page {
2697        local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
2698    }
2699    if let Some(ref local_var_str) = all_workspaces {
2700        local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
2701    }
2702    if let Some(ref local_var_str) = is_not_schedule {
2703        local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
2704    }
2705    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2706        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2707    }
2708    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2709        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2710    };
2711
2712    let local_var_req = local_var_req_builder.build()?;
2713    let local_var_resp = local_var_client.execute(local_var_req).await?;
2714
2715    let local_var_status = local_var_resp.status();
2716    let local_var_content = local_var_resp.text().await?;
2717
2718    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2719        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2720    } else {
2721        let local_var_entity: Option<ListQueueError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2722        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2723        Err(Error::ResponseError(local_var_error))
2724    }
2725}
2726
2727pub async fn list_selected_job_groups(configuration: &configuration::Configuration, workspace: &str, uuid_colon_colon_uuid: Vec<uuid::Uuid>) -> Result<Vec<models::ListSelectedJobGroups200ResponseInner>, Error<ListSelectedJobGroupsError>> {
2728    let local_var_configuration = configuration;
2729
2730    let local_var_client = &local_var_configuration.client;
2731
2732    let local_var_uri_str = format!("{}/w/{workspace}/jobs/list_selected_job_groups", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2733    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2734
2735    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2736        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2737    }
2738    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2739        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2740    };
2741    local_var_req_builder = local_var_req_builder.json(&uuid_colon_colon_uuid);
2742
2743    let local_var_req = local_var_req_builder.build()?;
2744    let local_var_resp = local_var_client.execute(local_var_req).await?;
2745
2746    let local_var_status = local_var_resp.status();
2747    let local_var_content = local_var_resp.text().await?;
2748
2749    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2750        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2751    } else {
2752        let local_var_entity: Option<ListSelectedJobGroupsError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2753        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2754        Err(Error::ResponseError(local_var_error))
2755    }
2756}
2757
2758pub async fn restart_flow_at_step(configuration: &configuration::Configuration, workspace: &str, id: &str, restart_flow_at_step_request: models::RestartFlowAtStepRequest, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, parent_job: Option<&str>, tag: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, invisible_to_owner: Option<bool>) -> Result<uuid::Uuid, Error<RestartFlowAtStepError>> {
2759    let local_var_configuration = configuration;
2760
2761    let local_var_client = &local_var_configuration.client;
2762
2763    let local_var_uri_str = format!("{}/w/{workspace}/jobs/restart/f/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
2764    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2765
2766    if let Some(ref local_var_str) = scheduled_for {
2767        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
2768    }
2769    if let Some(ref local_var_str) = scheduled_in_secs {
2770        local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
2771    }
2772    if let Some(ref local_var_str) = parent_job {
2773        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2774    }
2775    if let Some(ref local_var_str) = tag {
2776        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2777    }
2778    if let Some(ref local_var_str) = job_id {
2779        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2780    }
2781    if let Some(ref local_var_str) = include_header {
2782        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2783    }
2784    if let Some(ref local_var_str) = invisible_to_owner {
2785        local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
2786    }
2787    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2788        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2789    }
2790    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2791        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2792    };
2793    local_var_req_builder = local_var_req_builder.json(&restart_flow_at_step_request);
2794
2795    let local_var_req = local_var_req_builder.build()?;
2796    let local_var_resp = local_var_client.execute(local_var_req).await?;
2797
2798    let local_var_status = local_var_resp.status();
2799    let local_var_content = local_var_resp.text().await?;
2800
2801    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2802        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2803    } else {
2804        let local_var_entity: Option<RestartFlowAtStepError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2805        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2806        Err(Error::ResponseError(local_var_error))
2807    }
2808}
2809
2810pub async fn result_by_id(configuration: &configuration::Configuration, workspace: &str, flow_job_id: &str, node_id: &str) -> Result<serde_json::Value, Error<ResultByIdError>> {
2811    let local_var_configuration = configuration;
2812
2813    let local_var_client = &local_var_configuration.client;
2814
2815    let local_var_uri_str = format!("{}/w/{workspace}/jobs/result_by_id/{flow_job_id}/{node_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), flow_job_id=crate::apis::urlencode(flow_job_id), node_id=crate::apis::urlencode(node_id));
2816    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2817
2818    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2819        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2820    }
2821    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2822        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2823    };
2824
2825    let local_var_req = local_var_req_builder.build()?;
2826    let local_var_resp = local_var_client.execute(local_var_req).await?;
2827
2828    let local_var_status = local_var_resp.status();
2829    let local_var_content = local_var_resp.text().await?;
2830
2831    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2832        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2833    } else {
2834        let local_var_entity: Option<ResultByIdError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2835        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2836        Err(Error::ResponseError(local_var_error))
2837    }
2838}
2839
2840/// Resume or cancel a suspended flow/Code Flow job. Uses approval rules to determine authorization. Either a valid approval_token or an authenticated session is required; a step with any approval condition requires the session. 
2841pub async fn resume_suspended(configuration: &configuration::Configuration, workspace: &str, job_id: &str, resume_suspended_request: models::ResumeSuspendedRequest) -> Result<String, Error<ResumeSuspendedError>> {
2842    let local_var_configuration = configuration;
2843
2844    let local_var_client = &local_var_configuration.client;
2845
2846    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/flow/resume_suspended/{job_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), job_id=crate::apis::urlencode(job_id));
2847    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2848
2849    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2850        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2851    }
2852    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2853        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2854    };
2855    local_var_req_builder = local_var_req_builder.json(&resume_suspended_request);
2856
2857    let local_var_req = local_var_req_builder.build()?;
2858    let local_var_resp = local_var_client.execute(local_var_req).await?;
2859
2860    let local_var_status = local_var_resp.status();
2861    let local_var_content = local_var_resp.text().await?;
2862
2863    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2864        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2865    } else {
2866        let local_var_entity: Option<ResumeSuspendedError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2867        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2868        Err(Error::ResponseError(local_var_error))
2869    }
2870}
2871
2872pub async fn resume_suspended_flow_as_owner(configuration: &configuration::Configuration, workspace: &str, id: &str, body: serde_json::Value) -> Result<String, Error<ResumeSuspendedFlowAsOwnerError>> {
2873    let local_var_configuration = configuration;
2874
2875    let local_var_client = &local_var_configuration.client;
2876
2877    let local_var_uri_str = format!("{}/w/{workspace}/jobs/flow/resume/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
2878    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2879
2880    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2881        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2882    }
2883    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2884        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2885    };
2886    local_var_req_builder = local_var_req_builder.json(&body);
2887
2888    let local_var_req = local_var_req_builder.build()?;
2889    let local_var_resp = local_var_client.execute(local_var_req).await?;
2890
2891    let local_var_status = local_var_resp.status();
2892    let local_var_content = local_var_resp.text().await?;
2893
2894    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2895        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2896    } else {
2897        let local_var_entity: Option<ResumeSuspendedFlowAsOwnerError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2898        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2899        Err(Error::ResponseError(local_var_error))
2900    }
2901}
2902
2903/// A GET without an `Authorization: Bearer` header (and any HEAD) decides nothing: it answers 200 with an HTML confirm page whose form POSTs back to this URL, so a link scanner, mail gateway or chat unfurler that fetches the link cannot approve or cancel anything. Only a GET with a bearer token acts directly. The rest of this description applies to the action itself.  The signed link is the whole capability only for a step with no approval conditions. For a step that requires a logged-in approver (and so for self-approval or required groups), the caller must also be an identified user who passes those conditions: a POST with a session, or a request with a bearer token. A GET carrying only the session cookie (a link opened in a browser) is refused with 403, and a logged-out request with 401; both name the approval page. Before such a step waits (or when its definition cannot be read), its link is refused with 400. A flow-level link (including one for a loop/branch iteration or a subflow step) that could approve such a step is redeemable only by an admin. A token must carry `jobs:write`. 
2904pub async fn resume_suspended_job_get(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, payload: Option<&str>, approver: Option<&str>) -> Result<String, Error<ResumeSuspendedJobGetError>> {
2905    let local_var_configuration = configuration;
2906
2907    let local_var_client = &local_var_configuration.client;
2908
2909    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/resume/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
2910    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2911
2912    if let Some(ref local_var_str) = payload {
2913        local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
2914    }
2915    if let Some(ref local_var_str) = approver {
2916        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
2917    }
2918    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2919        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2920    }
2921    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2922        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2923    };
2924
2925    let local_var_req = local_var_req_builder.build()?;
2926    let local_var_resp = local_var_client.execute(local_var_req).await?;
2927
2928    let local_var_status = local_var_resp.status();
2929    let local_var_content = local_var_resp.text().await?;
2930
2931    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2932        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2933    } else {
2934        let local_var_entity: Option<ResumeSuspendedJobGetError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2935        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2936        Err(Error::ResponseError(local_var_error))
2937    }
2938}
2939
2940/// The signed link is the whole capability only for a step with no approval conditions. For a step that requires a logged-in approver (and so for self-approval or required groups), the caller must also be an identified user who passes those conditions: a POST with a session, or a request with a bearer token. A GET carrying only the session cookie (a link opened in a browser) is refused with 403, and a logged-out request with 401; both name the approval page. Before such a step waits (or when its definition cannot be read), its link is refused with 400. A flow-level link (including one for a loop/branch iteration or a subflow step) that could approve such a step is redeemable only by an admin. A token must carry `jobs:write`. 
2941pub async fn resume_suspended_job_post(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, body: serde_json::Value, approver: Option<&str>) -> Result<String, Error<ResumeSuspendedJobPostError>> {
2942    let local_var_configuration = configuration;
2943
2944    let local_var_client = &local_var_configuration.client;
2945
2946    let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/resume/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
2947    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2948
2949    if let Some(ref local_var_str) = approver {
2950        local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
2951    }
2952    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2953        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2954    }
2955    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2956        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2957    };
2958    local_var_req_builder = local_var_req_builder.json(&body);
2959
2960    let local_var_req = local_var_req_builder.build()?;
2961    let local_var_resp = local_var_client.execute(local_var_req).await?;
2962
2963    let local_var_status = local_var_resp.status();
2964    let local_var_content = local_var_resp.text().await?;
2965
2966    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2967        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
2968    } else {
2969        let local_var_entity: Option<ResumeSuspendedJobPostError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
2970        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2971        Err(Error::ResponseError(local_var_error))
2972    }
2973}
2974
2975pub async fn run_and_stream_flow_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, include_header: Option<&str>, queue_limit: Option<&str>, job_id: Option<&str>, skip_preprocessor: Option<bool>, memory_id: Option<&str>, poll_delay_ms: Option<i64>) -> Result<String, Error<RunAndStreamFlowByPathError>> {
2976    let local_var_configuration = configuration;
2977
2978    let local_var_client = &local_var_configuration.client;
2979
2980    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_and_stream/f/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
2981    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2982
2983    if let Some(ref local_var_str) = include_header {
2984        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2985    }
2986    if let Some(ref local_var_str) = queue_limit {
2987        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
2988    }
2989    if let Some(ref local_var_str) = job_id {
2990        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2991    }
2992    if let Some(ref local_var_str) = skip_preprocessor {
2993        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
2994    }
2995    if let Some(ref local_var_str) = memory_id {
2996        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
2997    }
2998    if let Some(ref local_var_str) = poll_delay_ms {
2999        local_var_req_builder = local_var_req_builder.query(&[("poll_delay_ms", &local_var_str.to_string())]);
3000    }
3001    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3002        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3003    }
3004    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3005        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3006    };
3007    local_var_req_builder = local_var_req_builder.json(&request_body);
3008
3009    let local_var_req = local_var_req_builder.build()?;
3010    let local_var_resp = local_var_client.execute(local_var_req).await?;
3011
3012    let local_var_status = local_var_resp.status();
3013    let local_var_content = local_var_resp.text().await?;
3014
3015    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3016        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3017    } else {
3018        let local_var_entity: Option<RunAndStreamFlowByPathError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3019        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3020        Err(Error::ResponseError(local_var_error))
3021    }
3022}
3023
3024pub async fn run_and_stream_flow_by_path_get(configuration: &configuration::Configuration, workspace: &str, path: &str, include_header: Option<&str>, queue_limit: Option<&str>, payload: Option<&str>, job_id: Option<&str>, skip_preprocessor: Option<bool>, memory_id: Option<&str>, poll_delay_ms: Option<i64>) -> Result<String, Error<RunAndStreamFlowByPathGetError>> {
3025    let local_var_configuration = configuration;
3026
3027    let local_var_client = &local_var_configuration.client;
3028
3029    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_and_stream/f/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
3030    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3031
3032    if let Some(ref local_var_str) = include_header {
3033        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3034    }
3035    if let Some(ref local_var_str) = queue_limit {
3036        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
3037    }
3038    if let Some(ref local_var_str) = payload {
3039        local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
3040    }
3041    if let Some(ref local_var_str) = job_id {
3042        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3043    }
3044    if let Some(ref local_var_str) = skip_preprocessor {
3045        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3046    }
3047    if let Some(ref local_var_str) = memory_id {
3048        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
3049    }
3050    if let Some(ref local_var_str) = poll_delay_ms {
3051        local_var_req_builder = local_var_req_builder.query(&[("poll_delay_ms", &local_var_str.to_string())]);
3052    }
3053    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3054        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3055    }
3056    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3057        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3058    };
3059
3060    let local_var_req = local_var_req_builder.build()?;
3061    let local_var_resp = local_var_client.execute(local_var_req).await?;
3062
3063    let local_var_status = local_var_resp.status();
3064    let local_var_content = local_var_resp.text().await?;
3065
3066    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3067        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3068    } else {
3069        let local_var_entity: Option<RunAndStreamFlowByPathGetError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3070        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3071        Err(Error::ResponseError(local_var_error))
3072    }
3073}
3074
3075pub async fn run_and_stream_flow_by_version(configuration: &configuration::Configuration, workspace: &str, version: i64, request_body: std::collections::HashMap<String, serde_json::Value>, include_header: Option<&str>, queue_limit: Option<&str>, job_id: Option<&str>, skip_preprocessor: Option<bool>, memory_id: Option<&str>, poll_delay_ms: Option<i64>) -> Result<String, Error<RunAndStreamFlowByVersionError>> {
3076    let local_var_configuration = configuration;
3077
3078    let local_var_client = &local_var_configuration.client;
3079
3080    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_and_stream/fv/{version}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), version=version);
3081    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3082
3083    if let Some(ref local_var_str) = include_header {
3084        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3085    }
3086    if let Some(ref local_var_str) = queue_limit {
3087        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
3088    }
3089    if let Some(ref local_var_str) = job_id {
3090        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3091    }
3092    if let Some(ref local_var_str) = skip_preprocessor {
3093        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3094    }
3095    if let Some(ref local_var_str) = memory_id {
3096        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
3097    }
3098    if let Some(ref local_var_str) = poll_delay_ms {
3099        local_var_req_builder = local_var_req_builder.query(&[("poll_delay_ms", &local_var_str.to_string())]);
3100    }
3101    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3102        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3103    }
3104    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3105        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3106    };
3107    local_var_req_builder = local_var_req_builder.json(&request_body);
3108
3109    let local_var_req = local_var_req_builder.build()?;
3110    let local_var_resp = local_var_client.execute(local_var_req).await?;
3111
3112    let local_var_status = local_var_resp.status();
3113    let local_var_content = local_var_resp.text().await?;
3114
3115    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3116        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3117    } else {
3118        let local_var_entity: Option<RunAndStreamFlowByVersionError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3119        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3120        Err(Error::ResponseError(local_var_error))
3121    }
3122}
3123
3124pub async fn run_and_stream_flow_by_version_get(configuration: &configuration::Configuration, workspace: &str, version: i64, include_header: Option<&str>, queue_limit: Option<&str>, payload: Option<&str>, job_id: Option<&str>, skip_preprocessor: Option<bool>, memory_id: Option<&str>, poll_delay_ms: Option<i64>) -> Result<String, Error<RunAndStreamFlowByVersionGetError>> {
3125    let local_var_configuration = configuration;
3126
3127    let local_var_client = &local_var_configuration.client;
3128
3129    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_and_stream/fv/{version}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), version=version);
3130    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3131
3132    if let Some(ref local_var_str) = include_header {
3133        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3134    }
3135    if let Some(ref local_var_str) = queue_limit {
3136        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
3137    }
3138    if let Some(ref local_var_str) = payload {
3139        local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
3140    }
3141    if let Some(ref local_var_str) = job_id {
3142        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3143    }
3144    if let Some(ref local_var_str) = skip_preprocessor {
3145        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3146    }
3147    if let Some(ref local_var_str) = memory_id {
3148        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
3149    }
3150    if let Some(ref local_var_str) = poll_delay_ms {
3151        local_var_req_builder = local_var_req_builder.query(&[("poll_delay_ms", &local_var_str.to_string())]);
3152    }
3153    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3154        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3155    }
3156    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3157        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3158    };
3159
3160    let local_var_req = local_var_req_builder.build()?;
3161    let local_var_resp = local_var_client.execute(local_var_req).await?;
3162
3163    let local_var_status = local_var_resp.status();
3164    let local_var_content = local_var_resp.text().await?;
3165
3166    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3167        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3168    } else {
3169        let local_var_entity: Option<RunAndStreamFlowByVersionGetError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3170        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3171        Err(Error::ResponseError(local_var_error))
3172    }
3173}
3174
3175pub async fn run_and_stream_script_by_hash(configuration: &configuration::Configuration, workspace: &str, hash: &str, request_body: std::collections::HashMap<String, serde_json::Value>, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>, skip_preprocessor: Option<bool>, poll_delay_ms: Option<i64>) -> Result<String, Error<RunAndStreamScriptByHashError>> {
3176    let local_var_configuration = configuration;
3177
3178    let local_var_client = &local_var_configuration.client;
3179
3180    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_and_stream/h/{hash}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), hash=crate::apis::urlencode(hash));
3181    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3182
3183    if let Some(ref local_var_str) = parent_job {
3184        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
3185    }
3186    if let Some(ref local_var_str) = tag {
3187        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
3188    }
3189    if let Some(ref local_var_str) = cache_ttl {
3190        local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
3191    }
3192    if let Some(ref local_var_str) = job_id {
3193        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3194    }
3195    if let Some(ref local_var_str) = include_header {
3196        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3197    }
3198    if let Some(ref local_var_str) = queue_limit {
3199        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
3200    }
3201    if let Some(ref local_var_str) = skip_preprocessor {
3202        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3203    }
3204    if let Some(ref local_var_str) = poll_delay_ms {
3205        local_var_req_builder = local_var_req_builder.query(&[("poll_delay_ms", &local_var_str.to_string())]);
3206    }
3207    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3208        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3209    }
3210    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3211        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3212    };
3213    local_var_req_builder = local_var_req_builder.json(&request_body);
3214
3215    let local_var_req = local_var_req_builder.build()?;
3216    let local_var_resp = local_var_client.execute(local_var_req).await?;
3217
3218    let local_var_status = local_var_resp.status();
3219    let local_var_content = local_var_resp.text().await?;
3220
3221    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3222        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3223    } else {
3224        let local_var_entity: Option<RunAndStreamScriptByHashError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3225        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3226        Err(Error::ResponseError(local_var_error))
3227    }
3228}
3229
3230pub async fn run_and_stream_script_by_hash_get(configuration: &configuration::Configuration, workspace: &str, hash: &str, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>, payload: Option<&str>, skip_preprocessor: Option<bool>, poll_delay_ms: Option<i64>) -> Result<String, Error<RunAndStreamScriptByHashGetError>> {
3231    let local_var_configuration = configuration;
3232
3233    let local_var_client = &local_var_configuration.client;
3234
3235    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_and_stream/h/{hash}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), hash=crate::apis::urlencode(hash));
3236    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3237
3238    if let Some(ref local_var_str) = parent_job {
3239        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
3240    }
3241    if let Some(ref local_var_str) = tag {
3242        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
3243    }
3244    if let Some(ref local_var_str) = cache_ttl {
3245        local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
3246    }
3247    if let Some(ref local_var_str) = job_id {
3248        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3249    }
3250    if let Some(ref local_var_str) = include_header {
3251        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3252    }
3253    if let Some(ref local_var_str) = queue_limit {
3254        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
3255    }
3256    if let Some(ref local_var_str) = payload {
3257        local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
3258    }
3259    if let Some(ref local_var_str) = skip_preprocessor {
3260        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3261    }
3262    if let Some(ref local_var_str) = poll_delay_ms {
3263        local_var_req_builder = local_var_req_builder.query(&[("poll_delay_ms", &local_var_str.to_string())]);
3264    }
3265    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3266        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3267    }
3268    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3269        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3270    };
3271
3272    let local_var_req = local_var_req_builder.build()?;
3273    let local_var_resp = local_var_client.execute(local_var_req).await?;
3274
3275    let local_var_status = local_var_resp.status();
3276    let local_var_content = local_var_resp.text().await?;
3277
3278    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3279        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3280    } else {
3281        let local_var_entity: Option<RunAndStreamScriptByHashGetError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3282        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3283        Err(Error::ResponseError(local_var_error))
3284    }
3285}
3286
3287pub async fn run_and_stream_script_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>, skip_preprocessor: Option<bool>, poll_delay_ms: Option<i64>) -> Result<String, Error<RunAndStreamScriptByPathError>> {
3288    let local_var_configuration = configuration;
3289
3290    let local_var_client = &local_var_configuration.client;
3291
3292    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_and_stream/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
3293    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3294
3295    if let Some(ref local_var_str) = parent_job {
3296        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
3297    }
3298    if let Some(ref local_var_str) = tag {
3299        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
3300    }
3301    if let Some(ref local_var_str) = cache_ttl {
3302        local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
3303    }
3304    if let Some(ref local_var_str) = job_id {
3305        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3306    }
3307    if let Some(ref local_var_str) = include_header {
3308        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3309    }
3310    if let Some(ref local_var_str) = queue_limit {
3311        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
3312    }
3313    if let Some(ref local_var_str) = skip_preprocessor {
3314        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3315    }
3316    if let Some(ref local_var_str) = poll_delay_ms {
3317        local_var_req_builder = local_var_req_builder.query(&[("poll_delay_ms", &local_var_str.to_string())]);
3318    }
3319    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3320        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3321    }
3322    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3323        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3324    };
3325    local_var_req_builder = local_var_req_builder.json(&request_body);
3326
3327    let local_var_req = local_var_req_builder.build()?;
3328    let local_var_resp = local_var_client.execute(local_var_req).await?;
3329
3330    let local_var_status = local_var_resp.status();
3331    let local_var_content = local_var_resp.text().await?;
3332
3333    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3334        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3335    } else {
3336        let local_var_entity: Option<RunAndStreamScriptByPathError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3337        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3338        Err(Error::ResponseError(local_var_error))
3339    }
3340}
3341
3342pub async fn run_and_stream_script_by_path_get(configuration: &configuration::Configuration, workspace: &str, path: &str, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>, payload: Option<&str>, skip_preprocessor: Option<bool>, poll_delay_ms: Option<i64>) -> Result<String, Error<RunAndStreamScriptByPathGetError>> {
3343    let local_var_configuration = configuration;
3344
3345    let local_var_client = &local_var_configuration.client;
3346
3347    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_and_stream/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
3348    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
3349
3350    if let Some(ref local_var_str) = parent_job {
3351        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
3352    }
3353    if let Some(ref local_var_str) = tag {
3354        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
3355    }
3356    if let Some(ref local_var_str) = cache_ttl {
3357        local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
3358    }
3359    if let Some(ref local_var_str) = job_id {
3360        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3361    }
3362    if let Some(ref local_var_str) = include_header {
3363        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3364    }
3365    if let Some(ref local_var_str) = queue_limit {
3366        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
3367    }
3368    if let Some(ref local_var_str) = payload {
3369        local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
3370    }
3371    if let Some(ref local_var_str) = skip_preprocessor {
3372        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3373    }
3374    if let Some(ref local_var_str) = poll_delay_ms {
3375        local_var_req_builder = local_var_req_builder.query(&[("poll_delay_ms", &local_var_str.to_string())]);
3376    }
3377    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3378        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3379    }
3380    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3381        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3382    };
3383
3384    let local_var_req = local_var_req_builder.build()?;
3385    let local_var_resp = local_var_client.execute(local_var_req).await?;
3386
3387    let local_var_status = local_var_resp.status();
3388    let local_var_content = local_var_resp.text().await?;
3389
3390    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3391        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3392    } else {
3393        let local_var_entity: Option<RunAndStreamScriptByPathGetError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3394        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3395        Err(Error::ResponseError(local_var_error))
3396    }
3397}
3398
3399pub async fn run_code_flow_task(configuration: &configuration::Configuration, workspace: &str, job_id: &str, entrypoint: &str, workflow_task: models::WorkflowTask) -> Result<uuid::Uuid, Error<RunCodeFlowTaskError>> {
3400    let local_var_configuration = configuration;
3401
3402    let local_var_client = &local_var_configuration.client;
3403
3404    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/code_flow/{job_id}/{entrypoint}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), job_id=crate::apis::urlencode(job_id), entrypoint=crate::apis::urlencode(entrypoint));
3405    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3406
3407    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3408        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3409    }
3410    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3411        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3412    };
3413    local_var_req_builder = local_var_req_builder.json(&workflow_task);
3414
3415    let local_var_req = local_var_req_builder.build()?;
3416    let local_var_resp = local_var_client.execute(local_var_req).await?;
3417
3418    let local_var_status = local_var_resp.status();
3419    let local_var_content = local_var_resp.text().await?;
3420
3421    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3422        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3423    } else {
3424        let local_var_entity: Option<RunCodeFlowTaskError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3425        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3426        Err(Error::ResponseError(local_var_error))
3427    }
3428}
3429
3430pub async fn run_dynamic_select(configuration: &configuration::Configuration, workspace: &str, dynamic_input_data: models::DynamicInputData) -> Result<uuid::Uuid, Error<RunDynamicSelectError>> {
3431    let local_var_configuration = configuration;
3432
3433    let local_var_client = &local_var_configuration.client;
3434
3435    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/dynamic_select", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3436    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3437
3438    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3439        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3440    }
3441    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3442        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3443    };
3444    local_var_req_builder = local_var_req_builder.json(&dynamic_input_data);
3445
3446    let local_var_req = local_var_req_builder.build()?;
3447    let local_var_resp = local_var_client.execute(local_var_req).await?;
3448
3449    let local_var_status = local_var_resp.status();
3450    let local_var_content = local_var_resp.text().await?;
3451
3452    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3453        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3454    } else {
3455        let local_var_entity: Option<RunDynamicSelectError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3456        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3457        Err(Error::ResponseError(local_var_error))
3458    }
3459}
3460
3461pub async fn run_flow_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, skip_preprocessor: Option<bool>, parent_job: Option<&str>, tag: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, invisible_to_owner: Option<bool>, memory_id: Option<&str>) -> Result<uuid::Uuid, Error<RunFlowByPathError>> {
3462    let local_var_configuration = configuration;
3463
3464    let local_var_client = &local_var_configuration.client;
3465
3466    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/f/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
3467    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3468
3469    if let Some(ref local_var_str) = scheduled_for {
3470        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
3471    }
3472    if let Some(ref local_var_str) = scheduled_in_secs {
3473        local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
3474    }
3475    if let Some(ref local_var_str) = skip_preprocessor {
3476        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3477    }
3478    if let Some(ref local_var_str) = parent_job {
3479        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
3480    }
3481    if let Some(ref local_var_str) = tag {
3482        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
3483    }
3484    if let Some(ref local_var_str) = job_id {
3485        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3486    }
3487    if let Some(ref local_var_str) = include_header {
3488        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3489    }
3490    if let Some(ref local_var_str) = invisible_to_owner {
3491        local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
3492    }
3493    if let Some(ref local_var_str) = memory_id {
3494        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
3495    }
3496    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3497        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3498    }
3499    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3500        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3501    };
3502    local_var_req_builder = local_var_req_builder.json(&request_body);
3503
3504    let local_var_req = local_var_req_builder.build()?;
3505    let local_var_resp = local_var_client.execute(local_var_req).await?;
3506
3507    let local_var_status = local_var_resp.status();
3508    let local_var_content = local_var_resp.text().await?;
3509
3510    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3511        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3512    } else {
3513        let local_var_entity: Option<RunFlowByPathError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3514        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3515        Err(Error::ResponseError(local_var_error))
3516    }
3517}
3518
3519pub async fn run_flow_by_version(configuration: &configuration::Configuration, workspace: &str, version: i64, request_body: std::collections::HashMap<String, serde_json::Value>, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, skip_preprocessor: Option<bool>, parent_job: Option<&str>, tag: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, invisible_to_owner: Option<bool>, memory_id: Option<&str>) -> Result<uuid::Uuid, Error<RunFlowByVersionError>> {
3520    let local_var_configuration = configuration;
3521
3522    let local_var_client = &local_var_configuration.client;
3523
3524    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/fv/{version}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), version=version);
3525    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3526
3527    if let Some(ref local_var_str) = scheduled_for {
3528        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
3529    }
3530    if let Some(ref local_var_str) = scheduled_in_secs {
3531        local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
3532    }
3533    if let Some(ref local_var_str) = skip_preprocessor {
3534        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3535    }
3536    if let Some(ref local_var_str) = parent_job {
3537        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
3538    }
3539    if let Some(ref local_var_str) = tag {
3540        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
3541    }
3542    if let Some(ref local_var_str) = job_id {
3543        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3544    }
3545    if let Some(ref local_var_str) = include_header {
3546        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3547    }
3548    if let Some(ref local_var_str) = invisible_to_owner {
3549        local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
3550    }
3551    if let Some(ref local_var_str) = memory_id {
3552        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
3553    }
3554    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3555        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3556    }
3557    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3558        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3559    };
3560    local_var_req_builder = local_var_req_builder.json(&request_body);
3561
3562    let local_var_req = local_var_req_builder.build()?;
3563    let local_var_resp = local_var_client.execute(local_var_req).await?;
3564
3565    let local_var_status = local_var_resp.status();
3566    let local_var_content = local_var_resp.text().await?;
3567
3568    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3569        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3570    } else {
3571        let local_var_entity: Option<RunFlowByVersionError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3572        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3573        Err(Error::ResponseError(local_var_error))
3574    }
3575}
3576
3577pub async fn run_flow_dependencies_async(configuration: &configuration::Configuration, workspace: &str, run_flow_dependencies_async_request: models::RunFlowDependenciesAsyncRequest) -> Result<uuid::Uuid, Error<RunFlowDependenciesAsyncError>> {
3578    let local_var_configuration = configuration;
3579
3580    let local_var_client = &local_var_configuration.client;
3581
3582    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/flow_dependencies_async", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3583    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3584
3585    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3586        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3587    }
3588    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3589        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3590    };
3591    local_var_req_builder = local_var_req_builder.json(&run_flow_dependencies_async_request);
3592
3593    let local_var_req = local_var_req_builder.build()?;
3594    let local_var_resp = local_var_client.execute(local_var_req).await?;
3595
3596    let local_var_status = local_var_resp.status();
3597    let local_var_content = local_var_resp.text().await?;
3598
3599    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3600        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3601    } else {
3602        let local_var_entity: Option<RunFlowDependenciesAsyncError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3603        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3604        Err(Error::ResponseError(local_var_error))
3605    }
3606}
3607
3608pub async fn run_flow_preview(configuration: &configuration::Configuration, workspace: &str, flow_preview: models::FlowPreview, include_header: Option<&str>, invisible_to_owner: Option<bool>, job_id: Option<&str>, memory_id: Option<&str>) -> Result<uuid::Uuid, Error<RunFlowPreviewError>> {
3609    let local_var_configuration = configuration;
3610
3611    let local_var_client = &local_var_configuration.client;
3612
3613    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/preview_flow", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3614    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3615
3616    if let Some(ref local_var_str) = include_header {
3617        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3618    }
3619    if let Some(ref local_var_str) = invisible_to_owner {
3620        local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
3621    }
3622    if let Some(ref local_var_str) = job_id {
3623        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3624    }
3625    if let Some(ref local_var_str) = memory_id {
3626        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
3627    }
3628    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3629        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3630    }
3631    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3632        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3633    };
3634    local_var_req_builder = local_var_req_builder.json(&flow_preview);
3635
3636    let local_var_req = local_var_req_builder.build()?;
3637    let local_var_resp = local_var_client.execute(local_var_req).await?;
3638
3639    let local_var_status = local_var_resp.status();
3640    let local_var_content = local_var_resp.text().await?;
3641
3642    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3643        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3644    } else {
3645        let local_var_entity: Option<RunFlowPreviewError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3646        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3647        Err(Error::ResponseError(local_var_error))
3648    }
3649}
3650
3651pub async fn run_flow_preview_and_wait_result(configuration: &configuration::Configuration, workspace: &str, flow_preview: models::FlowPreview, memory_id: Option<&str>) -> Result<serde_json::Value, Error<RunFlowPreviewAndWaitResultError>> {
3652    let local_var_configuration = configuration;
3653
3654    let local_var_client = &local_var_configuration.client;
3655
3656    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/preview_flow", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3657    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3658
3659    if let Some(ref local_var_str) = memory_id {
3660        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
3661    }
3662    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3663        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3664    }
3665    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3666        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3667    };
3668    local_var_req_builder = local_var_req_builder.json(&flow_preview);
3669
3670    let local_var_req = local_var_req_builder.build()?;
3671    let local_var_resp = local_var_client.execute(local_var_req).await?;
3672
3673    let local_var_status = local_var_resp.status();
3674    let local_var_content = local_var_resp.text().await?;
3675
3676    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3677        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3678    } else {
3679        let local_var_entity: Option<RunFlowPreviewAndWaitResultError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3680        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3681        Err(Error::ResponseError(local_var_error))
3682    }
3683}
3684
3685pub async fn run_raw_script_dependencies(configuration: &configuration::Configuration, workspace: &str, run_raw_script_dependencies_request: models::RunRawScriptDependenciesRequest) -> Result<models::RunRawScriptDependencies201Response, Error<RunRawScriptDependenciesError>> {
3686    let local_var_configuration = configuration;
3687
3688    let local_var_client = &local_var_configuration.client;
3689
3690    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/dependencies", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3691    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3692
3693    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3694        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3695    }
3696    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3697        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3698    };
3699    local_var_req_builder = local_var_req_builder.json(&run_raw_script_dependencies_request);
3700
3701    let local_var_req = local_var_req_builder.build()?;
3702    let local_var_resp = local_var_client.execute(local_var_req).await?;
3703
3704    let local_var_status = local_var_resp.status();
3705    let local_var_content = local_var_resp.text().await?;
3706
3707    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3708        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3709    } else {
3710        let local_var_entity: Option<RunRawScriptDependenciesError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3711        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3712        Err(Error::ResponseError(local_var_error))
3713    }
3714}
3715
3716pub async fn run_raw_script_dependencies_async(configuration: &configuration::Configuration, workspace: &str, run_raw_script_dependencies_request: models::RunRawScriptDependenciesRequest) -> Result<uuid::Uuid, Error<RunRawScriptDependenciesAsyncError>> {
3717    let local_var_configuration = configuration;
3718
3719    let local_var_client = &local_var_configuration.client;
3720
3721    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/dependencies_async", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3722    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3723
3724    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3725        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3726    }
3727    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3728        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3729    };
3730    local_var_req_builder = local_var_req_builder.json(&run_raw_script_dependencies_request);
3731
3732    let local_var_req = local_var_req_builder.build()?;
3733    let local_var_resp = local_var_client.execute(local_var_req).await?;
3734
3735    let local_var_status = local_var_resp.status();
3736    let local_var_content = local_var_resp.text().await?;
3737
3738    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3739        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3740    } else {
3741        let local_var_entity: Option<RunRawScriptDependenciesAsyncError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3742        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3743        Err(Error::ResponseError(local_var_error))
3744    }
3745}
3746
3747pub async fn run_script_by_hash(configuration: &configuration::Configuration, workspace: &str, hash: &str, body: serde_json::Value, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, skip_preprocessor: Option<bool>, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, invisible_to_owner: Option<bool>) -> Result<uuid::Uuid, Error<RunScriptByHashError>> {
3748    let local_var_configuration = configuration;
3749
3750    let local_var_client = &local_var_configuration.client;
3751
3752    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/h/{hash}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), hash=crate::apis::urlencode(hash));
3753    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3754
3755    if let Some(ref local_var_str) = scheduled_for {
3756        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
3757    }
3758    if let Some(ref local_var_str) = scheduled_in_secs {
3759        local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
3760    }
3761    if let Some(ref local_var_str) = skip_preprocessor {
3762        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3763    }
3764    if let Some(ref local_var_str) = parent_job {
3765        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
3766    }
3767    if let Some(ref local_var_str) = tag {
3768        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
3769    }
3770    if let Some(ref local_var_str) = cache_ttl {
3771        local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
3772    }
3773    if let Some(ref local_var_str) = job_id {
3774        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3775    }
3776    if let Some(ref local_var_str) = include_header {
3777        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3778    }
3779    if let Some(ref local_var_str) = invisible_to_owner {
3780        local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
3781    }
3782    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3783        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3784    }
3785    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3786        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3787    };
3788    local_var_req_builder = local_var_req_builder.json(&body);
3789
3790    let local_var_req = local_var_req_builder.build()?;
3791    let local_var_resp = local_var_client.execute(local_var_req).await?;
3792
3793    let local_var_status = local_var_resp.status();
3794    let local_var_content = local_var_resp.text().await?;
3795
3796    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3797        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3798    } else {
3799        let local_var_entity: Option<RunScriptByHashError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3800        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3801        Err(Error::ResponseError(local_var_error))
3802    }
3803}
3804
3805pub async fn run_script_by_hash_inline(configuration: &configuration::Configuration, workspace: &str, hash: &str, inline_script_args: models::InlineScriptArgs) -> Result<serde_json::Value, Error<RunScriptByHashInlineError>> {
3806    let local_var_configuration = configuration;
3807
3808    let local_var_client = &local_var_configuration.client;
3809
3810    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_inline/h/{hash}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), hash=crate::apis::urlencode(hash));
3811    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3812
3813    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3814        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3815    }
3816    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3817        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3818    };
3819    local_var_req_builder = local_var_req_builder.json(&inline_script_args);
3820
3821    let local_var_req = local_var_req_builder.build()?;
3822    let local_var_resp = local_var_client.execute(local_var_req).await?;
3823
3824    let local_var_status = local_var_resp.status();
3825    let local_var_content = local_var_resp.text().await?;
3826
3827    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3828        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3829    } else {
3830        let local_var_entity: Option<RunScriptByHashInlineError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3831        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3832        Err(Error::ResponseError(local_var_error))
3833    }
3834}
3835
3836pub async fn run_script_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, skip_preprocessor: Option<bool>, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, invisible_to_owner: Option<bool>) -> Result<uuid::Uuid, Error<RunScriptByPathError>> {
3837    let local_var_configuration = configuration;
3838
3839    let local_var_client = &local_var_configuration.client;
3840
3841    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
3842    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3843
3844    if let Some(ref local_var_str) = scheduled_for {
3845        local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
3846    }
3847    if let Some(ref local_var_str) = scheduled_in_secs {
3848        local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
3849    }
3850    if let Some(ref local_var_str) = skip_preprocessor {
3851        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
3852    }
3853    if let Some(ref local_var_str) = parent_job {
3854        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
3855    }
3856    if let Some(ref local_var_str) = tag {
3857        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
3858    }
3859    if let Some(ref local_var_str) = cache_ttl {
3860        local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
3861    }
3862    if let Some(ref local_var_str) = job_id {
3863        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3864    }
3865    if let Some(ref local_var_str) = invisible_to_owner {
3866        local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
3867    }
3868    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3869        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3870    }
3871    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3872        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3873    };
3874    local_var_req_builder = local_var_req_builder.json(&request_body);
3875
3876    let local_var_req = local_var_req_builder.build()?;
3877    let local_var_resp = local_var_client.execute(local_var_req).await?;
3878
3879    let local_var_status = local_var_resp.status();
3880    let local_var_content = local_var_resp.text().await?;
3881
3882    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3883        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3884    } else {
3885        let local_var_entity: Option<RunScriptByPathError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3886        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3887        Err(Error::ResponseError(local_var_error))
3888    }
3889}
3890
3891pub async fn run_script_by_path_inline(configuration: &configuration::Configuration, workspace: &str, path: &str, inline_script_args: models::InlineScriptArgs) -> Result<serde_json::Value, Error<RunScriptByPathInlineError>> {
3892    let local_var_configuration = configuration;
3893
3894    let local_var_client = &local_var_configuration.client;
3895
3896    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_inline/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
3897    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3898
3899    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3900        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3901    }
3902    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3903        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3904    };
3905    local_var_req_builder = local_var_req_builder.json(&inline_script_args);
3906
3907    let local_var_req = local_var_req_builder.build()?;
3908    let local_var_resp = local_var_client.execute(local_var_req).await?;
3909
3910    let local_var_status = local_var_resp.status();
3911    let local_var_content = local_var_resp.text().await?;
3912
3913    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3914        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3915    } else {
3916        let local_var_entity: Option<RunScriptByPathInlineError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3917        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3918        Err(Error::ResponseError(local_var_error))
3919    }
3920}
3921
3922pub async fn run_script_preview(configuration: &configuration::Configuration, workspace: &str, preview: models::Preview, include_header: Option<&str>, invisible_to_owner: Option<bool>, job_id: Option<&str>) -> Result<uuid::Uuid, Error<RunScriptPreviewError>> {
3923    let local_var_configuration = configuration;
3924
3925    let local_var_client = &local_var_configuration.client;
3926
3927    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/preview", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3928    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3929
3930    if let Some(ref local_var_str) = include_header {
3931        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
3932    }
3933    if let Some(ref local_var_str) = invisible_to_owner {
3934        local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
3935    }
3936    if let Some(ref local_var_str) = job_id {
3937        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
3938    }
3939    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3940        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3941    }
3942    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3943        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3944    };
3945    local_var_req_builder = local_var_req_builder.json(&preview);
3946
3947    let local_var_req = local_var_req_builder.build()?;
3948    let local_var_resp = local_var_client.execute(local_var_req).await?;
3949
3950    let local_var_status = local_var_resp.status();
3951    let local_var_content = local_var_resp.text().await?;
3952
3953    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3954        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3955    } else {
3956        let local_var_entity: Option<RunScriptPreviewError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3957        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3958        Err(Error::ResponseError(local_var_error))
3959    }
3960}
3961
3962pub async fn run_script_preview_and_wait_result(configuration: &configuration::Configuration, workspace: &str, preview: models::Preview) -> Result<serde_json::Value, Error<RunScriptPreviewAndWaitResultError>> {
3963    let local_var_configuration = configuration;
3964
3965    let local_var_client = &local_var_configuration.client;
3966
3967    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/preview", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3968    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3969
3970    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3971        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3972    }
3973    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
3974        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
3975    };
3976    local_var_req_builder = local_var_req_builder.json(&preview);
3977
3978    let local_var_req = local_var_req_builder.build()?;
3979    let local_var_resp = local_var_client.execute(local_var_req).await?;
3980
3981    let local_var_status = local_var_resp.status();
3982    let local_var_content = local_var_resp.text().await?;
3983
3984    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3985        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
3986    } else {
3987        let local_var_entity: Option<RunScriptPreviewAndWaitResultError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
3988        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3989        Err(Error::ResponseError(local_var_error))
3990    }
3991}
3992
3993pub async fn run_script_preview_inline(configuration: &configuration::Configuration, workspace: &str, preview_inline: models::PreviewInline) -> Result<serde_json::Value, Error<RunScriptPreviewInlineError>> {
3994    let local_var_configuration = configuration;
3995
3996    let local_var_client = &local_var_configuration.client;
3997
3998    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_inline/preview", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
3999    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4000
4001    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4002        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4003    }
4004    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
4005        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
4006    };
4007    local_var_req_builder = local_var_req_builder.json(&preview_inline);
4008
4009    let local_var_req = local_var_req_builder.build()?;
4010    let local_var_resp = local_var_client.execute(local_var_req).await?;
4011
4012    let local_var_status = local_var_resp.status();
4013    let local_var_content = local_var_resp.text().await?;
4014
4015    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4016        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
4017    } else {
4018        let local_var_entity: Option<RunScriptPreviewInlineError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
4019        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4020        Err(Error::ResponseError(local_var_error))
4021    }
4022}
4023
4024pub async fn run_wait_result_flow_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, include_header: Option<&str>, queue_limit: Option<&str>, job_id: Option<&str>, skip_preprocessor: Option<bool>, memory_id: Option<&str>) -> Result<serde_json::Value, Error<RunWaitResultFlowByPathError>> {
4025    let local_var_configuration = configuration;
4026
4027    let local_var_client = &local_var_configuration.client;
4028
4029    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/f/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
4030    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4031
4032    if let Some(ref local_var_str) = include_header {
4033        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
4034    }
4035    if let Some(ref local_var_str) = queue_limit {
4036        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
4037    }
4038    if let Some(ref local_var_str) = job_id {
4039        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
4040    }
4041    if let Some(ref local_var_str) = skip_preprocessor {
4042        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
4043    }
4044    if let Some(ref local_var_str) = memory_id {
4045        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
4046    }
4047    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4048        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4049    }
4050    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
4051        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
4052    };
4053    local_var_req_builder = local_var_req_builder.json(&request_body);
4054
4055    let local_var_req = local_var_req_builder.build()?;
4056    let local_var_resp = local_var_client.execute(local_var_req).await?;
4057
4058    let local_var_status = local_var_resp.status();
4059    let local_var_content = local_var_resp.text().await?;
4060
4061    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4062        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
4063    } else {
4064        let local_var_entity: Option<RunWaitResultFlowByPathError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
4065        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4066        Err(Error::ResponseError(local_var_error))
4067    }
4068}
4069
4070pub async fn run_wait_result_flow_by_version(configuration: &configuration::Configuration, workspace: &str, version: i64, request_body: std::collections::HashMap<String, serde_json::Value>, include_header: Option<&str>, queue_limit: Option<&str>, job_id: Option<&str>, skip_preprocessor: Option<bool>, memory_id: Option<&str>) -> Result<serde_json::Value, Error<RunWaitResultFlowByVersionError>> {
4071    let local_var_configuration = configuration;
4072
4073    let local_var_client = &local_var_configuration.client;
4074
4075    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/fv/{version}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), version=version);
4076    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4077
4078    if let Some(ref local_var_str) = include_header {
4079        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
4080    }
4081    if let Some(ref local_var_str) = queue_limit {
4082        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
4083    }
4084    if let Some(ref local_var_str) = job_id {
4085        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
4086    }
4087    if let Some(ref local_var_str) = skip_preprocessor {
4088        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
4089    }
4090    if let Some(ref local_var_str) = memory_id {
4091        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
4092    }
4093    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4094        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4095    }
4096    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
4097        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
4098    };
4099    local_var_req_builder = local_var_req_builder.json(&request_body);
4100
4101    let local_var_req = local_var_req_builder.build()?;
4102    let local_var_resp = local_var_client.execute(local_var_req).await?;
4103
4104    let local_var_status = local_var_resp.status();
4105    let local_var_content = local_var_resp.text().await?;
4106
4107    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4108        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
4109    } else {
4110        let local_var_entity: Option<RunWaitResultFlowByVersionError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
4111        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4112        Err(Error::ResponseError(local_var_error))
4113    }
4114}
4115
4116pub async fn run_wait_result_flow_by_version_get(configuration: &configuration::Configuration, workspace: &str, version: i64, include_header: Option<&str>, queue_limit: Option<&str>, payload: Option<&str>, job_id: Option<&str>, skip_preprocessor: Option<bool>, memory_id: Option<&str>) -> Result<serde_json::Value, Error<RunWaitResultFlowByVersionGetError>> {
4117    let local_var_configuration = configuration;
4118
4119    let local_var_client = &local_var_configuration.client;
4120
4121    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/fv/{version}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), version=version);
4122    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4123
4124    if let Some(ref local_var_str) = include_header {
4125        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
4126    }
4127    if let Some(ref local_var_str) = queue_limit {
4128        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
4129    }
4130    if let Some(ref local_var_str) = payload {
4131        local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
4132    }
4133    if let Some(ref local_var_str) = job_id {
4134        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
4135    }
4136    if let Some(ref local_var_str) = skip_preprocessor {
4137        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
4138    }
4139    if let Some(ref local_var_str) = memory_id {
4140        local_var_req_builder = local_var_req_builder.query(&[("memory_id", &local_var_str.to_string())]);
4141    }
4142    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4143        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4144    }
4145    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
4146        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
4147    };
4148
4149    let local_var_req = local_var_req_builder.build()?;
4150    let local_var_resp = local_var_client.execute(local_var_req).await?;
4151
4152    let local_var_status = local_var_resp.status();
4153    let local_var_content = local_var_resp.text().await?;
4154
4155    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4156        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
4157    } else {
4158        let local_var_entity: Option<RunWaitResultFlowByVersionGetError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
4159        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4160        Err(Error::ResponseError(local_var_error))
4161    }
4162}
4163
4164pub async fn run_wait_result_script_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>, skip_preprocessor: Option<bool>) -> Result<serde_json::Value, Error<RunWaitResultScriptByPathError>> {
4165    let local_var_configuration = configuration;
4166
4167    let local_var_client = &local_var_configuration.client;
4168
4169    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
4170    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4171
4172    if let Some(ref local_var_str) = parent_job {
4173        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
4174    }
4175    if let Some(ref local_var_str) = tag {
4176        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
4177    }
4178    if let Some(ref local_var_str) = cache_ttl {
4179        local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
4180    }
4181    if let Some(ref local_var_str) = job_id {
4182        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
4183    }
4184    if let Some(ref local_var_str) = include_header {
4185        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
4186    }
4187    if let Some(ref local_var_str) = queue_limit {
4188        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
4189    }
4190    if let Some(ref local_var_str) = skip_preprocessor {
4191        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
4192    }
4193    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4194        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4195    }
4196    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
4197        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
4198    };
4199    local_var_req_builder = local_var_req_builder.json(&request_body);
4200
4201    let local_var_req = local_var_req_builder.build()?;
4202    let local_var_resp = local_var_client.execute(local_var_req).await?;
4203
4204    let local_var_status = local_var_resp.status();
4205    let local_var_content = local_var_resp.text().await?;
4206
4207    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4208        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
4209    } else {
4210        let local_var_entity: Option<RunWaitResultScriptByPathError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
4211        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4212        Err(Error::ResponseError(local_var_error))
4213    }
4214}
4215
4216pub async fn run_wait_result_script_by_path_get(configuration: &configuration::Configuration, workspace: &str, path: &str, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>, payload: Option<&str>, skip_preprocessor: Option<bool>) -> Result<serde_json::Value, Error<RunWaitResultScriptByPathGetError>> {
4217    let local_var_configuration = configuration;
4218
4219    let local_var_client = &local_var_configuration.client;
4220
4221    let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
4222    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
4223
4224    if let Some(ref local_var_str) = parent_job {
4225        local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
4226    }
4227    if let Some(ref local_var_str) = tag {
4228        local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
4229    }
4230    if let Some(ref local_var_str) = cache_ttl {
4231        local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
4232    }
4233    if let Some(ref local_var_str) = job_id {
4234        local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
4235    }
4236    if let Some(ref local_var_str) = include_header {
4237        local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
4238    }
4239    if let Some(ref local_var_str) = queue_limit {
4240        local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
4241    }
4242    if let Some(ref local_var_str) = payload {
4243        local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
4244    }
4245    if let Some(ref local_var_str) = skip_preprocessor {
4246        local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
4247    }
4248    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4249        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4250    }
4251    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
4252        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
4253    };
4254
4255    let local_var_req = local_var_req_builder.build()?;
4256    let local_var_resp = local_var_client.execute(local_var_req).await?;
4257
4258    let local_var_status = local_var_resp.status();
4259    let local_var_content = local_var_resp.text().await?;
4260
4261    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4262        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
4263    } else {
4264        let local_var_entity: Option<RunWaitResultScriptByPathGetError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
4265        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4266        Err(Error::ResponseError(local_var_error))
4267    }
4268}
4269
4270pub async fn set_flow_user_state(configuration: &configuration::Configuration, workspace: &str, id: &str, key: &str, body: Option<serde_json::Value>) -> Result<String, Error<SetFlowUserStateError>> {
4271    let local_var_configuration = configuration;
4272
4273    let local_var_client = &local_var_configuration.client;
4274
4275    let local_var_uri_str = format!("{}/w/{workspace}/jobs/flow/user_states/{id}/{key}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), key=crate::apis::urlencode(key));
4276    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4277
4278    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4279        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4280    }
4281    if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
4282        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
4283    };
4284    local_var_req_builder = local_var_req_builder.json(&body);
4285
4286    let local_var_req = local_var_req_builder.build()?;
4287    let local_var_resp = local_var_client.execute(local_var_req).await?;
4288
4289    let local_var_status = local_var_resp.status();
4290    let local_var_content = local_var_resp.text().await?;
4291
4292    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4293        crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).map_err(Error::from)
4294    } else {
4295        let local_var_entity: Option<SetFlowUserStateError> = crate::from_str_patched/* Externally injected from /build.nu */(&local_var_content).ok();
4296        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4297        Err(Error::ResponseError(local_var_error))
4298    }
4299}
4300
orvanta_api/apis/job_api.rs

orvanta_api/apis/
job_api.rs
