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.3.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/// 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. 
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/// 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
