windmill_api/apis/
job_api.rs

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

windmill_api/apis/
job_api.rs
