benchling/
lib.rs

1//! [`BenchlingClient`](struct.BenchlingClient.html) is the main entry point for this library.
2//!
3//! Library created with [`libninja`](https://www.libninja.com).
4#![allow(non_camel_case_types)]
5#![allow(unused)]
6pub mod model;
7pub mod request;
8use crate::model::*;
9
10pub struct BenchlingClient {
11    pub(crate) client: httpclient::Client,
12    authentication: BenchlingAuthentication,
13}
14impl BenchlingClient {
15    pub fn from_env() -> Self {
16        let url = "/api/v2".to_string();
17        Self {
18            client: httpclient::Client::new(Some(url)),
19            authentication: BenchlingAuthentication::from_env(),
20        }
21    }
22}
23impl BenchlingClient {
24    pub fn new(url: &str, authentication: BenchlingAuthentication) -> Self {
25        let client = httpclient::Client::new(Some(url.to_string()));
26        Self { client, authentication }
27    }
28    pub fn with_authentication(
29        mut self,
30        authentication: BenchlingAuthentication,
31    ) -> Self {
32        self.authentication = authentication;
33        self
34    }
35    pub fn authenticate<'a>(
36        &self,
37        mut r: httpclient::RequestBuilder<'a>,
38    ) -> httpclient::RequestBuilder<'a> {
39        match &self.authentication {
40            BenchlingAuthentication::BasicApiKeyAuth { basic_api_key_auth } => {
41                r = r.basic_auth(basic_api_key_auth);
42            }
43        }
44        r
45    }
46    pub fn with_middleware<M: httpclient::Middleware + 'static>(
47        mut self,
48        middleware: M,
49    ) -> Self {
50        self.client = self.client.with_middleware(middleware);
51        self
52    }
53    ///List AA sequences
54    pub fn list_aa_sequences(&self) -> request::ListAaSequencesRequest {
55        request::ListAaSequencesRequest {
56            client: &self,
57            page_size: None,
58            next_token: None,
59            sort: None,
60            modified_at: None,
61            name: None,
62            name_includes: None,
63            amino_acids: None,
64            folder_id: None,
65            mentioned_in: None,
66            project_id: None,
67            registry_id: None,
68            schema_id: None,
69            schema_fields: None,
70            archive_reason: None,
71            mentions: None,
72            ids: None,
73            entity_registry_ids_any_of: None,
74            names_any_of: None,
75            names_any_of_case_sensitive: None,
76            creator_ids: None,
77            author_ids_any_of: None,
78        }
79    }
80    ///Create an AA sequence
81    pub fn create_aa_sequence(
82        &self,
83        args: request::CreateAaSequenceRequired,
84    ) -> request::CreateAaSequenceRequest {
85        request::CreateAaSequenceRequest {
86            client: &self,
87            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
88            amino_acids: args.amino_acids.to_owned(),
89            annotations: args.annotations,
90            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
91            custom_fields: args.custom_fields,
92            fields: args.fields,
93            folder_id: args.folder_id.to_owned(),
94            name: args.name.to_owned(),
95            schema_id: args.schema_id.to_owned(),
96            entity_registry_id: args.entity_registry_id.to_owned(),
97            naming_strategy: args.naming_strategy.to_owned(),
98            registry_id: args.registry_id.to_owned(),
99        }
100    }
101    ///Get an AA sequence
102    pub fn get_aa_sequence(
103        &self,
104        aa_sequence_id: &str,
105    ) -> request::GetAaSequenceRequest {
106        request::GetAaSequenceRequest {
107            client: &self,
108            aa_sequence_id: aa_sequence_id.to_owned(),
109        }
110    }
111    ///Update an AA sequence
112    pub fn update_aa_sequence(
113        &self,
114        args: request::UpdateAaSequenceRequired,
115    ) -> request::UpdateAaSequenceRequest {
116        request::UpdateAaSequenceRequest {
117            client: &self,
118            aa_sequence_id: args.aa_sequence_id.to_owned(),
119            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
120            amino_acids: args.amino_acids.to_owned(),
121            annotations: args.annotations,
122            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
123            custom_fields: args.custom_fields,
124            fields: args.fields,
125            folder_id: args.folder_id.to_owned(),
126            name: args.name.to_owned(),
127            schema_id: args.schema_id.to_owned(),
128            entity_registry_id: args.entity_registry_id.to_owned(),
129        }
130    }
131    ///Archive AA sequences
132    pub fn archive_aa_sequences(
133        &self,
134        aa_sequence_ids: &[&str],
135        reason: &str,
136    ) -> request::ArchiveAaSequencesRequest {
137        request::ArchiveAaSequencesRequest {
138            client: &self,
139            aa_sequence_ids: aa_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
140            reason: reason.to_owned(),
141        }
142    }
143    ///Auto-annotate AA sequences with matching features from specified Feature Libraries
144    pub fn auto_annotate_aa_sequences(
145        &self,
146        aa_sequence_ids: &[&str],
147        feature_library_ids: &[&str],
148    ) -> request::AutoAnnotateAaSequencesRequest {
149        request::AutoAnnotateAaSequencesRequest {
150            client: &self,
151            aa_sequence_ids: aa_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
152            feature_library_ids: feature_library_ids
153                .iter()
154                .map(|&x| x.to_owned())
155                .collect(),
156        }
157    }
158    /**Bulk Create AA sequences
159
160Bulk Create AA sequences. Limit of 1000 AA Sequences per request.*/
161    pub fn bulk_create_aa_sequences(&self) -> request::BulkCreateAaSequencesRequest {
162        request::BulkCreateAaSequencesRequest {
163            client: &self,
164            aa_sequences: None,
165        }
166    }
167    ///Bulk get AA sequences by ID
168    pub fn bulk_get_aa_sequences(
169        &self,
170        aa_sequence_ids: &str,
171    ) -> request::BulkGetAaSequencesRequest {
172        request::BulkGetAaSequencesRequest {
173            client: &self,
174            aa_sequence_ids: aa_sequence_ids.to_owned(),
175        }
176    }
177    ///Bulk Update AA sequences
178    pub fn bulk_update_aa_sequences(&self) -> request::BulkUpdateAaSequencesRequest {
179        request::BulkUpdateAaSequencesRequest {
180            client: &self,
181            aa_sequences: None,
182        }
183    }
184    ///Unarchive AA sequences
185    pub fn unarchive_aa_sequences(
186        &self,
187        aa_sequence_ids: &[&str],
188    ) -> request::UnarchiveAaSequencesRequest {
189        request::UnarchiveAaSequencesRequest {
190            client: &self,
191            aa_sequence_ids: aa_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
192        }
193    }
194    ///Get app configuration items
195    pub fn list_app_configuration_items(
196        &self,
197    ) -> request::ListAppConfigurationItemsRequest {
198        request::ListAppConfigurationItemsRequest {
199            client: &self,
200            next_token: None,
201            page_size: None,
202            modified_at: None,
203            app_id: None,
204            ids: None,
205            sort: None,
206        }
207    }
208    ///Create app configuration item
209    pub fn create_app_configuration_item(
210        &self,
211    ) -> request::CreateAppConfigurationItemRequest {
212        request::CreateAppConfigurationItemRequest {
213            client: &self,
214        }
215    }
216    ///Get app configuration item
217    pub fn get_app_configuration_item_by_id(
218        &self,
219        item_id: &str,
220    ) -> request::GetAppConfigurationItemByIdRequest {
221        request::GetAppConfigurationItemByIdRequest {
222            client: &self,
223            item_id: item_id.to_owned(),
224        }
225    }
226    ///Update app configuration item
227    pub fn update_app_configuration_item(
228        &self,
229        item_id: &str,
230    ) -> request::UpdateAppConfigurationItemRequest {
231        request::UpdateAppConfigurationItemRequest {
232            client: &self,
233            item_id: item_id.to_owned(),
234        }
235    }
236    /**Bulk Create app configuration items. Limit of 1000 App Config Items per request.
237
238Bulk Create app configuration items*/
239    pub fn bulk_create_app_configuration_items(
240        &self,
241        app_configuration_items: Vec<AppConfigItemCreate>,
242    ) -> request::BulkCreateAppConfigurationItemsRequest {
243        request::BulkCreateAppConfigurationItemsRequest {
244            client: &self,
245            app_configuration_items,
246        }
247    }
248    /**Bulk Update app configuration items. Limit of 1000 App Config Items per request.
249
250Bulk Update app configuration items*/
251    pub fn bulk_update_app_configuration_items(
252        &self,
253        app_configuration_items: Vec<AppConfigItemBulkUpdate>,
254    ) -> request::BulkUpdateAppConfigurationItemsRequest {
255        request::BulkUpdateAppConfigurationItemsRequest {
256            client: &self,
257            app_configuration_items,
258        }
259    }
260    ///List apps
261    pub fn list_benchling_apps(&self) -> request::ListBenchlingAppsRequest {
262        request::ListBenchlingAppsRequest {
263            client: &self,
264            page_size: None,
265            next_token: None,
266            sort: None,
267            ids: None,
268            modified_at: None,
269            name: None,
270            name_includes: None,
271            names_any_of: None,
272            names_any_of_case_sensitive: None,
273            creator_ids: None,
274            member_of: None,
275            admin_of: None,
276        }
277    }
278    ///Create an app
279    pub fn create_benchling_app(
280        &self,
281        name: &str,
282    ) -> request::CreateBenchlingAppRequest {
283        request::CreateBenchlingAppRequest {
284            client: &self,
285            description: None,
286            name: name.to_owned(),
287        }
288    }
289    ///Get an app by ID
290    pub fn get_benchling_app_by_id(
291        &self,
292        app_id: &str,
293    ) -> request::GetBenchlingAppByIdRequest {
294        request::GetBenchlingAppByIdRequest {
295            client: &self,
296            app_id: app_id.to_owned(),
297        }
298    }
299    ///Update an app
300    pub fn patch_benchling_app(
301        &self,
302        app_id: &str,
303    ) -> request::PatchBenchlingAppRequest {
304        request::PatchBenchlingAppRequest {
305            client: &self,
306            app_id: app_id.to_owned(),
307            description: None,
308            name: None,
309        }
310    }
311    ///Archive apps
312    pub fn archive_benchling_apps(
313        &self,
314        app_ids: &[&str],
315        reason: &str,
316    ) -> request::ArchiveBenchlingAppsRequest {
317        request::ArchiveBenchlingAppsRequest {
318            client: &self,
319            app_ids: app_ids.iter().map(|&x| x.to_owned()).collect(),
320            reason: reason.to_owned(),
321        }
322    }
323    ///Unarchive apps
324    pub fn unarchive_benchling_apps(
325        &self,
326        app_ids: &[&str],
327    ) -> request::UnarchiveBenchlingAppsRequest {
328        request::UnarchiveBenchlingAppsRequest {
329            client: &self,
330            app_ids: app_ids.iter().map(|&x| x.to_owned()).collect(),
331        }
332    }
333    ///List assay result schemas
334    pub fn list_assay_result_schemas(&self) -> request::ListAssayResultSchemasRequest {
335        request::ListAssayResultSchemasRequest {
336            client: &self,
337            next_token: None,
338            page_size: None,
339            modified_at: None,
340        }
341    }
342    ///Get a Result schema by ID
343    pub fn get_result_schema(&self, schema_id: &str) -> request::GetResultSchemaRequest {
344        request::GetResultSchemaRequest {
345            client: &self,
346            schema_id: schema_id.to_owned(),
347        }
348    }
349    ///List results
350    pub fn list_assay_results(
351        &self,
352        schema_id: &str,
353    ) -> request::ListAssayResultsRequest {
354        request::ListAssayResultsRequest {
355            client: &self,
356            schema_id: schema_id.to_owned(),
357            created_at_lt: None,
358            created_at_gt: None,
359            created_at_lte: None,
360            created_at_gte: None,
361            min_created_time: None,
362            max_created_time: None,
363            sort: None,
364            next_token: None,
365            page_size: None,
366            entity_ids: None,
367            storage_ids: None,
368            assay_run_ids: None,
369            ids: None,
370        }
371    }
372    ///Create 1 or more results.
373    pub fn create_assay_results(
374        &self,
375        assay_results: Vec<AssayResultCreate>,
376    ) -> request::CreateAssayResultsRequest {
377        request::CreateAssayResultsRequest {
378            client: &self,
379            assay_results,
380        }
381    }
382    ///Get a result
383    pub fn get_assay_result(
384        &self,
385        assay_result_id: &str,
386    ) -> request::GetAssayResultRequest {
387        request::GetAssayResultRequest {
388            client: &self,
389            assay_result_id: assay_result_id.to_owned(),
390        }
391    }
392    /**Archive 1 or more results.
393
394**Only results that have not been added to a Notebook Entry can be Archived.**
395Once results are attached to a notebook entry, they are tracked in the history of that notebook entry, and cannot be archived.
396*/
397    pub fn archive_assay_results(
398        &self,
399        assay_result_ids: &[&str],
400        reason: &str,
401    ) -> request::ArchiveAssayResultsRequest {
402        request::ArchiveAssayResultsRequest {
403            client: &self,
404            assay_result_ids: assay_result_ids.iter().map(|&x| x.to_owned()).collect(),
405            reason: reason.to_owned(),
406        }
407    }
408    /**Gets multiple results specified by a list of IDs.
409
410Up to 200 IDs can be specified at once.*/
411    pub fn bulk_get_assay_results(
412        &self,
413        assay_result_ids: &str,
414    ) -> request::BulkGetAssayResultsRequest {
415        request::BulkGetAssayResultsRequest {
416            client: &self,
417            assay_result_ids: assay_result_ids.to_owned(),
418        }
419    }
420    ///Unarchive 1 or more results.
421    pub fn unarchive_assay_results(
422        &self,
423        assay_result_ids: &[&str],
424    ) -> request::UnarchiveAssayResultsRequest {
425        request::UnarchiveAssayResultsRequest {
426            client: &self,
427            assay_result_ids: assay_result_ids.iter().map(|&x| x.to_owned()).collect(),
428        }
429    }
430    ///List assay run schemas
431    pub fn list_assay_run_schemas(&self) -> request::ListAssayRunSchemasRequest {
432        request::ListAssayRunSchemasRequest {
433            client: &self,
434            next_token: None,
435            page_size: None,
436            modified_at: None,
437        }
438    }
439    ///Get a Run schema by ID
440    pub fn get_run_schema(&self, schema_id: &str) -> request::GetRunSchemaRequest {
441        request::GetRunSchemaRequest {
442            client: &self,
443            schema_id: schema_id.to_owned(),
444        }
445    }
446    ///List runs
447    pub fn list_assay_runs(&self, schema_id: &str) -> request::ListAssayRunsRequest {
448        request::ListAssayRunsRequest {
449            client: &self,
450            schema_id: schema_id.to_owned(),
451            min_created_time: None,
452            max_created_time: None,
453            next_token: None,
454            page_size: None,
455            ids: None,
456        }
457    }
458    ///Create 1 or more runs.
459    pub fn create_assay_runs(
460        &self,
461        assay_runs: Vec<AssayRunCreate>,
462    ) -> request::CreateAssayRunsRequest {
463        request::CreateAssayRunsRequest {
464            client: &self,
465            assay_runs,
466        }
467    }
468    ///Get a run
469    pub fn get_assay_run(&self, assay_run_id: &str) -> request::GetAssayRunRequest {
470        request::GetAssayRunRequest {
471            client: &self,
472            assay_run_id: assay_run_id.to_owned(),
473        }
474    }
475    ///Update a run
476    pub fn update_assay_run(
477        &self,
478        assay_run_id: &str,
479    ) -> request::UpdateAssayRunRequest {
480        request::UpdateAssayRunRequest {
481            client: &self,
482            assay_run_id: assay_run_id.to_owned(),
483            fields: None,
484        }
485    }
486    ///list AutomationInputGenerators by Run
487    pub fn list_automation_input_generators(
488        &self,
489        assay_run_id: &str,
490    ) -> request::ListAutomationInputGeneratorsRequest {
491        request::ListAutomationInputGeneratorsRequest {
492            client: &self,
493            assay_run_id: assay_run_id.to_owned(),
494            next_token: None,
495            modified_at: None,
496        }
497    }
498    /**list AutomationOutputProcessors by Run
499
500Deprecated in favor of '/automation-output-processors'. For each output config in the run config, will create an empty automationOutputProcessor for the run if one doesn't exist.*/
501    pub fn list_automation_output_processors_deprecated(
502        &self,
503        assay_run_id: &str,
504    ) -> request::ListAutomationOutputProcessorsDeprecatedRequest {
505        request::ListAutomationOutputProcessorsDeprecatedRequest {
506            client: &self,
507            assay_run_id: assay_run_id.to_owned(),
508            next_token: None,
509        }
510    }
511    /**Archive Assay Runs
512
513Archive assay runs that are not embedded in a notebook entry*/
514    pub fn archive_assay_runs(
515        &self,
516        assay_run_ids: &[&str],
517        reason: &str,
518    ) -> request::ArchiveAssayRunsRequest {
519        request::ArchiveAssayRunsRequest {
520            client: &self,
521            assay_run_ids: assay_run_ids.iter().map(|&x| x.to_owned()).collect(),
522            reason: reason.to_owned(),
523        }
524    }
525    ///Bulk get runs by ID
526    pub fn bulk_get_assay_runs(
527        &self,
528        assay_run_ids: &str,
529    ) -> request::BulkGetAssayRunsRequest {
530        request::BulkGetAssayRunsRequest {
531            client: &self,
532            assay_run_ids: assay_run_ids.to_owned(),
533        }
534    }
535    /**Unarchive Assay Runs
536
537Unarchive assay runs*/
538    pub fn unarchive_assay_runs(
539        &self,
540        assay_run_ids: &[&str],
541    ) -> request::UnarchiveAssayRunsRequest {
542        request::UnarchiveAssayRunsRequest {
543            client: &self,
544            assay_run_ids: assay_run_ids.iter().map(|&x| x.to_owned()).collect(),
545        }
546    }
547    ///Get a Lab Automation Transform step
548    pub fn get_lab_automation_transform(
549        &self,
550        transform_id: &str,
551    ) -> request::GetLabAutomationTransformRequest {
552        request::GetLabAutomationTransformRequest {
553            client: &self,
554            transform_id: transform_id.to_owned(),
555        }
556    }
557    ///Update a Lab Automation Transform step
558    pub fn update_lab_automation_transform(
559        &self,
560        transform_id: &str,
561    ) -> request::UpdateLabAutomationTransformRequest {
562        request::UpdateLabAutomationTransformRequest {
563            client: &self,
564            transform_id: transform_id.to_owned(),
565            blob_id: None,
566            errors: None,
567        }
568    }
569    ///Get an Automation Input Generator
570    pub fn get_automation_input_generator(
571        &self,
572        input_generator_id: &str,
573    ) -> request::GetAutomationInputGeneratorRequest {
574        request::GetAutomationInputGeneratorRequest {
575            client: &self,
576            input_generator_id: input_generator_id.to_owned(),
577        }
578    }
579    ///Update an Automation Input Generator
580    pub fn update_automation_input_generator(
581        &self,
582        input_generator_id: &str,
583    ) -> request::UpdateAutomationInputGeneratorRequest {
584        request::UpdateAutomationInputGeneratorRequest {
585            client: &self,
586            input_generator_id: input_generator_id.to_owned(),
587            file_id: None,
588        }
589    }
590    ///Generate Input with an Automation Input Generator
591    pub fn generate_input_with_automation_input_generator(
592        &self,
593        input_generator_id: &str,
594    ) -> request::GenerateInputWithAutomationInputGeneratorRequest {
595        request::GenerateInputWithAutomationInputGeneratorRequest {
596            client: &self,
597            input_generator_id: input_generator_id.to_owned(),
598        }
599    }
600    /**List non-empty Automation Output Processors
601
602List Automation Output Processors which have an attached file*/
603    pub fn list_automation_output_processors(
604        &self,
605    ) -> request::ListAutomationOutputProcessorsRequest {
606        request::ListAutomationOutputProcessorsRequest {
607            client: &self,
608            assay_run_id: None,
609            automation_file_config_name: None,
610            archive_reason: None,
611            modified_at: None,
612            next_token: None,
613        }
614    }
615    ///Create Automation Output Processor
616    pub fn create_automation_output_processor(
617        &self,
618        assay_run_id: &str,
619        automation_file_config_name: &str,
620        file_id: &str,
621    ) -> request::CreateAutomationOutputProcessorRequest {
622        request::CreateAutomationOutputProcessorRequest {
623            client: &self,
624            assay_run_id: assay_run_id.to_owned(),
625            automation_file_config_name: automation_file_config_name.to_owned(),
626            complete_with_errors: None,
627            file_id: file_id.to_owned(),
628        }
629    }
630    ///Get an Automation Output Processor
631    pub fn get_automation_output_processor(
632        &self,
633        output_processor_id: &str,
634    ) -> request::GetAutomationOutputProcessorRequest {
635        request::GetAutomationOutputProcessorRequest {
636            client: &self,
637            output_processor_id: output_processor_id.to_owned(),
638        }
639    }
640    ///Update an Automation Output Processor
641    pub fn update_automation_output_processor(
642        &self,
643        output_processor_id: &str,
644        file_id: &str,
645    ) -> request::UpdateAutomationOutputProcessorRequest {
646        request::UpdateAutomationOutputProcessorRequest {
647            client: &self,
648            output_processor_id: output_processor_id.to_owned(),
649            file_id: file_id.to_owned(),
650        }
651    }
652    ///Process Output with an Automation Output Processor
653    pub fn process_output_with_automation_output_processor(
654        &self,
655        output_processor_id: &str,
656    ) -> request::ProcessOutputWithAutomationOutputProcessorRequest {
657        request::ProcessOutputWithAutomationOutputProcessorRequest {
658            client: &self,
659            output_processor_id: output_processor_id.to_owned(),
660        }
661    }
662    ///Archive Automation Output Processors and linked Results
663    pub fn archive_automation_output_processors(
664        &self,
665        automation_output_processor_ids: &[&str],
666    ) -> request::ArchiveAutomationOutputProcessorsRequest {
667        request::ArchiveAutomationOutputProcessorsRequest {
668            client: &self,
669            automation_output_processor_ids: automation_output_processor_ids
670                .iter()
671                .map(|&x| x.to_owned())
672                .collect(),
673            reason: None,
674        }
675    }
676    ///Unarchive Automation Output Processors and linked Results
677    pub fn unarchive_automation_output_processors(
678        &self,
679        automation_output_processor_ids: &[&str],
680    ) -> request::UnarchiveAutomationOutputProcessorsRequest {
681        request::UnarchiveAutomationOutputProcessorsRequest {
682            client: &self,
683            automation_output_processor_ids: automation_output_processor_ids
684                .iter()
685                .map(|&x| x.to_owned())
686                .collect(),
687        }
688    }
689    ///List batch schemas
690    pub fn list_batch_schemas(&self) -> request::ListBatchSchemasRequest {
691        request::ListBatchSchemasRequest {
692            client: &self,
693            next_token: None,
694            page_size: None,
695            modified_at: None,
696        }
697    }
698    ///Get a batch schema by ID
699    pub fn get_batch_schema(&self, schema_id: &str) -> request::GetBatchSchemaRequest {
700        request::GetBatchSchemaRequest {
701            client: &self,
702            schema_id: schema_id.to_owned(),
703        }
704    }
705    ///List batches
706    pub fn list_batches(&self) -> request::ListBatchesRequest {
707        request::ListBatchesRequest {
708            client: &self,
709            page_size: None,
710            next_token: None,
711            sort: None,
712            modified_at: None,
713            schema_id: None,
714            schema_fields: None,
715            archive_reason: None,
716            ids: None,
717            creator_ids: None,
718        }
719    }
720    ///Create a batch
721    pub fn create_batch(&self) -> request::CreateBatchRequest {
722        request::CreateBatchRequest {
723            client: &self,
724            default_concentration: None,
725            entity_id: None,
726            fields: None,
727        }
728    }
729    ///Get a batch
730    pub fn get_batch(&self, batch_id: &str) -> request::GetBatchRequest {
731        request::GetBatchRequest {
732            client: &self,
733            batch_id: batch_id.to_owned(),
734        }
735    }
736    ///Update a batch
737    pub fn update_batch(&self, batch_id: &str) -> request::UpdateBatchRequest {
738        request::UpdateBatchRequest {
739            client: &self,
740            batch_id: batch_id.to_owned(),
741            default_concentration: None,
742            fields: None,
743        }
744    }
745    ///Archive Batches
746    pub fn archive_batches(
747        &self,
748        batch_ids: &[&str],
749        reason: &str,
750    ) -> request::ArchiveBatchesRequest {
751        request::ArchiveBatchesRequest {
752            client: &self,
753            batch_ids: batch_ids.iter().map(|&x| x.to_owned()).collect(),
754            reason: reason.to_owned(),
755        }
756    }
757    /**Bulk get batches
758
759Batches can be queried by their IDs or their names. Querying by name requires specifying a registryId since batch names are not necessarily unique across registries. Batches must be registered to query by name.
760*/
761    pub fn bulk_get_batches(&self) -> request::BulkGetBatchesRequest {
762        request::BulkGetBatchesRequest {
763            client: &self,
764            batch_ids: None,
765            batch_names: None,
766            registry_id: None,
767        }
768    }
769    ///Unarchive Batches
770    pub fn unarchive_batches(
771        &self,
772        batch_ids: &[&str],
773    ) -> request::UnarchiveBatchesRequest {
774        request::UnarchiveBatchesRequest {
775            client: &self,
776            batch_ids: batch_ids.iter().map(|&x| x.to_owned()).collect(),
777        }
778    }
779    /**Upload single-part blob
780
781
782This endpoint uploads a blob in a single API call.
783
784Blobs larger than 10MB should be uploaded in [multiple parts](#/Blobs/createMultipartBlob). The data64 parameter is the base64-encoded part contents, and the md5 parameter is the hex-encoded MD5 hash of the part contents. For example, given the string hello, data64 is aGVsbG8= and md5 is 5d41402abc4b2a76b9719d911017c592.
785*/
786    pub fn create_blob(
787        &self,
788        args: request::CreateBlobRequired,
789    ) -> request::CreateBlobRequest {
790        request::CreateBlobRequest {
791            client: &self,
792            data64: args.data64.to_owned(),
793            md5: args.md5.to_owned(),
794            mime_type: None,
795            name: args.name.to_owned(),
796            type_: args.type_.to_owned(),
797        }
798    }
799    ///Get a Blob
800    pub fn get_blob(&self, blob_id: &str) -> request::GetBlobRequest {
801        request::GetBlobRequest {
802            client: &self,
803            blob_id: blob_id.to_owned(),
804        }
805    }
806    ///Get a Blob's download url
807    pub fn get_blob_url(&self, blob_id: &str) -> request::GetBlobUrlRequest {
808        request::GetBlobUrlRequest {
809            client: &self,
810            blob_id: blob_id.to_owned(),
811        }
812    }
813    /**Upload a part of a multi-part blob
814
815
816Upload a part of the blob. This part must be at least 5MB, unless it's the last or only part. It's recommended to keep the part size around 10MB.
817
818The data64 parameter is the base64-encoded part contents, and the md5 parameter is the hex-encoded MD5 hash of the part contents. For example, given the string hello, data64 is aGVsbG8= and md5 is 5d41402abc4b2a76b9719d911017c592.
819
820## Multipart Upload
821
822If a blob is larger than 10MB, it should be uploaded in multiple parts using the following endpoints:
823- [Start a multi-part blob upload](#/Blobs/createMultipartBlob)
824- [Upload a blob part](#/Blobs/createBlobPart)
825- [Complete a blob upload](#/Blobs/completeMultipartBlob)
826
827Each part has a *partNumber* and an *eTag*. The part number can be any number between 1 to 10,000, inclusive - this number should be unique and identifies the order of the part in the final blob. The eTag of a part is returned in the API response - this eTag must be specified when completing the upload in order to ensure the server has received all the expected parts.
828*/
829    pub fn create_blob_part(
830        &self,
831        args: request::CreateBlobPartRequired,
832    ) -> request::CreateBlobPartRequest {
833        request::CreateBlobPartRequest {
834            client: &self,
835            blob_id: args.blob_id.to_owned(),
836            data64: args.data64.to_owned(),
837            md5: args.md5.to_owned(),
838            part_number: args.part_number,
839        }
840    }
841    ///Abort multi-part blob upload
842    pub fn abort_multipart_blob(
843        &self,
844        blob_id: &str,
845    ) -> request::AbortMultipartBlobRequest {
846        request::AbortMultipartBlobRequest {
847            client: &self,
848            blob_id: blob_id.to_owned(),
849        }
850    }
851    /**Complete multi-part blob upload
852
853
854Combine blob parts into a single blob.
855
856## Multipart Upload
857
858If a blob is larger than 10MB, it should be uploaded in multiple parts using the following endpoints:
859- [Start a multi-part blob upload](#/Blobs/createMultipartBlob)
860- [Upload a blob part](#/Blobs/createBlobPart)
861- [Complete a blob upload](#/Blobs/completeMultipartBlob)
862
863Each part must be at least 5MB in size, except for the last part. We recommend keeping each part to under 10MB when uploading.
864
865Each part has a *partNumber* and an *eTag*. The part number can be any number between 1 to 10,000, inclusive - this number should be unique and identifies the order of the part in the final blob. The eTag of a part is returned in the API response - this eTag must be specified when completing the upload in order to ensure the server has received all the expected parts.
866*/
867    pub fn complete_multipart_blob(
868        &self,
869        blob_id: &str,
870    ) -> request::CompleteMultipartBlobRequest {
871        request::CompleteMultipartBlobRequest {
872            client: &self,
873            blob_id: blob_id.to_owned(),
874            parts: None,
875        }
876    }
877    ///Bulk get Blobs by UUID
878    pub fn bulk_get_blobs(&self) -> request::BulkGetBlobsRequest {
879        request::BulkGetBlobsRequest {
880            client: &self,
881            blob_ids: None,
882        }
883    }
884    /**Initiate multi-part blob upload
885
886
887Blobs may be uploaded using multi-part upload. This endpoint initiates the upload process - blob parts can then be uploaded in multiple blob parts.
888
889## Multipart Upload
890
891If a blob is larger than 10MB, it should be uploaded in multiple parts using the following endpoints:
892- [Start a multi-part blob upload](#/Blobs/createMultipartBlob)
893- [Upload a blob part](#/Blobs/createBlobPart)
894- [Complete a blob upload](#/Blobs/completeMultipartBlob)
895
896Each part must be at least 5MB in size, except for the last part. We recommend keeping each part to under 10MB when uploading.
897
898Each part has a *partNumber* and an *eTag*. The part number can be any number between 1 to 10,000, inclusive - this number should be unique and identifies the order of the part in the final blob. The eTag of a part is returned in the API response - this eTag must be specified when completing the upload in order to ensure the server has received all the expected parts.
899*/
900    pub fn create_multipart_blob(
901        &self,
902        name: &str,
903        type_: &str,
904    ) -> request::CreateMultipartBlobRequest {
905        request::CreateMultipartBlobRequest {
906            client: &self,
907            mime_type: None,
908            name: name.to_owned(),
909            type_: type_.to_owned(),
910        }
911    }
912    ///List box schemas
913    pub fn list_box_schemas(&self) -> request::ListBoxSchemasRequest {
914        request::ListBoxSchemasRequest {
915            client: &self,
916            next_token: None,
917            page_size: None,
918        }
919    }
920    ///Get a box schema by ID
921    pub fn get_box_schema(&self, schema_id: &str) -> request::GetBoxSchemaRequest {
922        request::GetBoxSchemaRequest {
923            client: &self,
924            schema_id: schema_id.to_owned(),
925        }
926    }
927    ///List boxes
928    pub fn list_boxes(&self) -> request::ListBoxesRequest {
929        request::ListBoxesRequest {
930            client: &self,
931            page_size: None,
932            next_token: None,
933            sort: None,
934            schema_id: None,
935            schema_fields: None,
936            modified_at: None,
937            name: None,
938            name_includes: None,
939            empty_positions: None,
940            empty_positions_gte: None,
941            empty_positions_gt: None,
942            empty_positions_lte: None,
943            empty_positions_lt: None,
944            empty_containers: None,
945            empty_containers_gte: None,
946            empty_containers_gt: None,
947            empty_containers_lte: None,
948            empty_containers_lt: None,
949            ancestor_storage_id: None,
950            storage_contents_id: None,
951            storage_contents_ids: None,
952            archive_reason: None,
953            ids: None,
954            barcodes: None,
955            names_any_of: None,
956            names_any_of_case_sensitive: None,
957            creator_ids: None,
958        }
959    }
960    ///Create a box
961    pub fn create_box(&self, schema_id: &str) -> request::CreateBoxRequest {
962        request::CreateBoxRequest {
963            client: &self,
964            barcode: None,
965            fields: None,
966            name: None,
967            parent_storage_id: None,
968            project_id: None,
969            schema_id: schema_id.to_owned(),
970        }
971    }
972    ///Get a box
973    pub fn get_box(&self, box_id: &str) -> request::GetBoxRequest {
974        request::GetBoxRequest {
975            client: &self,
976            box_id: box_id.to_owned(),
977        }
978    }
979    ///Update a box
980    pub fn update_box(&self, box_id: &str) -> request::UpdateBoxRequest {
981        request::UpdateBoxRequest {
982            client: &self,
983            box_id: box_id.to_owned(),
984            fields: None,
985            name: None,
986            parent_storage_id: None,
987            project_id: None,
988        }
989    }
990    ///List a box's contents
991    pub fn list_box_contents(&self, box_id: &str) -> request::ListBoxContentsRequest {
992        request::ListBoxContentsRequest {
993            client: &self,
994            box_id: box_id.to_owned(),
995            page_size: None,
996            next_token: None,
997        }
998    }
999    /**Archive boxes
1000
1001Archive boxes and any containers of the boxes*/
1002    pub fn archive_boxes(
1003        &self,
1004        box_ids: &[&str],
1005        reason: &str,
1006    ) -> request::ArchiveBoxesRequest {
1007        request::ArchiveBoxesRequest {
1008            client: &self,
1009            box_ids: box_ids.iter().map(|&x| x.to_owned()).collect(),
1010            reason: reason.to_owned(),
1011            should_remove_barcodes: None,
1012        }
1013    }
1014    ///BulkGet boxes
1015    pub fn bulk_get_boxes(&self) -> request::BulkGetBoxesRequest {
1016        request::BulkGetBoxesRequest {
1017            client: &self,
1018            box_ids: None,
1019            barcodes: None,
1020        }
1021    }
1022    /**Unarchive boxes
1023
1024Unarchive boxes and the containers that were archived along with them*/
1025    pub fn unarchive_boxes(&self, box_ids: &[&str]) -> request::UnarchiveBoxesRequest {
1026        request::UnarchiveBoxesRequest {
1027            client: &self,
1028            box_ids: box_ids.iter().map(|&x| x.to_owned()).collect(),
1029        }
1030    }
1031    ///List container schemas
1032    pub fn list_container_schemas(&self) -> request::ListContainerSchemasRequest {
1033        request::ListContainerSchemasRequest {
1034            client: &self,
1035            next_token: None,
1036            page_size: None,
1037            modified_at: None,
1038        }
1039    }
1040    ///Get a container schema by ID
1041    pub fn get_container_schema(
1042        &self,
1043        schema_id: &str,
1044    ) -> request::GetContainerSchemaRequest {
1045        request::GetContainerSchemaRequest {
1046            client: &self,
1047            schema_id: schema_id.to_owned(),
1048        }
1049    }
1050    ///List containers
1051    pub fn list_containers(&self) -> request::ListContainersRequest {
1052        request::ListContainersRequest {
1053            client: &self,
1054            page_size: None,
1055            next_token: None,
1056            sort: None,
1057            schema_id: None,
1058            schema_fields: None,
1059            modified_at: None,
1060            name: None,
1061            name_includes: None,
1062            ancestor_storage_id: None,
1063            storage_contents_id: None,
1064            storage_contents_ids: None,
1065            archive_reason: None,
1066            checkout_status: None,
1067            ids: None,
1068            barcodes: None,
1069            names_any_of: None,
1070            names_any_of_case_sensitive: None,
1071            creator_ids: None,
1072        }
1073    }
1074    ///Create a new container
1075    pub fn create_container(
1076        &self,
1077        args: request::CreateContainerRequired,
1078    ) -> request::CreateContainerRequest {
1079        request::CreateContainerRequest {
1080            client: &self,
1081            fields: args.fields,
1082            name: args.name.to_owned(),
1083            parent_storage_id: args.parent_storage_id.to_owned(),
1084            barcode: args.barcode.to_owned(),
1085            project_id: None,
1086            schema_id: args.schema_id.to_owned(),
1087        }
1088    }
1089    ///get a container by id
1090    pub fn get_container(&self, container_id: &str) -> request::GetContainerRequest {
1091        request::GetContainerRequest {
1092            client: &self,
1093            container_id: container_id.to_owned(),
1094        }
1095    }
1096    ///update a container
1097    pub fn update_container(
1098        &self,
1099        args: request::UpdateContainerRequired,
1100    ) -> request::UpdateContainerRequest {
1101        request::UpdateContainerRequest {
1102            client: &self,
1103            container_id: args.container_id.to_owned(),
1104            fields: args.fields,
1105            name: args.name.to_owned(),
1106            parent_storage_id: args.parent_storage_id.to_owned(),
1107            project_id: None,
1108            quantity: args.quantity,
1109            volume: args.volume,
1110        }
1111    }
1112    ///List a container's contents
1113    pub fn list_container_contents(
1114        &self,
1115        container_id: &str,
1116    ) -> request::ListContainerContentsRequest {
1117        request::ListContainerContentsRequest {
1118            client: &self,
1119            container_id: container_id.to_owned(),
1120        }
1121    }
1122    ///Get a container content
1123    pub fn get_container_content(
1124        &self,
1125        container_id: &str,
1126        containable_id: &str,
1127    ) -> request::GetContainerContentRequest {
1128        request::GetContainerContentRequest {
1129            client: &self,
1130            container_id: container_id.to_owned(),
1131            containable_id: containable_id.to_owned(),
1132        }
1133    }
1134    ///Delete a container content
1135    pub fn delete_container_content(
1136        &self,
1137        container_id: &str,
1138        containable_id: &str,
1139    ) -> request::DeleteContainerContentRequest {
1140        request::DeleteContainerContentRequest {
1141            client: &self,
1142            container_id: container_id.to_owned(),
1143            containable_id: containable_id.to_owned(),
1144        }
1145    }
1146    ///Update a container content
1147    pub fn update_container_content(
1148        &self,
1149        container_id: &str,
1150        containable_id: &str,
1151        concentration: Measurement,
1152    ) -> request::UpdateContainerContentRequest {
1153        request::UpdateContainerContentRequest {
1154            client: &self,
1155            container_id: container_id.to_owned(),
1156            containable_id: containable_id.to_owned(),
1157            concentration,
1158        }
1159    }
1160    /**Transfer into container
1161
1162Transfers a volume of an entity, batch, or container into a destination container.
1163Transfering a volume is cumulative with the existing destination container's contents. To transfer an entire container's contents, the sourceContainerId should be specified. To otherwise transfer multiple entities within a container, you can make multiple calls to this endpoint, specifying a single entity with each call.
1164*/
1165    pub fn transfer_into_container(
1166        &self,
1167        destination_container_id: &str,
1168    ) -> request::TransferIntoContainerRequest {
1169        request::TransferIntoContainerRequest {
1170            client: &self,
1171            destination_container_id: destination_container_id.to_owned(),
1172        }
1173    }
1174    ///Archive containers
1175    pub fn archive_containers(
1176        &self,
1177        container_ids: &[&str],
1178        reason: &str,
1179    ) -> request::ArchiveContainersRequest {
1180        request::ArchiveContainersRequest {
1181            client: &self,
1182            container_ids: container_ids.iter().map(|&x| x.to_owned()).collect(),
1183            reason: reason.to_owned(),
1184            should_remove_barcodes: None,
1185        }
1186    }
1187    /**Bulk create containers. Limit of 1000 containers per request.
1188
1189Bulk create containers*/
1190    pub fn bulk_create_containers(
1191        &self,
1192        containers: Vec<ContainerCreate>,
1193    ) -> request::BulkCreateContainersRequest {
1194        request::BulkCreateContainersRequest {
1195            client: &self,
1196            containers,
1197        }
1198    }
1199    /**Bulk get a set of containers
1200
1201Bulk get a set of containers. Provide either containerIds or barcodes, not both.*/
1202    pub fn bulk_get_containers(&self) -> request::BulkGetContainersRequest {
1203        request::BulkGetContainersRequest {
1204            client: &self,
1205            container_ids: None,
1206            barcodes: None,
1207        }
1208    }
1209    ///Bulk update containers
1210    pub fn bulk_update_containers(
1211        &self,
1212        containers: Vec<ContainerBulkUpdateItem>,
1213    ) -> request::BulkUpdateContainersRequest {
1214        request::BulkUpdateContainersRequest {
1215            client: &self,
1216            containers,
1217        }
1218    }
1219    /**Check in containers
1220
1221Check in containers to signify that they are available for use.*/
1222    pub fn checkin_containers(
1223        &self,
1224        container_ids: &[&str],
1225    ) -> request::CheckinContainersRequest {
1226        request::CheckinContainersRequest {
1227            client: &self,
1228            comments: None,
1229            container_ids: container_ids.iter().map(|&x| x.to_owned()).collect(),
1230        }
1231    }
1232    /**Check out containers
1233
1234Check out containers to signify that they are in use.*/
1235    pub fn checkout_containers(
1236        &self,
1237        assignee_id: &str,
1238        container_ids: &[&str],
1239    ) -> request::CheckoutContainersRequest {
1240        request::CheckoutContainersRequest {
1241            client: &self,
1242            assignee_id: assignee_id.to_owned(),
1243            comment: None,
1244            container_ids: container_ids.iter().map(|&x| x.to_owned()).collect(),
1245        }
1246    }
1247    ///Print labels
1248    pub fn print_labels(
1249        &self,
1250        container_ids: &[&str],
1251        label_template_id: &str,
1252        printer_id: &str,
1253    ) -> request::PrintLabelsRequest {
1254        request::PrintLabelsRequest {
1255            client: &self,
1256            container_ids: container_ids.iter().map(|&x| x.to_owned()).collect(),
1257            label_template_id: label_template_id.to_owned(),
1258            printer_id: printer_id.to_owned(),
1259        }
1260    }
1261    /**Reserve containers
1262
1263Reserve containers to signify that someone plans to use the containers.*/
1264    pub fn reserve_containers(
1265        &self,
1266        assignee_id: &str,
1267        container_ids: &[&str],
1268    ) -> request::ReserveContainersRequest {
1269        request::ReserveContainersRequest {
1270            client: &self,
1271            assignee_id: assignee_id.to_owned(),
1272            comment: None,
1273            container_ids: container_ids.iter().map(|&x| x.to_owned()).collect(),
1274        }
1275    }
1276    ///Unarchive containers
1277    pub fn unarchive_containers(
1278        &self,
1279        container_ids: &[&str],
1280    ) -> request::UnarchiveContainersRequest {
1281        request::UnarchiveContainersRequest {
1282            client: &self,
1283            container_ids: container_ids.iter().map(|&x| x.to_owned()).collect(),
1284        }
1285    }
1286    ///List custom entities
1287    pub fn list_custom_entities(&self) -> request::ListCustomEntitiesRequest {
1288        request::ListCustomEntitiesRequest {
1289            client: &self,
1290            next_token: None,
1291            page_size: None,
1292            sort: None,
1293            modified_at: None,
1294            name: None,
1295            returning: None,
1296            name_includes: None,
1297            folder_id: None,
1298            mentioned_in: None,
1299            project_id: None,
1300            registry_id: None,
1301            schema_id: None,
1302            schema_fields: None,
1303            archive_reason: None,
1304            mentions: None,
1305            ids: None,
1306            names_any_of: None,
1307            names_any_of_case_sensitive: None,
1308            entity_registry_ids_any_of: None,
1309            creator_ids: None,
1310            author_ids_any_of: None,
1311        }
1312    }
1313    ///Create a custom entity
1314    pub fn create_custom_entity(
1315        &self,
1316        args: request::CreateCustomEntityRequired,
1317    ) -> request::CreateCustomEntityRequest {
1318        request::CreateCustomEntityRequest {
1319            client: &self,
1320            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
1321            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
1322            custom_fields: args.custom_fields,
1323            fields: args.fields,
1324            folder_id: args.folder_id.to_owned(),
1325            name: args.name.to_owned(),
1326            schema_id: args.schema_id.to_owned(),
1327            entity_registry_id: args.entity_registry_id.to_owned(),
1328            naming_strategy: args.naming_strategy.to_owned(),
1329            registry_id: args.registry_id.to_owned(),
1330        }
1331    }
1332    ///Get a custom entity
1333    pub fn get_custom_entity(
1334        &self,
1335        custom_entity_id: &str,
1336    ) -> request::GetCustomEntityRequest {
1337        request::GetCustomEntityRequest {
1338            client: &self,
1339            custom_entity_id: custom_entity_id.to_owned(),
1340        }
1341    }
1342    ///Update a custom entity
1343    pub fn update_custom_entity(
1344        &self,
1345        args: request::UpdateCustomEntityRequired,
1346    ) -> request::UpdateCustomEntityRequest {
1347        request::UpdateCustomEntityRequest {
1348            client: &self,
1349            custom_entity_id: args.custom_entity_id.to_owned(),
1350            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
1351            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
1352            custom_fields: args.custom_fields,
1353            fields: args.fields,
1354            folder_id: args.folder_id.to_owned(),
1355            name: args.name.to_owned(),
1356            schema_id: args.schema_id.to_owned(),
1357            entity_registry_id: args.entity_registry_id.to_owned(),
1358        }
1359    }
1360    ///Archive custom entities
1361    pub fn archive_custom_entities(
1362        &self,
1363        custom_entity_ids: &[&str],
1364        reason: &str,
1365    ) -> request::ArchiveCustomEntitiesRequest {
1366        request::ArchiveCustomEntitiesRequest {
1367            client: &self,
1368            custom_entity_ids: custom_entity_ids.iter().map(|&x| x.to_owned()).collect(),
1369            reason: reason.to_owned(),
1370        }
1371    }
1372    /**Bulk Create custom entities
1373
1374Bulk Create custom entities. Limit of 2500 custom entities per request.*/
1375    pub fn bulk_create_custom_entities(
1376        &self,
1377        custom_entities: Vec<CustomEntityBulkCreate>,
1378    ) -> request::BulkCreateCustomEntitiesRequest {
1379        request::BulkCreateCustomEntitiesRequest {
1380            client: &self,
1381            custom_entities,
1382        }
1383    }
1384    ///Bulk get custom entities by ID
1385    pub fn bulk_get_custom_entities(
1386        &self,
1387        custom_entity_ids: &str,
1388    ) -> request::BulkGetCustomEntitiesRequest {
1389        request::BulkGetCustomEntitiesRequest {
1390            client: &self,
1391            custom_entity_ids: custom_entity_ids.to_owned(),
1392        }
1393    }
1394    ///Bulk Update custom entities
1395    pub fn bulk_update_custom_entities(
1396        &self,
1397        custom_entities: Vec<CustomEntityBulkUpdate>,
1398    ) -> request::BulkUpdateCustomEntitiesRequest {
1399        request::BulkUpdateCustomEntitiesRequest {
1400            client: &self,
1401            custom_entities,
1402        }
1403    }
1404    ///Unarchive custom entities
1405    pub fn unarchive_custom_entities(
1406        &self,
1407        custom_entity_ids: &[&str],
1408    ) -> request::UnarchiveCustomEntitiesRequest {
1409        request::UnarchiveCustomEntitiesRequest {
1410            client: &self,
1411            custom_entity_ids: custom_entity_ids.iter().map(|&x| x.to_owned()).collect(),
1412        }
1413    }
1414    ///List DNA Alignments
1415    pub fn list_dna_alignments(&self) -> request::ListDnaAlignmentsRequest {
1416        request::ListDnaAlignmentsRequest {
1417            client: &self,
1418            page_size: None,
1419            next_token: None,
1420            sort: None,
1421            modified_at: None,
1422            name: None,
1423            name_includes: None,
1424            ids: None,
1425            names_any_of: None,
1426            names_any_of_case_sensitive: None,
1427            sequence_ids: None,
1428        }
1429    }
1430    ///Get a DNA Alignment
1431    pub fn get_dna_alignment(
1432        &self,
1433        dna_alignment_id: &str,
1434    ) -> request::GetDnaAlignmentRequest {
1435        request::GetDnaAlignmentRequest {
1436            client: &self,
1437            dna_alignment_id: dna_alignment_id.to_owned(),
1438        }
1439    }
1440    ///Delete a DNA Alignment
1441    pub fn delete_dna_alignment(
1442        &self,
1443        dna_alignment_id: &str,
1444    ) -> request::DeleteDnaAlignmentRequest {
1445        request::DeleteDnaAlignmentRequest {
1446            client: &self,
1447            dna_alignment_id: dna_alignment_id.to_owned(),
1448        }
1449    }
1450    ///Create a consensus DNA alignment
1451    pub fn create_dna_consensus_alignment(
1452        &self,
1453        args: request::CreateDnaConsensusAlignmentRequired,
1454    ) -> request::CreateDnaConsensusAlignmentRequest {
1455        request::CreateDnaConsensusAlignmentRequest {
1456            client: &self,
1457            algorithm: args.algorithm.to_owned(),
1458            files: args.files,
1459            name: args.name.to_owned(),
1460            new_sequence: args.new_sequence,
1461            sequence_id: args.sequence_id.to_owned(),
1462        }
1463    }
1464    ///Create a template DNA alignment
1465    pub fn create_dna_template_alignment(
1466        &self,
1467        args: request::CreateDnaTemplateAlignmentRequired,
1468    ) -> request::CreateDnaTemplateAlignmentRequest {
1469        request::CreateDnaTemplateAlignmentRequest {
1470            client: &self,
1471            algorithm: args.algorithm.to_owned(),
1472            files: args.files,
1473            name: args.name.to_owned(),
1474            template_sequence_id: args.template_sequence_id.to_owned(),
1475        }
1476    }
1477    ///List DNA Oligos
1478    pub fn list_dna_oligos(&self) -> request::ListDnaOligosRequest {
1479        request::ListDnaOligosRequest {
1480            client: &self,
1481            page_size: None,
1482            next_token: None,
1483            sort: None,
1484            modified_at: None,
1485            name: None,
1486            name_includes: None,
1487            bases: None,
1488            folder_id: None,
1489            mentioned_in: None,
1490            project_id: None,
1491            registry_id: None,
1492            schema_id: None,
1493            schema_fields: None,
1494            archive_reason: None,
1495            mentions: None,
1496            ids: None,
1497            entity_registry_ids_any_of: None,
1498            names_any_of: None,
1499            names_any_of_case_sensitive: None,
1500            creator_ids: None,
1501            author_ids_any_of: None,
1502        }
1503    }
1504    ///Create a DNA Oligo
1505    pub fn create_dna_oligo(
1506        &self,
1507        args: request::CreateDnaOligoRequired,
1508    ) -> request::CreateDnaOligoRequest {
1509        request::CreateDnaOligoRequest {
1510            client: &self,
1511            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
1512            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
1513            bases: args.bases.to_owned(),
1514            custom_fields: args.custom_fields,
1515            fields: args.fields,
1516            folder_id: args.folder_id.to_owned(),
1517            name: args.name.to_owned(),
1518            schema_id: args.schema_id.to_owned(),
1519            entity_registry_id: args.entity_registry_id.to_owned(),
1520            naming_strategy: args.naming_strategy.to_owned(),
1521            registry_id: args.registry_id.to_owned(),
1522        }
1523    }
1524    ///Get a DNA Oligo
1525    pub fn get_dna_oligo(&self, oligo_id: &str) -> request::GetDnaOligoRequest {
1526        request::GetDnaOligoRequest {
1527            client: &self,
1528            oligo_id: oligo_id.to_owned(),
1529        }
1530    }
1531    ///Update a DNA Oligo
1532    pub fn update_dna_oligo(
1533        &self,
1534        args: request::UpdateDnaOligoRequired,
1535    ) -> request::UpdateDnaOligoRequest {
1536        request::UpdateDnaOligoRequest {
1537            client: &self,
1538            oligo_id: args.oligo_id.to_owned(),
1539            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
1540            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
1541            bases: args.bases.to_owned(),
1542            custom_fields: args.custom_fields,
1543            fields: args.fields,
1544            folder_id: args.folder_id.to_owned(),
1545            name: args.name.to_owned(),
1546            schema_id: args.schema_id.to_owned(),
1547        }
1548    }
1549    ///Archive DNA Oligos
1550    pub fn archive_dna_oligos(
1551        &self,
1552        dna_oligo_ids: &[&str],
1553        reason: &str,
1554    ) -> request::ArchiveDnaOligosRequest {
1555        request::ArchiveDnaOligosRequest {
1556            client: &self,
1557            dna_oligo_ids: dna_oligo_ids.iter().map(|&x| x.to_owned()).collect(),
1558            reason: reason.to_owned(),
1559        }
1560    }
1561    /**Bulk Create DNA Oligos
1562
1563Bulk Create DNA Oligos. Limit of 1000 DNA Oligos per request.*/
1564    pub fn bulk_create_dna_oligos(&self) -> request::BulkCreateDnaOligosRequest {
1565        request::BulkCreateDnaOligosRequest {
1566            client: &self,
1567            dna_oligos: None,
1568        }
1569    }
1570    ///Bulk Update DNA Oligos
1571    pub fn bulk_update_dna_oligos(&self) -> request::BulkUpdateDnaOligosRequest {
1572        request::BulkUpdateDnaOligosRequest {
1573            client: &self,
1574            dna_oligos: None,
1575        }
1576    }
1577    ///Unarchive DNA Oligos
1578    pub fn unarchive_dna_oligos(
1579        &self,
1580        dna_oligo_ids: &[&str],
1581    ) -> request::UnarchiveDnaOligosRequest {
1582        request::UnarchiveDnaOligosRequest {
1583            client: &self,
1584            dna_oligo_ids: dna_oligo_ids.iter().map(|&x| x.to_owned()).collect(),
1585        }
1586    }
1587    ///List DNA sequences
1588    pub fn list_dna_sequences(&self) -> request::ListDnaSequencesRequest {
1589        request::ListDnaSequencesRequest {
1590            client: &self,
1591            page_size: None,
1592            next_token: None,
1593            sort: None,
1594            modified_at: None,
1595            name: None,
1596            name_includes: None,
1597            bases: None,
1598            folder_id: None,
1599            mentioned_in: None,
1600            project_id: None,
1601            registry_id: None,
1602            schema_id: None,
1603            schema_fields: None,
1604            archive_reason: None,
1605            mentions: None,
1606            ids: None,
1607            entity_registry_ids_any_of: None,
1608            names_any_of: None,
1609            names_any_of_case_sensitive: None,
1610            creator_ids: None,
1611            author_ids_any_of: None,
1612        }
1613    }
1614    ///Create a DNA sequence
1615    pub fn create_dna_sequence(
1616        &self,
1617        args: request::CreateDnaSequenceRequired,
1618    ) -> request::CreateDnaSequenceRequest {
1619        request::CreateDnaSequenceRequest {
1620            client: &self,
1621            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
1622            annotations: args.annotations,
1623            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
1624            bases: args.bases.to_owned(),
1625            custom_fields: args.custom_fields,
1626            fields: args.fields,
1627            folder_id: args.folder_id.to_owned(),
1628            is_circular: args.is_circular,
1629            name: args.name.to_owned(),
1630            primers: args.primers,
1631            schema_id: args.schema_id.to_owned(),
1632            translations: args.translations,
1633            entity_registry_id: args.entity_registry_id.to_owned(),
1634            naming_strategy: args.naming_strategy.to_owned(),
1635            registry_id: args.registry_id.to_owned(),
1636        }
1637    }
1638    ///Get a DNA sequence
1639    pub fn get_dna_sequence(
1640        &self,
1641        dna_sequence_id: &str,
1642    ) -> request::GetDnaSequenceRequest {
1643        request::GetDnaSequenceRequest {
1644            client: &self,
1645            dna_sequence_id: dna_sequence_id.to_owned(),
1646        }
1647    }
1648    ///Update a DNA sequence
1649    pub fn update_dna_sequence(
1650        &self,
1651        args: request::UpdateDnaSequenceRequired,
1652    ) -> request::UpdateDnaSequenceRequest {
1653        request::UpdateDnaSequenceRequest {
1654            client: &self,
1655            dna_sequence_id: args.dna_sequence_id.to_owned(),
1656            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
1657            annotations: args.annotations,
1658            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
1659            bases: args.bases.to_owned(),
1660            custom_fields: args.custom_fields,
1661            fields: args.fields,
1662            folder_id: args.folder_id.to_owned(),
1663            is_circular: args.is_circular,
1664            name: args.name.to_owned(),
1665            primers: args.primers,
1666            schema_id: args.schema_id.to_owned(),
1667            translations: args.translations,
1668            entity_registry_id: args.entity_registry_id.to_owned(),
1669        }
1670    }
1671    ///Archive DNA sequences
1672    pub fn archive_dna_sequences(
1673        &self,
1674        dna_sequence_ids: &[&str],
1675        reason: &str,
1676    ) -> request::ArchiveDnaSequencesRequest {
1677        request::ArchiveDnaSequencesRequest {
1678            client: &self,
1679            dna_sequence_ids: dna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
1680            reason: reason.to_owned(),
1681        }
1682    }
1683    ///Auto-annotate DNA sequences with matching features from specified Feature Libraries
1684    pub fn auto_annotate_dna_sequences(
1685        &self,
1686        dna_sequence_ids: &[&str],
1687        feature_library_ids: &[&str],
1688    ) -> request::AutoAnnotateDnaSequencesRequest {
1689        request::AutoAnnotateDnaSequencesRequest {
1690            client: &self,
1691            dna_sequence_ids: dna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
1692            feature_library_ids: feature_library_ids
1693                .iter()
1694                .map(|&x| x.to_owned())
1695                .collect(),
1696        }
1697    }
1698    ///Autofill DNA sequence parts
1699    pub fn autofill_dna_sequence_parts(
1700        &self,
1701        dna_sequence_ids: &[&str],
1702    ) -> request::AutofillDnaSequencePartsRequest {
1703        request::AutofillDnaSequencePartsRequest {
1704            client: &self,
1705            dna_sequence_ids: dna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
1706        }
1707    }
1708    ///Autofill DNA sequence translations
1709    pub fn autofill_dna_sequence_translations(
1710        &self,
1711        dna_sequence_ids: &[&str],
1712    ) -> request::AutofillDnaSequenceTranslationsRequest {
1713        request::AutofillDnaSequenceTranslationsRequest {
1714            client: &self,
1715            dna_sequence_ids: dna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
1716        }
1717    }
1718    /**Bulk Create DNA sequences
1719
1720Bulk Create DNA sequences. Limit of 1000 DNA Sequences per request.*/
1721    pub fn bulk_create_dna_sequences(&self) -> request::BulkCreateDnaSequencesRequest {
1722        request::BulkCreateDnaSequencesRequest {
1723            client: &self,
1724            dna_sequences: None,
1725        }
1726    }
1727    ///Bulk get DNA sequences by ID
1728    pub fn bulk_get_dna_sequences(
1729        &self,
1730        dna_sequence_ids: &str,
1731    ) -> request::BulkGetDnaSequencesRequest {
1732        request::BulkGetDnaSequencesRequest {
1733            client: &self,
1734            dna_sequence_ids: dna_sequence_ids.to_owned(),
1735        }
1736    }
1737    ///Bulk Update DNA sequences
1738    pub fn bulk_update_dna_sequences(&self) -> request::BulkUpdateDnaSequencesRequest {
1739        request::BulkUpdateDnaSequencesRequest {
1740            client: &self,
1741            dna_sequences: None,
1742        }
1743    }
1744    ///Unarchive DNA sequences
1745    pub fn unarchive_dna_sequences(
1746        &self,
1747        dna_sequence_ids: &[&str],
1748    ) -> request::UnarchiveDnaSequencesRequest {
1749        request::UnarchiveDnaSequencesRequest {
1750            client: &self,
1751            dna_sequence_ids: dna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
1752        }
1753    }
1754    ///List dropdowns
1755    pub fn list_dropdowns(&self) -> request::ListDropdownsRequest {
1756        request::ListDropdownsRequest {
1757            client: &self,
1758            next_token: None,
1759            page_size: None,
1760        }
1761    }
1762    ///Create a dropdown
1763    pub fn create_dropdown(
1764        &self,
1765        name: &str,
1766        options: Vec<DropdownOptionCreate>,
1767    ) -> request::CreateDropdownRequest {
1768        request::CreateDropdownRequest {
1769            client: &self,
1770            name: name.to_owned(),
1771            options,
1772            registry_id: None,
1773        }
1774    }
1775    ///Get a dropdown
1776    pub fn get_dropdown(&self, dropdown_id: &str) -> request::GetDropdownRequest {
1777        request::GetDropdownRequest {
1778            client: &self,
1779            dropdown_id: dropdown_id.to_owned(),
1780        }
1781    }
1782    ///Update a dropdown
1783    pub fn update_dropdown(
1784        &self,
1785        dropdown_id: &str,
1786        options: Vec<DropdownOptionUpdate>,
1787    ) -> request::UpdateDropdownRequest {
1788        request::UpdateDropdownRequest {
1789            client: &self,
1790            dropdown_id: dropdown_id.to_owned(),
1791            options,
1792        }
1793    }
1794    /**Archive dropdown options
1795
1796Archive options belonging to a dropdown*/
1797    pub fn archive_dropdown_options(
1798        &self,
1799        dropdown_id: &str,
1800    ) -> request::ArchiveDropdownOptionsRequest {
1801        request::ArchiveDropdownOptionsRequest {
1802            client: &self,
1803            dropdown_id: dropdown_id.to_owned(),
1804            dropdown_option_ids: None,
1805            reason: None,
1806        }
1807    }
1808    /**Unarchive dropdown options
1809
1810Unarchive options belonging to a dropdown*/
1811    pub fn unarchive_dropdown_options(
1812        &self,
1813        dropdown_id: &str,
1814    ) -> request::UnarchiveDropdownOptionsRequest {
1815        request::UnarchiveDropdownOptionsRequest {
1816            client: &self,
1817            dropdown_id: dropdown_id.to_owned(),
1818            dropdown_option_ids: None,
1819        }
1820    }
1821    ///Get an entity's batches
1822    pub fn get_enitity_batches(
1823        &self,
1824        entity_id: &str,
1825    ) -> request::GetEnitityBatchesRequest {
1826        request::GetEnitityBatchesRequest {
1827            client: &self,
1828            entity_id: entity_id.to_owned(),
1829        }
1830    }
1831    ///List entity schemas
1832    pub fn list_entity_schemas(&self) -> request::ListEntitySchemasRequest {
1833        request::ListEntitySchemasRequest {
1834            client: &self,
1835            next_token: None,
1836            page_size: None,
1837            modified_at: None,
1838        }
1839    }
1840    ///Get an entity schema by ID
1841    pub fn get_entity_schema(&self, schema_id: &str) -> request::GetEntitySchemaRequest {
1842        request::GetEntitySchemaRequest {
1843            client: &self,
1844            schema_id: schema_id.to_owned(),
1845        }
1846    }
1847    /**List entries
1848
1849List notebook entries*/
1850    pub fn list_entries(&self) -> request::ListEntriesRequest {
1851        request::ListEntriesRequest {
1852            client: &self,
1853            page_size: None,
1854            next_token: None,
1855            sort: None,
1856            modified_at: None,
1857            name: None,
1858            project_id: None,
1859            archive_reason: None,
1860            review_status: None,
1861            mentioned_in: None,
1862            mentions: None,
1863            ids: None,
1864            schema_id: None,
1865            names_any_of: None,
1866            names_any_of_case_sensitive: None,
1867            assigned_reviewer_ids_any_of: None,
1868            creator_ids: None,
1869            author_ids_any_of: None,
1870            display_ids: None,
1871        }
1872    }
1873    ///Create a notebook entry
1874    pub fn create_entry(
1875        &self,
1876        folder_id: &str,
1877        name: &str,
1878    ) -> request::CreateEntryRequest {
1879        request::CreateEntryRequest {
1880            client: &self,
1881            author_ids: None,
1882            custom_fields: None,
1883            entry_template_id: None,
1884            fields: None,
1885            folder_id: folder_id.to_owned(),
1886            initial_tables: None,
1887            name: name.to_owned(),
1888            schema_id: None,
1889        }
1890    }
1891    ///Get a notebook entry by ID
1892    pub fn get_entry(&self, entry_id: &str) -> request::GetEntryRequest {
1893        request::GetEntryRequest {
1894            client: &self,
1895            entry_id: entry_id.to_owned(),
1896        }
1897    }
1898    ///Update a notebook entry's metadata
1899    pub fn update_entry(&self, entry_id: &str) -> request::UpdateEntryRequest {
1900        request::UpdateEntryRequest {
1901            client: &self,
1902            entry_id: entry_id.to_owned(),
1903            author_ids: None,
1904            fields: None,
1905            folder_id: None,
1906            name: None,
1907            schema_id: None,
1908        }
1909    }
1910    /**Retrieves the metadata for an external file. Use the 'downloadURL' to download the actual file.
1911
1912
1913Retrieves the metadata for an external file. Use the 'downloadURL' to download the actual file. (Expand the schema view for details)
1914*/
1915    pub fn get_external_file_metadata(
1916        &self,
1917        entry_id: &str,
1918        external_file_id: &str,
1919    ) -> request::GetExternalFileMetadataRequest {
1920        request::GetExternalFileMetadataRequest {
1921            client: &self,
1922            entry_id: entry_id.to_owned(),
1923            external_file_id: external_file_id.to_owned(),
1924        }
1925    }
1926    ///Archive notebook entries
1927    pub fn archive_entries(
1928        &self,
1929        entry_ids: &[&str],
1930        reason: &str,
1931    ) -> request::ArchiveEntriesRequest {
1932        request::ArchiveEntriesRequest {
1933            client: &self,
1934            entry_ids: entry_ids.iter().map(|&x| x.to_owned()).collect(),
1935            reason: reason.to_owned(),
1936        }
1937    }
1938    ///Get notebook entries using entry IDs or display IDs
1939    pub fn bulk_get_entries(&self) -> request::BulkGetEntriesRequest {
1940        request::BulkGetEntriesRequest {
1941            client: &self,
1942            entry_ids: None,
1943            display_ids: None,
1944        }
1945    }
1946    ///Unarchive notebook entries
1947    pub fn unarchive_entries(
1948        &self,
1949        entry_ids: &[&str],
1950    ) -> request::UnarchiveEntriesRequest {
1951        request::UnarchiveEntriesRequest {
1952            client: &self,
1953            entry_ids: entry_ids.iter().map(|&x| x.to_owned()).collect(),
1954        }
1955    }
1956    ///List entry schemas
1957    pub fn list_entry_schemas(&self) -> request::ListEntrySchemasRequest {
1958        request::ListEntrySchemasRequest {
1959            client: &self,
1960            next_token: None,
1961            page_size: None,
1962            modified_at: None,
1963        }
1964    }
1965    ///Get an Entry schema by ID
1966    pub fn get_entry_schema(&self, schema_id: &str) -> request::GetEntrySchemaRequest {
1967        request::GetEntrySchemaRequest {
1968            client: &self,
1969            schema_id: schema_id.to_owned(),
1970        }
1971    }
1972    ///List entry templates
1973    pub fn list_entry_templates(&self) -> request::ListEntryTemplatesRequest {
1974        request::ListEntryTemplatesRequest {
1975            client: &self,
1976            page_size: None,
1977            next_token: None,
1978            modified_at: None,
1979            name: None,
1980            template_collection_id: None,
1981            ids: None,
1982            schema_id: None,
1983        }
1984    }
1985    ///Get a notebook template entry by ID
1986    pub fn get_entry_template(
1987        &self,
1988        entry_template_id: &str,
1989    ) -> request::GetEntryTemplateRequest {
1990        request::GetEntryTemplateRequest {
1991            client: &self,
1992            entry_template_id: entry_template_id.to_owned(),
1993        }
1994    }
1995    /**List Events
1996
1997List Events
1998
1999## Event Sort Order
2000
2001Events in Benchling are assigned a stable sort order that reflects when the event was processed (not created). The createdAt time is not the stable sorted order of events. For this reason event createdAt time may appear out of order.
2002*/
2003    pub fn list_events(&self) -> request::ListEventsRequest {
2004        request::ListEventsRequest {
2005            client: &self,
2006            page_size: None,
2007            next_token: None,
2008            created_at_gte: None,
2009            starting_after: None,
2010            event_types: None,
2011            poll: None,
2012        }
2013    }
2014    /**Export Item
2015
2016This endpoint launches a [long-running task](#/Tasks/getTask) and returns the Task ID of the launched task.
2017The task response contains a link to download the exported item from Amazon S3. The download is a ZIP file that contains the exported PDFs.
2018*/
2019    pub fn export_item(&self, id: &str) -> request::ExportItemRequest {
2020        request::ExportItemRequest {
2021            client: &self,
2022            id: id.to_owned(),
2023        }
2024    }
2025    ///List Feature Libraries
2026    pub fn list_feature_libraries(&self) -> request::ListFeatureLibrariesRequest {
2027        request::ListFeatureLibrariesRequest {
2028            client: &self,
2029            page_size: None,
2030            next_token: None,
2031            sort: None,
2032            modified_at: None,
2033            name: None,
2034            name_includes: None,
2035            ids: None,
2036            names_any_of: None,
2037        }
2038    }
2039    ///Create a Feature Library
2040    pub fn create_feature_library(&self) -> request::CreateFeatureLibraryRequest {
2041        request::CreateFeatureLibraryRequest {
2042            client: &self,
2043        }
2044    }
2045    ///Get a feature library by ID
2046    pub fn get_feature_library(
2047        &self,
2048        feature_library_id: &str,
2049    ) -> request::GetFeatureLibraryRequest {
2050        request::GetFeatureLibraryRequest {
2051            client: &self,
2052            feature_library_id: feature_library_id.to_owned(),
2053        }
2054    }
2055    /**Update a feature library
2056
2057Update a feature library. Note: Features cannot be updated from this endpoint.
2058Use the /features* endpoints to add or modify features.
2059*/
2060    pub fn update_feature_library(
2061        &self,
2062        feature_library_id: &str,
2063    ) -> request::UpdateFeatureLibraryRequest {
2064        request::UpdateFeatureLibraryRequest {
2065            client: &self,
2066            feature_library_id: feature_library_id.to_owned(),
2067        }
2068    }
2069    ///List Features
2070    pub fn list_features(&self) -> request::ListFeaturesRequest {
2071        request::ListFeaturesRequest {
2072            client: &self,
2073            page_size: None,
2074            next_token: None,
2075            name: None,
2076            ids: None,
2077            names_any_of_case_sensitive: None,
2078            feature_library_id: None,
2079            feature_type: None,
2080            match_type: None,
2081        }
2082    }
2083    ///Create a Feature
2084    pub fn create_feature(&self) -> request::CreateFeatureRequest {
2085        request::CreateFeatureRequest {
2086            client: &self,
2087        }
2088    }
2089    ///Get a feature by ID
2090    pub fn get_feature(&self, feature_id: &str) -> request::GetFeatureRequest {
2091        request::GetFeatureRequest {
2092            client: &self,
2093            feature_id: feature_id.to_owned(),
2094        }
2095    }
2096    ///Update a feature
2097    pub fn update_feature(&self, feature_id: &str) -> request::UpdateFeatureRequest {
2098        request::UpdateFeatureRequest {
2099            client: &self,
2100            feature_id: feature_id.to_owned(),
2101        }
2102    }
2103    ///Bulk create Features
2104    pub fn bulk_create_features(&self) -> request::BulkCreateFeaturesRequest {
2105        request::BulkCreateFeaturesRequest {
2106            client: &self,
2107            features: None,
2108        }
2109    }
2110    ///List folders
2111    pub fn list_folders(&self) -> request::ListFoldersRequest {
2112        request::ListFoldersRequest {
2113            client: &self,
2114            next_token: None,
2115            page_size: None,
2116            sort: None,
2117            archive_reason: None,
2118            name_includes: None,
2119            parent_folder_id: None,
2120            project_id: None,
2121            ids: None,
2122            name: None,
2123            section: None,
2124        }
2125    }
2126    ///Create folder
2127    pub fn create_folder(
2128        &self,
2129        name: &str,
2130        parent_folder_id: &str,
2131    ) -> request::CreateFolderRequest {
2132        request::CreateFolderRequest {
2133            client: &self,
2134            name: name.to_owned(),
2135            parent_folder_id: parent_folder_id.to_owned(),
2136        }
2137    }
2138    ///Get a folder by ID
2139    pub fn get_folder(&self, folder_id: &str) -> request::GetFolderRequest {
2140        request::GetFolderRequest {
2141            client: &self,
2142            folder_id: folder_id.to_owned(),
2143        }
2144    }
2145    /**Archive folders
2146
2147Archives folders and their contents*/
2148    pub fn archive_folders(
2149        &self,
2150        folder_ids: &[&str],
2151        reason: &str,
2152    ) -> request::ArchiveFoldersRequest {
2153        request::ArchiveFoldersRequest {
2154            client: &self,
2155            folder_ids: folder_ids.iter().map(|&x| x.to_owned()).collect(),
2156            reason: reason.to_owned(),
2157        }
2158    }
2159    /**Unarchive folders
2160
2161Unarchives folders and the contents that were archived along with them*/
2162    pub fn unarchive_folders(
2163        &self,
2164        folder_ids: &[&str],
2165    ) -> request::UnarchiveFoldersRequest {
2166        request::UnarchiveFoldersRequest {
2167            client: &self,
2168            folder_ids: folder_ids.iter().map(|&x| x.to_owned()).collect(),
2169        }
2170    }
2171    ///List legacy workflow stage run input samples
2172    pub fn list_legacy_workflow_stage_run_input_samples(
2173        &self,
2174        stage_run_id: &str,
2175    ) -> request::ListLegacyWorkflowStageRunInputSamplesRequest {
2176        request::ListLegacyWorkflowStageRunInputSamplesRequest {
2177            client: &self,
2178            stage_run_id: stage_run_id.to_owned(),
2179        }
2180    }
2181    ///List legacy workflow stage run output samples
2182    pub fn list_legacy_workflow_stage_run_output_samples(
2183        &self,
2184        stage_run_id: &str,
2185    ) -> request::ListLegacyWorkflowStageRunOutputSamplesRequest {
2186        request::ListLegacyWorkflowStageRunOutputSamplesRequest {
2187            client: &self,
2188            stage_run_id: stage_run_id.to_owned(),
2189        }
2190    }
2191    ///List legacy workflow stage run registered samples
2192    pub fn list_legacy_workflow_stage_run_registered_samples(
2193        &self,
2194        stage_run_id: &str,
2195    ) -> request::ListLegacyWorkflowStageRunRegisteredSamplesRequest {
2196        request::ListLegacyWorkflowStageRunRegisteredSamplesRequest {
2197            client: &self,
2198            stage_run_id: stage_run_id.to_owned(),
2199        }
2200    }
2201    ///List legacy workflow stage runs
2202    pub fn list_legacy_workflow_stage_runs(
2203        &self,
2204        stage_id: &str,
2205    ) -> request::ListLegacyWorkflowStageRunsRequest {
2206        request::ListLegacyWorkflowStageRunsRequest {
2207            client: &self,
2208            stage_id: stage_id.to_owned(),
2209        }
2210    }
2211    ///List legacy workflows
2212    pub fn list_legacy_workflows(&self) -> request::ListLegacyWorkflowsRequest {
2213        request::ListLegacyWorkflowsRequest {
2214            client: &self,
2215        }
2216    }
2217    /**Update legacy workflow
2218
2219Update workflow metadata*/
2220    pub fn update_legacy_workflow_metadata(
2221        &self,
2222        legacy_workflow_id: &str,
2223    ) -> request::UpdateLegacyWorkflowMetadataRequest {
2224        request::UpdateLegacyWorkflowMetadataRequest {
2225            client: &self,
2226            legacy_workflow_id: legacy_workflow_id.to_owned(),
2227            description: None,
2228            name: None,
2229            project_id: None,
2230        }
2231    }
2232    ///List legacy workflow stages
2233    pub fn list_legacy_workflow_stages(
2234        &self,
2235        legacy_workflow_id: &str,
2236    ) -> request::ListLegacyWorkflowStagesRequest {
2237        request::ListLegacyWorkflowStagesRequest {
2238            client: &self,
2239            legacy_workflow_id: legacy_workflow_id.to_owned(),
2240        }
2241    }
2242    ///List location schemas
2243    pub fn list_location_schemas(&self) -> request::ListLocationSchemasRequest {
2244        request::ListLocationSchemasRequest {
2245            client: &self,
2246            next_token: None,
2247            page_size: None,
2248        }
2249    }
2250    ///Get a location schema by ID
2251    pub fn get_location_schema(
2252        &self,
2253        schema_id: &str,
2254    ) -> request::GetLocationSchemaRequest {
2255        request::GetLocationSchemaRequest {
2256            client: &self,
2257            schema_id: schema_id.to_owned(),
2258        }
2259    }
2260    ///List locations
2261    pub fn list_locations(&self) -> request::ListLocationsRequest {
2262        request::ListLocationsRequest {
2263            client: &self,
2264            page_size: None,
2265            next_token: None,
2266            sort: None,
2267            schema_id: None,
2268            schema_fields: None,
2269            modified_at: None,
2270            name: None,
2271            name_includes: None,
2272            ancestor_storage_id: None,
2273            archive_reason: None,
2274            ids: None,
2275            barcodes: None,
2276            names_any_of: None,
2277            names_any_of_case_sensitive: None,
2278            creator_ids: None,
2279        }
2280    }
2281    ///Create a location
2282    pub fn create_location(
2283        &self,
2284        name: &str,
2285        schema_id: &str,
2286    ) -> request::CreateLocationRequest {
2287        request::CreateLocationRequest {
2288            client: &self,
2289            barcode: None,
2290            fields: None,
2291            name: name.to_owned(),
2292            parent_storage_id: None,
2293            schema_id: schema_id.to_owned(),
2294        }
2295    }
2296    ///Get a location by ID
2297    pub fn get_location(&self, location_id: &str) -> request::GetLocationRequest {
2298        request::GetLocationRequest {
2299            client: &self,
2300            location_id: location_id.to_owned(),
2301        }
2302    }
2303    ///Update a location
2304    pub fn update_location(&self, location_id: &str) -> request::UpdateLocationRequest {
2305        request::UpdateLocationRequest {
2306            client: &self,
2307            location_id: location_id.to_owned(),
2308            fields: None,
2309            name: None,
2310            parent_storage_id: None,
2311        }
2312    }
2313    ///Archive locations
2314    pub fn archive_locations(
2315        &self,
2316        location_ids: &[&str],
2317        reason: &str,
2318    ) -> request::ArchiveLocationsRequest {
2319        request::ArchiveLocationsRequest {
2320            client: &self,
2321            location_ids: location_ids.iter().map(|&x| x.to_owned()).collect(),
2322            reason: reason.to_owned(),
2323            should_remove_barcodes: None,
2324        }
2325    }
2326    ///BulkGet locations
2327    pub fn bulk_get_locations(&self) -> request::BulkGetLocationsRequest {
2328        request::BulkGetLocationsRequest {
2329            client: &self,
2330            location_ids: None,
2331            barcodes: None,
2332        }
2333    }
2334    ///Unarchive locations
2335    pub fn unarchive_locations(
2336        &self,
2337        location_ids: &[&str],
2338    ) -> request::UnarchiveLocationsRequest {
2339        request::UnarchiveLocationsRequest {
2340            client: &self,
2341            location_ids: location_ids.iter().map(|&x| x.to_owned()).collect(),
2342        }
2343    }
2344    ///List mixtures
2345    pub fn list_mixtures(&self) -> request::ListMixturesRequest {
2346        request::ListMixturesRequest {
2347            client: &self,
2348            next_token: None,
2349            page_size: None,
2350            sort: None,
2351            modified_at: None,
2352            name: None,
2353            name_includes: None,
2354            folder_id: None,
2355            mentioned_in: None,
2356            project_id: None,
2357            registry_id: None,
2358            schema_id: None,
2359            schema_fields: None,
2360            archive_reason: None,
2361            mentions: None,
2362            ids: None,
2363            names_any_of: None,
2364            names_any_of_case_sensitive: None,
2365            entity_registry_ids_any_of: None,
2366            ingredient_component_entity_ids: None,
2367            ingredient_component_entity_ids_any_of: None,
2368            author_ids_any_of: None,
2369        }
2370    }
2371    /**Create a mixture
2372
2373Create a mixture.
2374To create a new child mixture (eg. a prep) from a parent mixture (eg. a recipe), set the parent mixture field and specify the desired final state for your ingredients.
2375Benchling will recognize that any ingredients you specify that match ingredients on the parent mixture (based on component entity) are inherited. This can be seen on the returned `ingredients[i].hasParent` attribute.
2376*/
2377    pub fn create_mixture(
2378        &self,
2379        args: request::CreateMixtureRequired,
2380    ) -> request::CreateMixtureRequest {
2381        request::CreateMixtureRequest {
2382            client: &self,
2383            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
2384            amount: args.amount.to_owned(),
2385            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
2386            custom_fields: args.custom_fields,
2387            entity_registry_id: args.entity_registry_id.to_owned(),
2388            fields: args.fields,
2389            folder_id: args.folder_id.to_owned(),
2390            ingredients: args.ingredients,
2391            name: args.name.to_owned(),
2392            schema_id: args.schema_id.to_owned(),
2393            units: None,
2394            naming_strategy: args.naming_strategy.to_owned(),
2395            registry_id: args.registry_id.to_owned(),
2396        }
2397    }
2398    ///Get a mixture
2399    pub fn get_mixture(&self, mixture_id: &str) -> request::GetMixtureRequest {
2400        request::GetMixtureRequest {
2401            client: &self,
2402            mixture_id: mixture_id.to_owned(),
2403        }
2404    }
2405    /**Update a mixture
2406
2407Update a mixture.
2408To change the parent mixture, set the parent mixture field and specify the desired final state for your ingredients.
2409Benchling will recognize that any ingredients you specify that match ingredients on the parent mixture (based on component entity) are inherited. This can be seen on the returned `ingredients[i].hasParent` attribute.
2410*/
2411    pub fn update_mixture(&self, mixture_id: &str) -> request::UpdateMixtureRequest {
2412        request::UpdateMixtureRequest {
2413            client: &self,
2414            mixture_id: mixture_id.to_owned(),
2415            aliases: None,
2416            amount: None,
2417            author_ids: None,
2418            custom_fields: None,
2419            entity_registry_id: None,
2420            fields: None,
2421            folder_id: None,
2422            ingredients: None,
2423            name: None,
2424            schema_id: None,
2425            units: None,
2426        }
2427    }
2428    ///Archive mixtures
2429    pub fn archive_mixtures(
2430        &self,
2431        mixture_ids: &[&str],
2432        reason: &str,
2433    ) -> request::ArchiveMixturesRequest {
2434        request::ArchiveMixturesRequest {
2435            client: &self,
2436            mixture_ids: mixture_ids.iter().map(|&x| x.to_owned()).collect(),
2437            reason: reason.to_owned(),
2438        }
2439    }
2440    /**Bulk Create mixtures
2441
2442Create multiple mixtures. Limit of 1000 mixtures per request.
2443To create new child mixtures (eg. a prep) from parent mixtures (eg. a recipe), set the parent mixture field and specify the desired final state for your ingredients.
2444Benchling will recognize that any ingredients you specify that match ingredients on the parent mixtures (based on component entity) are inherited. This can be seen on the returned `ingredients[i].hasParent` attribute.
2445*/
2446    pub fn bulk_create_mixtures(
2447        &self,
2448        mixtures: Vec<MixtureCreate>,
2449    ) -> request::BulkCreateMixturesRequest {
2450        request::BulkCreateMixturesRequest {
2451            client: &self,
2452            mixtures,
2453        }
2454    }
2455    /**Bulk Update mixtures
2456
2457Update multiple mixtures.
2458To change the parent mixture on your specified mixtures, set the parent mixture field and specify the desired final state for your ingredients.
2459Benchling will recognize that any ingredients you specify that match ingredients on the parent mixtures (based on component entity) are inherited. This can be seen on the returned `ingredients[i].hasParent` attribute.
2460*/
2461    pub fn bulk_update_mixtures(&self) -> request::BulkUpdateMixturesRequest {
2462        request::BulkUpdateMixturesRequest {
2463            client: &self,
2464            mixtures: None,
2465        }
2466    }
2467    ///Unarchive mixtures
2468    pub fn unarchive_mixtures(
2469        &self,
2470        mixture_ids: &[&str],
2471    ) -> request::UnarchiveMixturesRequest {
2472        request::UnarchiveMixturesRequest {
2473            client: &self,
2474            mixture_ids: mixture_ids.iter().map(|&x| x.to_owned()).collect(),
2475        }
2476    }
2477    /**List Molecules
2478
2479List molecules*/
2480    pub fn list_molecules(&self) -> request::ListMoleculesRequest {
2481        request::ListMoleculesRequest {
2482            client: &self,
2483            page_size: None,
2484            next_token: None,
2485            sort: None,
2486            modified_at: None,
2487            name: None,
2488            name_includes: None,
2489            folder_id: None,
2490            mentioned_in: None,
2491            project_id: None,
2492            registry_id: None,
2493            schema_id: None,
2494            schema_fields: None,
2495            archive_reason: None,
2496            mentions: None,
2497            ids: None,
2498            entity_registry_ids_any_of: None,
2499            names_any_of: None,
2500            author_ids_any_of: None,
2501            chemical_substructure_mol: None,
2502            chemical_substructure_smiles: None,
2503        }
2504    }
2505    ///Create a Molecule
2506    pub fn create_molecule(
2507        &self,
2508        args: request::CreateMoleculeRequired,
2509    ) -> request::CreateMoleculeRequest {
2510        request::CreateMoleculeRequest {
2511            client: &self,
2512            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
2513            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
2514            chemical_structure: args.chemical_structure,
2515            custom_fields: args.custom_fields,
2516            fields: args.fields,
2517            folder_id: args.folder_id.to_owned(),
2518            name: args.name.to_owned(),
2519            schema_id: args.schema_id.to_owned(),
2520            entity_registry_id: args.entity_registry_id.to_owned(),
2521            naming_strategy: args.naming_strategy.to_owned(),
2522            registry_id: args.registry_id.to_owned(),
2523        }
2524    }
2525    ///Get a Molecule
2526    pub fn get_molecule(&self, molecule_id: &str) -> request::GetMoleculeRequest {
2527        request::GetMoleculeRequest {
2528            client: &self,
2529            molecule_id: molecule_id.to_owned(),
2530        }
2531    }
2532    ///Update a Molecule
2533    pub fn update_molecule(
2534        &self,
2535        args: request::UpdateMoleculeRequired,
2536    ) -> request::UpdateMoleculeRequest {
2537        request::UpdateMoleculeRequest {
2538            client: &self,
2539            molecule_id: args.molecule_id.to_owned(),
2540            entity_registry_id: args.entity_registry_id.to_owned(),
2541            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
2542            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
2543            chemical_structure: args.chemical_structure,
2544            custom_fields: args.custom_fields,
2545            fields: args.fields,
2546            folder_id: args.folder_id.to_owned(),
2547            name: args.name.to_owned(),
2548            schema_id: args.schema_id.to_owned(),
2549        }
2550    }
2551    ///Archive Molecules
2552    pub fn archive_molecules(
2553        &self,
2554        molecule_ids: &[&str],
2555        reason: &str,
2556    ) -> request::ArchiveMoleculesRequest {
2557        request::ArchiveMoleculesRequest {
2558            client: &self,
2559            molecule_ids: molecule_ids.iter().map(|&x| x.to_owned()).collect(),
2560            reason: reason.to_owned(),
2561        }
2562    }
2563    ///Bulk Create Molecules
2564    pub fn bulk_create_molecules(&self) -> request::BulkCreateMoleculesRequest {
2565        request::BulkCreateMoleculesRequest {
2566            client: &self,
2567            molecules: None,
2568        }
2569    }
2570    ///Bulk Update Molecules
2571    pub fn bulk_update_molecules(&self) -> request::BulkUpdateMoleculesRequest {
2572        request::BulkUpdateMoleculesRequest {
2573            client: &self,
2574            molecules: None,
2575        }
2576    }
2577    ///Unarchive Molecules
2578    pub fn unarchive_molecules(
2579        &self,
2580        molecule_ids: &[&str],
2581    ) -> request::UnarchiveMoleculesRequest {
2582        request::UnarchiveMoleculesRequest {
2583            client: &self,
2584            molecule_ids: molecule_ids.iter().map(|&x| x.to_owned()).collect(),
2585        }
2586    }
2587    ///List Nucleotide Alignments
2588    pub fn list_nucleotide_alignments(
2589        &self,
2590    ) -> request::ListNucleotideAlignmentsRequest {
2591        request::ListNucleotideAlignmentsRequest {
2592            client: &self,
2593            page_size: None,
2594            next_token: None,
2595            sort: None,
2596            modified_at: None,
2597            name: None,
2598            name_includes: None,
2599            ids: None,
2600            names_any_of: None,
2601            names_any_of_case_sensitive: None,
2602            sequence_ids: None,
2603        }
2604    }
2605    ///Get a Nucleotide Alignment
2606    pub fn get_nucleotide_alignment(
2607        &self,
2608        alignment_id: &str,
2609    ) -> request::GetNucleotideAlignmentRequest {
2610        request::GetNucleotideAlignmentRequest {
2611            client: &self,
2612            alignment_id: alignment_id.to_owned(),
2613        }
2614    }
2615    ///Delete a Nucleotide Alignment
2616    pub fn delete_nucleotide_alignment(
2617        &self,
2618        alignment_id: &str,
2619    ) -> request::DeleteNucleotideAlignmentRequest {
2620        request::DeleteNucleotideAlignmentRequest {
2621            client: &self,
2622            alignment_id: alignment_id.to_owned(),
2623        }
2624    }
2625    ///Create a consensus Nucleotide Alignment
2626    pub fn create_consensus_nucleotide_alignment(
2627        &self,
2628        args: request::CreateConsensusNucleotideAlignmentRequired,
2629    ) -> request::CreateConsensusNucleotideAlignmentRequest {
2630        request::CreateConsensusNucleotideAlignmentRequest {
2631            client: &self,
2632            algorithm: args.algorithm.to_owned(),
2633            files: args.files,
2634            name: args.name.to_owned(),
2635            new_sequence: args.new_sequence,
2636            sequence_id: args.sequence_id.to_owned(),
2637        }
2638    }
2639    ///Create a template Nucleotide Alignment
2640    pub fn create_template_nucleotide_alignment(
2641        &self,
2642        args: request::CreateTemplateNucleotideAlignmentRequired,
2643    ) -> request::CreateTemplateNucleotideAlignmentRequest {
2644        request::CreateTemplateNucleotideAlignmentRequest {
2645            client: &self,
2646            algorithm: args.algorithm.to_owned(),
2647            files: args.files,
2648            name: args.name.to_owned(),
2649            template_sequence_id: args.template_sequence_id.to_owned(),
2650        }
2651    }
2652    ///List Oligos
2653    pub fn list_oligos(&self) -> request::ListOligosRequest {
2654        request::ListOligosRequest {
2655            client: &self,
2656            page_size: None,
2657            next_token: None,
2658            sort: None,
2659            modified_at: None,
2660            name: None,
2661            bases: None,
2662            folder_id: None,
2663            mentioned_in: None,
2664            project_id: None,
2665            registry_id: None,
2666            schema_id: None,
2667            schema_fields: None,
2668            archive_reason: None,
2669            mentions: None,
2670            ids: None,
2671            entity_registry_ids_any_of: None,
2672            names_any_of: None,
2673            names_any_of_case_sensitive: None,
2674            creator_ids: None,
2675        }
2676    }
2677    ///Create an Oligo
2678    pub fn create_oligo(
2679        &self,
2680        args: request::CreateOligoRequired,
2681    ) -> request::CreateOligoRequest {
2682        request::CreateOligoRequest {
2683            client: &self,
2684            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
2685            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
2686            bases: args.bases.to_owned(),
2687            custom_fields: args.custom_fields,
2688            fields: args.fields,
2689            folder_id: args.folder_id.to_owned(),
2690            name: args.name.to_owned(),
2691            schema_id: args.schema_id.to_owned(),
2692            entity_registry_id: args.entity_registry_id.to_owned(),
2693            naming_strategy: args.naming_strategy.to_owned(),
2694            registry_id: args.registry_id.to_owned(),
2695        }
2696    }
2697    ///Get an Oligo
2698    pub fn get_oligo(&self, oligo_id: &str) -> request::GetOligoRequest {
2699        request::GetOligoRequest {
2700            client: &self,
2701            oligo_id: oligo_id.to_owned(),
2702        }
2703    }
2704    ///Update an Oligo
2705    pub fn update_oligo(
2706        &self,
2707        args: request::UpdateOligoRequired,
2708    ) -> request::UpdateOligoRequest {
2709        request::UpdateOligoRequest {
2710            client: &self,
2711            oligo_id: args.oligo_id.to_owned(),
2712            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
2713            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
2714            bases: args.bases.to_owned(),
2715            custom_fields: args.custom_fields,
2716            fields: args.fields,
2717            folder_id: args.folder_id.to_owned(),
2718            name: args.name.to_owned(),
2719            schema_id: args.schema_id.to_owned(),
2720        }
2721    }
2722    ///Archive Oligos
2723    pub fn archive_oligos(
2724        &self,
2725        oligo_ids: &[&str],
2726        reason: &str,
2727    ) -> request::ArchiveOligosRequest {
2728        request::ArchiveOligosRequest {
2729            client: &self,
2730            oligo_ids: oligo_ids.iter().map(|&x| x.to_owned()).collect(),
2731            reason: reason.to_owned(),
2732        }
2733    }
2734    /**Bulk Create DNA Oligos
2735
2736Bulk Create DNA Oligos
2737Please migrate to [Bulk Create DNA Oligos](#/DNA%20Oligos/bulkCreateDNAOligos) so that we can support RNA Oligos.
2738*/
2739    pub fn bulk_create_oligos(&self) -> request::BulkCreateOligosRequest {
2740        request::BulkCreateOligosRequest {
2741            client: &self,
2742            oligos: None,
2743        }
2744    }
2745    ///Bulk get Oligos by ID
2746    pub fn bulk_get_oligos(&self, oligo_ids: &str) -> request::BulkGetOligosRequest {
2747        request::BulkGetOligosRequest {
2748            client: &self,
2749            oligo_ids: oligo_ids.to_owned(),
2750        }
2751    }
2752    ///Unarchive Oligos
2753    pub fn unarchive_oligos(
2754        &self,
2755        oligo_ids: &[&str],
2756    ) -> request::UnarchiveOligosRequest {
2757        request::UnarchiveOligosRequest {
2758            client: &self,
2759            oligo_ids: oligo_ids.iter().map(|&x| x.to_owned()).collect(),
2760        }
2761    }
2762    /**List organizations
2763
2764Returns all organizations that the caller has permission to view. The following roles have view permission:
2765  - tenant admins
2766  - members of the organization
2767*/
2768    pub fn list_organizations(&self) -> request::ListOrganizationsRequest {
2769        request::ListOrganizationsRequest {
2770            client: &self,
2771            ids: None,
2772            name: None,
2773            name_includes: None,
2774            names_any_of: None,
2775            names_any_of_case_sensitive: None,
2776            modified_at: None,
2777            has_members: None,
2778            has_admins: None,
2779            page_size: None,
2780            next_token: None,
2781            sort: None,
2782        }
2783    }
2784    /**Get an organization by ID
2785
2786Returns an organization by ID if the caller has permission to view. The following roles have view permission:
2787  - tenant admins
2788  - members of the organization
2789*/
2790    pub fn get_organization(
2791        &self,
2792        organization_id: &str,
2793    ) -> request::GetOrganizationRequest {
2794        request::GetOrganizationRequest {
2795            client: &self,
2796            organization_id: organization_id.to_owned(),
2797        }
2798    }
2799    ///List plate schemas
2800    pub fn list_plate_schemas(&self) -> request::ListPlateSchemasRequest {
2801        request::ListPlateSchemasRequest {
2802            client: &self,
2803            next_token: None,
2804            page_size: None,
2805        }
2806    }
2807    ///Get a plate schema by ID
2808    pub fn get_plate_schema(&self, schema_id: &str) -> request::GetPlateSchemaRequest {
2809        request::GetPlateSchemaRequest {
2810            client: &self,
2811            schema_id: schema_id.to_owned(),
2812        }
2813    }
2814    ///List plates
2815    pub fn list_plates(&self) -> request::ListPlatesRequest {
2816        request::ListPlatesRequest {
2817            client: &self,
2818            page_size: None,
2819            next_token: None,
2820            sort: None,
2821            schema_id: None,
2822            schema_fields: None,
2823            modified_at: None,
2824            name: None,
2825            name_includes: None,
2826            ancestor_storage_id: None,
2827            storage_contents_id: None,
2828            storage_contents_ids: None,
2829            archive_reason: None,
2830            ids: None,
2831            barcodes: None,
2832            names_any_of: None,
2833            names_any_of_case_sensitive: None,
2834            returning: None,
2835            creator_ids: None,
2836        }
2837    }
2838    ///Create a plate
2839    pub fn create_plate(&self, schema_id: &str) -> request::CreatePlateRequest {
2840        request::CreatePlateRequest {
2841            client: &self,
2842            returning: None,
2843            barcode: None,
2844            container_schema_id: None,
2845            fields: None,
2846            name: None,
2847            parent_storage_id: None,
2848            project_id: None,
2849            schema_id: schema_id.to_owned(),
2850            wells: None,
2851        }
2852    }
2853    ///Get a plate
2854    pub fn get_plate(&self, plate_id: &str) -> request::GetPlateRequest {
2855        request::GetPlateRequest {
2856            client: &self,
2857            plate_id: plate_id.to_owned(),
2858            returning: None,
2859        }
2860    }
2861    ///Update a plate
2862    pub fn update_plate(&self, plate_id: &str) -> request::UpdatePlateRequest {
2863        request::UpdatePlateRequest {
2864            client: &self,
2865            plate_id: plate_id.to_owned(),
2866            returning: None,
2867            fields: None,
2868            name: None,
2869            parent_storage_id: None,
2870            project_id: None,
2871        }
2872    }
2873    /**Archive plates
2874
2875Archive plates and any containers of the plates*/
2876    pub fn archive_plates(
2877        &self,
2878        plate_ids: &[&str],
2879        reason: &str,
2880        should_remove_barcodes: bool,
2881    ) -> request::ArchivePlatesRequest {
2882        request::ArchivePlatesRequest {
2883            client: &self,
2884            plate_ids: plate_ids.iter().map(|&x| x.to_owned()).collect(),
2885            reason: reason.to_owned(),
2886            should_remove_barcodes,
2887        }
2888    }
2889    ///BulkGet plates
2890    pub fn bulk_get_plates(&self) -> request::BulkGetPlatesRequest {
2891        request::BulkGetPlatesRequest {
2892            client: &self,
2893            plate_ids: None,
2894            barcodes: None,
2895            returning: None,
2896        }
2897    }
2898    /**Unarchive plates
2899
2900Unarchive plates and the containers that were archived along with them*/
2901    pub fn unarchive_plates(
2902        &self,
2903        plate_ids: &[&str],
2904    ) -> request::UnarchivePlatesRequest {
2905        request::UnarchivePlatesRequest {
2906            client: &self,
2907            plate_ids: plate_ids.iter().map(|&x| x.to_owned()).collect(),
2908        }
2909    }
2910    ///List projects
2911    pub fn list_projects(&self) -> request::ListProjectsRequest {
2912        request::ListProjectsRequest {
2913            client: &self,
2914            next_token: None,
2915            page_size: None,
2916            sort: None,
2917            archive_reason: None,
2918            ids: None,
2919            name: None,
2920        }
2921    }
2922    ///Get a project by ID
2923    pub fn get_project(&self, project_id: &str) -> request::GetProjectRequest {
2924        request::GetProjectRequest {
2925            client: &self,
2926            project_id: project_id.to_owned(),
2927        }
2928    }
2929    /**Archive projects
2930
2931Archives projects and their contents*/
2932    pub fn archive_projects(
2933        &self,
2934        project_ids: &[&str],
2935        reason: &str,
2936    ) -> request::ArchiveProjectsRequest {
2937        request::ArchiveProjectsRequest {
2938            client: &self,
2939            project_ids: project_ids.iter().map(|&x| x.to_owned()).collect(),
2940            reason: reason.to_owned(),
2941        }
2942    }
2943    /**Unarchive projects
2944
2945Unarchives projects and the contents that were archived along with them*/
2946    pub fn unarchive_projects(
2947        &self,
2948        project_ids: &[&str],
2949    ) -> request::UnarchiveProjectsRequest {
2950        request::UnarchiveProjectsRequest {
2951            client: &self,
2952            project_ids: project_ids.iter().map(|&x| x.to_owned()).collect(),
2953        }
2954    }
2955    ///List registries
2956    pub fn list_registries(&self) -> request::ListRegistriesRequest {
2957        request::ListRegistriesRequest {
2958            client: &self,
2959            name: None,
2960            modified_at: None,
2961        }
2962    }
2963    ///Get registry
2964    pub fn get_registry(&self, registry_id: &str) -> request::GetRegistryRequest {
2965        request::GetRegistryRequest {
2966            client: &self,
2967            registry_id: registry_id.to_owned(),
2968        }
2969    }
2970    /**List batch schemas by registry
2971
2972List batch schemas by registry. Deprecated - use Schemas endpoints instead.*/
2973    pub fn list_batch_schemas_by_registry(
2974        &self,
2975        registry_id: &str,
2976    ) -> request::ListBatchSchemasByRegistryRequest {
2977        request::ListBatchSchemasByRegistryRequest {
2978            client: &self,
2979            registry_id: registry_id.to_owned(),
2980        }
2981    }
2982    /**List box schemas by registry
2983
2984List box schemas by registry. Deprecated - use Schemas endpoints instead.*/
2985    pub fn list_box_schemas_by_registry(
2986        &self,
2987        registry_id: &str,
2988    ) -> request::ListBoxSchemasByRegistryRequest {
2989        request::ListBoxSchemasByRegistryRequest {
2990            client: &self,
2991            registry_id: registry_id.to_owned(),
2992        }
2993    }
2994    /**List container schemas by registry
2995
2996List container schemas by registry. Deprecated - use Schemas endpoints instead.*/
2997    pub fn list_container_schemas_by_registry(
2998        &self,
2999        registry_id: &str,
3000    ) -> request::ListContainerSchemasByRegistryRequest {
3001        request::ListContainerSchemasByRegistryRequest {
3002            client: &self,
3003            registry_id: registry_id.to_owned(),
3004        }
3005    }
3006    /**List dropdowns for a given registry
3007
3008List dropdowns by registry*/
3009    pub fn list_dropdowns_by_registry(
3010        &self,
3011        registry_id: &str,
3012    ) -> request::ListDropdownsByRegistryRequest {
3013        request::ListDropdownsByRegistryRequest {
3014            client: &self,
3015            registry_id: registry_id.to_owned(),
3016        }
3017    }
3018    /**List entity schemas by registry
3019
3020List entity schemas by registry. Deprecated - use Schemas endpoints instead.*/
3021    pub fn list_entity_schemas_by_registry(
3022        &self,
3023        registry_id: &str,
3024    ) -> request::ListEntitySchemasByRegistryRequest {
3025        request::ListEntitySchemasByRegistryRequest {
3026            client: &self,
3027            registry_id: registry_id.to_owned(),
3028        }
3029    }
3030    ///List printers
3031    pub fn list_printers(&self, registry_id: &str) -> request::ListPrintersRequest {
3032        request::ListPrintersRequest {
3033            client: &self,
3034            registry_id: registry_id.to_owned(),
3035            name: None,
3036        }
3037    }
3038    ///List label templates
3039    pub fn list_label_templates(
3040        &self,
3041        registry_id: &str,
3042    ) -> request::ListLabelTemplatesRequest {
3043        request::ListLabelTemplatesRequest {
3044            client: &self,
3045            registry_id: registry_id.to_owned(),
3046            name: None,
3047        }
3048    }
3049    /**List location schemas by registry
3050
3051List location schemas by registry. Deprecated - use Schemas endpoints instead.*/
3052    pub fn list_location_schemas_by_registry(
3053        &self,
3054        registry_id: &str,
3055    ) -> request::ListLocationSchemasByRegistryRequest {
3056        request::ListLocationSchemasByRegistryRequest {
3057            client: &self,
3058            registry_id: registry_id.to_owned(),
3059        }
3060    }
3061    /**List plate schemas by registry
3062
3063List plate schemas by registry. Deprecated - use Schemas endpoints instead.*/
3064    pub fn list_plate_schemas_by_registry(
3065        &self,
3066        registry_id: &str,
3067    ) -> request::ListPlateSchemasByRegistryRequest {
3068        request::ListPlateSchemasByRegistryRequest {
3069            client: &self,
3070            registry_id: registry_id.to_owned(),
3071        }
3072    }
3073    ///Bulk get registered entities
3074    pub fn bulk_get_registered_entities(
3075        &self,
3076        registry_id: &str,
3077        entity_registry_ids: &str,
3078    ) -> request::BulkGetRegisteredEntitiesRequest {
3079        request::BulkGetRegisteredEntitiesRequest {
3080            client: &self,
3081            registry_id: registry_id.to_owned(),
3082            entity_registry_ids: entity_registry_ids.to_owned(),
3083        }
3084    }
3085    /**Register entities
3086
3087Attempts to move entities into the registry. Limit of 2500 entities per request. This endpoint will first check that the entities are all valid to be moved into the registry, given the namingStrategy. If any entities fail validation, no files will be moved and errors describing invalid entities is returned. If all entities pass validation, the entities are moved into the registry.
3088*/
3089    pub fn register_entities(
3090        &self,
3091        registry_id: &str,
3092        entity_ids: &[&str],
3093        naming_strategy: &str,
3094    ) -> request::RegisterEntitiesRequest {
3095        request::RegisterEntitiesRequest {
3096            client: &self,
3097            registry_id: registry_id.to_owned(),
3098            entity_ids: entity_ids.iter().map(|&x| x.to_owned()).collect(),
3099            naming_strategy: naming_strategy.to_owned(),
3100        }
3101    }
3102    /**Unregister entities
3103
3104Unregisters entities and moves them to a folder*/
3105    pub fn unregister_entities(
3106        &self,
3107        registry_id: &str,
3108        entity_ids: &[&str],
3109        folder_id: &str,
3110    ) -> request::UnregisterEntitiesRequest {
3111        request::UnregisterEntitiesRequest {
3112            client: &self,
3113            registry_id: registry_id.to_owned(),
3114            entity_ids: entity_ids.iter().map(|&x| x.to_owned()).collect(),
3115            folder_id: folder_id.to_owned(),
3116        }
3117    }
3118    /**Validate barcodes
3119
3120Validate barcodes on storage objects.*/
3121    pub fn validate_barcodes(
3122        &self,
3123        registry_id: &str,
3124        barcodes: &[&str],
3125    ) -> request::ValidateBarcodesRequest {
3126        request::ValidateBarcodesRequest {
3127            client: &self,
3128            registry_id: registry_id.to_owned(),
3129            barcodes: barcodes.iter().map(|&x| x.to_owned()).collect(),
3130        }
3131    }
3132    ///List Request Fulfillments
3133    pub fn list_request_fulfillments(
3134        &self,
3135        entry_id: &str,
3136    ) -> request::ListRequestFulfillmentsRequest {
3137        request::ListRequestFulfillmentsRequest {
3138            client: &self,
3139            entry_id: entry_id.to_owned(),
3140            modified_at: None,
3141            next_token: None,
3142            page_size: None,
3143        }
3144    }
3145    ///Get a request's fulfillment
3146    pub fn get_request_fulfillment(
3147        &self,
3148        request_fulfillment_id: &str,
3149    ) -> request::GetRequestFulfillmentRequest {
3150        request::GetRequestFulfillmentRequest {
3151            client: &self,
3152            request_fulfillment_id: request_fulfillment_id.to_owned(),
3153        }
3154    }
3155    ///List request schemas
3156    pub fn list_request_schemas(&self) -> request::ListRequestSchemasRequest {
3157        request::ListRequestSchemasRequest {
3158            client: &self,
3159            next_token: None,
3160            page_size: None,
3161            modified_at: None,
3162        }
3163    }
3164    ///Get a Request schema by ID
3165    pub fn get_request_schema(
3166        &self,
3167        schema_id: &str,
3168    ) -> request::GetRequestSchemaRequest {
3169        request::GetRequestSchemaRequest {
3170            client: &self,
3171            schema_id: schema_id.to_owned(),
3172        }
3173    }
3174    ///List request task schemas
3175    pub fn list_request_task_schemas(&self) -> request::ListRequestTaskSchemasRequest {
3176        request::ListRequestTaskSchemasRequest {
3177            client: &self,
3178            next_token: None,
3179            page_size: None,
3180            modified_at: None,
3181        }
3182    }
3183    ///Get a Request Task schema by ID
3184    pub fn get_request_task_schema(
3185        &self,
3186        schema_id: &str,
3187    ) -> request::GetRequestTaskSchemaRequest {
3188        request::GetRequestTaskSchemaRequest {
3189            client: &self,
3190            schema_id: schema_id.to_owned(),
3191        }
3192    }
3193    ///List requests
3194    pub fn list_requests(&self, schema_id: &str) -> request::ListRequestsRequest {
3195        request::ListRequestsRequest {
3196            client: &self,
3197            schema_id: schema_id.to_owned(),
3198            request_status: None,
3199            min_created_time: None,
3200            max_created_time: None,
3201            next_token: None,
3202            page_size: None,
3203        }
3204    }
3205    ///Create a request
3206    pub fn create_request(
3207        &self,
3208        args: request::CreateRequestRequired,
3209    ) -> request::CreateRequestRequest {
3210        request::CreateRequestRequest {
3211            client: &self,
3212            assignees: args.assignees,
3213            fields: args.fields,
3214            project_id: args.project_id.to_owned(),
3215            requestor_id: None,
3216            sample_groups: args.sample_groups,
3217            scheduled_on: args.scheduled_on.to_owned(),
3218            schema_id: args.schema_id.to_owned(),
3219        }
3220    }
3221    ///Get a request by ID
3222    pub fn get_request(&self, request_id: &str) -> request::GetRequestRequest {
3223        request::GetRequestRequest {
3224            client: &self,
3225            request_id: request_id.to_owned(),
3226        }
3227    }
3228    ///Update a request
3229    pub fn patch_request(
3230        &self,
3231        args: request::PatchRequestRequired,
3232    ) -> request::PatchRequestRequest {
3233        request::PatchRequestRequest {
3234            client: &self,
3235            request_id: args.request_id.to_owned(),
3236            assignees: args.assignees,
3237            fields: args.fields,
3238            project_id: args.project_id.to_owned(),
3239            requestor_id: None,
3240            sample_groups: args.sample_groups,
3241            scheduled_on: args.scheduled_on.to_owned(),
3242            request_status: args.request_status.to_owned(),
3243        }
3244    }
3245    ///Get a request's response
3246    pub fn get_request_response(
3247        &self,
3248        request_id: &str,
3249    ) -> request::GetRequestResponseRequest {
3250        request::GetRequestResponseRequest {
3251            client: &self,
3252            request_id: request_id.to_owned(),
3253        }
3254    }
3255    ///Create tasks for a request
3256    pub fn bulk_create_request_tasks(
3257        &self,
3258        request_id: &str,
3259        tasks: Vec<RequestTasksBulkCreate>,
3260    ) -> request::BulkCreateRequestTasksRequest {
3261        request::BulkCreateRequestTasksRequest {
3262            client: &self,
3263            request_id: request_id.to_owned(),
3264            tasks,
3265        }
3266    }
3267    ///Bulk update tasks for a request
3268    pub fn bulk_update_request_tasks(
3269        &self,
3270        request_id: &str,
3271        tasks: Vec<RequestTaskBase>,
3272    ) -> request::BulkUpdateRequestTasksRequest {
3273        request::BulkUpdateRequestTasksRequest {
3274            client: &self,
3275            request_id: request_id.to_owned(),
3276            tasks,
3277        }
3278    }
3279    ///Update the status of sample groups in a request
3280    pub fn execute_requests_sample_groups(
3281        &self,
3282        request_id: &str,
3283        sample_groups: Vec<SampleGroupStatusUpdate>,
3284    ) -> request::ExecuteRequestsSampleGroupsRequest {
3285        request::ExecuteRequestsSampleGroupsRequest {
3286            client: &self,
3287            request_id: request_id.to_owned(),
3288            sample_groups,
3289        }
3290    }
3291    /**Bulk get requests
3292
3293Bulk get requests by API ID or display ID*/
3294    pub fn bulk_get_requests(&self) -> request::BulkGetRequestsRequest {
3295        request::BulkGetRequestsRequest {
3296            client: &self,
3297            request_ids: None,
3298            display_ids: None,
3299        }
3300    }
3301    /**Create a transaction
3302
3303Transactions allow results to be upload in multiple requests. This endpoint lets you create a transaction. You can then upload results to the transaction, abort the transaction, or commit the transaction.
3304*/
3305    pub fn create_assay_results_transaction(
3306        &self,
3307    ) -> request::CreateAssayResultsTransactionRequest {
3308        request::CreateAssayResultsTransactionRequest {
3309            client: &self,
3310        }
3311    }
3312    ///Create results in a transaction
3313    pub fn create_assay_results_in_transaction(
3314        &self,
3315        transaction_id: &str,
3316        assay_results: Vec<AssayResultCreate>,
3317    ) -> request::CreateAssayResultsInTransactionRequest {
3318        request::CreateAssayResultsInTransactionRequest {
3319            client: &self,
3320            transaction_id: transaction_id.to_owned(),
3321            assay_results,
3322        }
3323    }
3324    /**Abort a transaction
3325
3326Aborting a transaction will discard all uploaded results.*/
3327    pub fn abort_assay_results_transaction(
3328        &self,
3329        transaction_id: &str,
3330    ) -> request::AbortAssayResultsTransactionRequest {
3331        request::AbortAssayResultsTransactionRequest {
3332            client: &self,
3333            transaction_id: transaction_id.to_owned(),
3334        }
3335    }
3336    /**Commit a transaction
3337
3338Committing a transaction will cause all results that have been uploaded to be saved and visible to others.*/
3339    pub fn commit_assay_results_transaction(
3340        &self,
3341        transaction_id: &str,
3342    ) -> request::CommitAssayResultsTransactionRequest {
3343        request::CommitAssayResultsTransactionRequest {
3344            client: &self,
3345            transaction_id: transaction_id.to_owned(),
3346        }
3347    }
3348    ///List RNA Oligos
3349    pub fn list_rna_oligos(&self) -> request::ListRnaOligosRequest {
3350        request::ListRnaOligosRequest {
3351            client: &self,
3352            page_size: None,
3353            next_token: None,
3354            sort: None,
3355            modified_at: None,
3356            name: None,
3357            name_includes: None,
3358            bases: None,
3359            folder_id: None,
3360            mentioned_in: None,
3361            project_id: None,
3362            registry_id: None,
3363            schema_id: None,
3364            schema_fields: None,
3365            archive_reason: None,
3366            mentions: None,
3367            ids: None,
3368            entity_registry_ids_any_of: None,
3369            names_any_of: None,
3370            names_any_of_case_sensitive: None,
3371            creator_ids: None,
3372            author_ids_any_of: None,
3373        }
3374    }
3375    ///Create an RNA Oligo
3376    pub fn create_rna_oligo(
3377        &self,
3378        args: request::CreateRnaOligoRequired,
3379    ) -> request::CreateRnaOligoRequest {
3380        request::CreateRnaOligoRequest {
3381            client: &self,
3382            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
3383            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
3384            bases: args.bases.to_owned(),
3385            custom_fields: args.custom_fields,
3386            fields: args.fields,
3387            folder_id: args.folder_id.to_owned(),
3388            name: args.name.to_owned(),
3389            schema_id: args.schema_id.to_owned(),
3390            entity_registry_id: args.entity_registry_id.to_owned(),
3391            naming_strategy: args.naming_strategy.to_owned(),
3392            registry_id: args.registry_id.to_owned(),
3393        }
3394    }
3395    ///Get an RNA Oligo
3396    pub fn get_rna_oligo(&self, oligo_id: &str) -> request::GetRnaOligoRequest {
3397        request::GetRnaOligoRequest {
3398            client: &self,
3399            oligo_id: oligo_id.to_owned(),
3400        }
3401    }
3402    ///Update an RNA Oligo
3403    pub fn update_rna_oligo(
3404        &self,
3405        args: request::UpdateRnaOligoRequired,
3406    ) -> request::UpdateRnaOligoRequest {
3407        request::UpdateRnaOligoRequest {
3408            client: &self,
3409            oligo_id: args.oligo_id.to_owned(),
3410            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
3411            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
3412            bases: args.bases.to_owned(),
3413            custom_fields: args.custom_fields,
3414            fields: args.fields,
3415            folder_id: args.folder_id.to_owned(),
3416            name: args.name.to_owned(),
3417            schema_id: args.schema_id.to_owned(),
3418        }
3419    }
3420    ///Archive RNA Oligos
3421    pub fn archive_rna_oligos(
3422        &self,
3423        reason: &str,
3424        rna_oligo_ids: &[&str],
3425    ) -> request::ArchiveRnaOligosRequest {
3426        request::ArchiveRnaOligosRequest {
3427            client: &self,
3428            reason: reason.to_owned(),
3429            rna_oligo_ids: rna_oligo_ids.iter().map(|&x| x.to_owned()).collect(),
3430        }
3431    }
3432    /**Bulk Create RNA Oligos
3433
3434Bulk Create RNA Oligos. Limit of 1000 RNA Oligos per request.*/
3435    pub fn bulk_create_rna_oligos(&self) -> request::BulkCreateRnaOligosRequest {
3436        request::BulkCreateRnaOligosRequest {
3437            client: &self,
3438            rna_oligos: None,
3439        }
3440    }
3441    ///Bulk Update RNA Oligos
3442    pub fn bulk_update_rna_oligos(&self) -> request::BulkUpdateRnaOligosRequest {
3443        request::BulkUpdateRnaOligosRequest {
3444            client: &self,
3445            rna_oligos: None,
3446        }
3447    }
3448    ///Unarchive RNA Oligos
3449    pub fn unarchive_rna_oligos(
3450        &self,
3451        rna_oligo_ids: &[&str],
3452    ) -> request::UnarchiveRnaOligosRequest {
3453        request::UnarchiveRnaOligosRequest {
3454            client: &self,
3455            rna_oligo_ids: rna_oligo_ids.iter().map(|&x| x.to_owned()).collect(),
3456        }
3457    }
3458    ///List RNA sequences
3459    pub fn list_rna_sequences(&self) -> request::ListRnaSequencesRequest {
3460        request::ListRnaSequencesRequest {
3461            client: &self,
3462            page_size: None,
3463            next_token: None,
3464            sort: None,
3465            modified_at: None,
3466            name: None,
3467            name_includes: None,
3468            bases: None,
3469            folder_id: None,
3470            mentioned_in: None,
3471            project_id: None,
3472            registry_id: None,
3473            schema_id: None,
3474            schema_fields: None,
3475            archive_reason: None,
3476            mentions: None,
3477            ids: None,
3478            entity_registry_ids_any_of: None,
3479            names_any_of: None,
3480            names_any_of_case_sensitive: None,
3481            creator_ids: None,
3482            author_ids_any_of: None,
3483        }
3484    }
3485    ///Create an RNA sequence
3486    pub fn create_rna_sequence(
3487        &self,
3488        args: request::CreateRnaSequenceRequired,
3489    ) -> request::CreateRnaSequenceRequest {
3490        request::CreateRnaSequenceRequest {
3491            client: &self,
3492            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
3493            annotations: args.annotations,
3494            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
3495            bases: args.bases.to_owned(),
3496            custom_fields: args.custom_fields,
3497            fields: args.fields,
3498            folder_id: args.folder_id.to_owned(),
3499            is_circular: args.is_circular,
3500            name: args.name.to_owned(),
3501            primers: args.primers,
3502            schema_id: args.schema_id.to_owned(),
3503            translations: args.translations,
3504            entity_registry_id: args.entity_registry_id.to_owned(),
3505            naming_strategy: args.naming_strategy.to_owned(),
3506            registry_id: args.registry_id.to_owned(),
3507        }
3508    }
3509    ///Get an RNA sequence
3510    pub fn get_rna_sequence(
3511        &self,
3512        rna_sequence_id: &str,
3513    ) -> request::GetRnaSequenceRequest {
3514        request::GetRnaSequenceRequest {
3515            client: &self,
3516            rna_sequence_id: rna_sequence_id.to_owned(),
3517        }
3518    }
3519    ///Update an RNA sequence
3520    pub fn update_rna_sequence(
3521        &self,
3522        args: request::UpdateRnaSequenceRequired,
3523    ) -> request::UpdateRnaSequenceRequest {
3524        request::UpdateRnaSequenceRequest {
3525            client: &self,
3526            rna_sequence_id: args.rna_sequence_id.to_owned(),
3527            aliases: args.aliases.iter().map(|&x| x.to_owned()).collect(),
3528            annotations: args.annotations,
3529            author_ids: args.author_ids.iter().map(|&x| x.to_owned()).collect(),
3530            bases: args.bases.to_owned(),
3531            custom_fields: args.custom_fields,
3532            fields: args.fields,
3533            folder_id: args.folder_id.to_owned(),
3534            is_circular: args.is_circular,
3535            name: args.name.to_owned(),
3536            primers: args.primers,
3537            schema_id: args.schema_id.to_owned(),
3538            translations: args.translations,
3539            entity_registry_id: args.entity_registry_id.to_owned(),
3540        }
3541    }
3542    /**Archive RNA Sequences
3543
3544Archive RNA Sequences. RNA sequences that are already registered will not be removed from the registry.*/
3545    pub fn archive_rna_sequences(
3546        &self,
3547        reason: &str,
3548        rna_sequence_ids: &[&str],
3549    ) -> request::ArchiveRnaSequencesRequest {
3550        request::ArchiveRnaSequencesRequest {
3551            client: &self,
3552            reason: reason.to_owned(),
3553            rna_sequence_ids: rna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
3554        }
3555    }
3556    /**Auto-annotate RNA sequences with matching features from specified Feature Libraries
3557
3558Auto-annotate RNA sequences with matching features from specified Feature Libraries. U/T bases are treated as interchangeable in both features and sequences.*/
3559    pub fn auto_annotate_rna_sequences(
3560        &self,
3561        feature_library_ids: &[&str],
3562        rna_sequence_ids: &[&str],
3563    ) -> request::AutoAnnotateRnaSequencesRequest {
3564        request::AutoAnnotateRnaSequencesRequest {
3565            client: &self,
3566            feature_library_ids: feature_library_ids
3567                .iter()
3568                .map(|&x| x.to_owned())
3569                .collect(),
3570            rna_sequence_ids: rna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
3571        }
3572    }
3573    /**Autofill RNA sequence parts
3574
3575Autofill parts from matching RNA Sequences with linked schemas.*/
3576    pub fn autofill_rna_sequence_parts(
3577        &self,
3578        rna_sequence_ids: &[&str],
3579    ) -> request::AutofillRnaSequencePartsRequest {
3580        request::AutofillRnaSequencePartsRequest {
3581            client: &self,
3582            rna_sequence_ids: rna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
3583        }
3584    }
3585    /**Autofill RNA sequence translations from Amino Acid sequences with matching schemas
3586
3587Autofill RNA sequence translations*/
3588    pub fn autofill_rna_sequence_translations(
3589        &self,
3590        rna_sequence_ids: &[&str],
3591    ) -> request::AutofillRnaSequenceTranslationsRequest {
3592        request::AutofillRnaSequenceTranslationsRequest {
3593            client: &self,
3594            rna_sequence_ids: rna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
3595        }
3596    }
3597    /**Bulk Create RNA sequences
3598
3599Bulk Create RNA sequences. Limit of 1000 RNA Sequences per request.*/
3600    pub fn bulk_create_rna_sequences(&self) -> request::BulkCreateRnaSequencesRequest {
3601        request::BulkCreateRnaSequencesRequest {
3602            client: &self,
3603            rna_sequences: None,
3604        }
3605    }
3606    ///Bulk get RNA sequences by ID
3607    pub fn bulk_get_rna_sequences(
3608        &self,
3609        rna_sequence_ids: &str,
3610    ) -> request::BulkGetRnaSequencesRequest {
3611        request::BulkGetRnaSequencesRequest {
3612            client: &self,
3613            rna_sequence_ids: rna_sequence_ids.to_owned(),
3614        }
3615    }
3616    ///Bulk Update RNA sequences
3617    pub fn bulk_update_rna_sequences(&self) -> request::BulkUpdateRnaSequencesRequest {
3618        request::BulkUpdateRnaSequencesRequest {
3619            client: &self,
3620            rna_sequences: None,
3621        }
3622    }
3623    ///Unarchive RNA sequences
3624    pub fn unarchive_rna_sequences(
3625        &self,
3626        rna_sequence_ids: &[&str],
3627    ) -> request::UnarchiveRnaSequencesRequest {
3628        request::UnarchiveRnaSequencesRequest {
3629            client: &self,
3630            rna_sequence_ids: rna_sequence_ids.iter().map(|&x| x.to_owned()).collect(),
3631        }
3632    }
3633    ///Get a task by id
3634    pub fn get_task(&self, task_id: &str) -> request::GetTaskRequest {
3635        request::GetTaskRequest {
3636            client: &self,
3637            task_id: task_id.to_owned(),
3638        }
3639    }
3640    /**List teams
3641
3642Returns all teams that the caller has permission to view. The following roles have view permission:
3643  - tenant admins
3644  - members of the team's organization
3645*/
3646    pub fn list_teams(&self) -> request::ListTeamsRequest {
3647        request::ListTeamsRequest {
3648            client: &self,
3649            ids: None,
3650            name: None,
3651            name_includes: None,
3652            names_any_of: None,
3653            names_any_of_case_sensitive: None,
3654            modified_at: None,
3655            mentioned_in: None,
3656            organization_id: None,
3657            has_members: None,
3658            has_admins: None,
3659            page_size: None,
3660            next_token: None,
3661            sort: None,
3662        }
3663    }
3664    /**Get a team by ID
3665
3666Returns a team by ID if the caller has permission to view. The following roles have view permission:
3667  - tenant admins
3668  - members of the team's organization
3669*/
3670    pub fn get_team(&self, team_id: &str) -> request::GetTeamRequest {
3671        request::GetTeamRequest {
3672            client: &self,
3673            team_id: team_id.to_owned(),
3674        }
3675    }
3676    /**Generate a token for usage with authenticating via OAuth2 in subsequent API calls.
3677
3678Generate a token*/
3679    pub fn generate_token(&self) -> request::GenerateTokenRequest {
3680        request::GenerateTokenRequest {
3681            client: &self,
3682        }
3683    }
3684    /**Transfers into containers
3685
3686Transfers a volume of an entity, batch, or container into a destination container. Limit of 5000 transfers per request. Concentration of all contents in the destination container will be automatically updated based on the previous volume & concentrations of the contents in that container, the concentration of the contents being transferred in, the volume of the contents being transferred in, and the final volume of the container. If no concentration is specified, the concentration will not be tracked.
3687*/
3688    pub fn transfer_into_containers(
3689        &self,
3690        transfers: Vec<MultipleContainersTransfer>,
3691    ) -> request::TransferIntoContainersRequest {
3692        request::TransferIntoContainersRequest {
3693            client: &self,
3694            transfers,
3695        }
3696    }
3697    /**List users
3698
3699Returns all users that the caller has permission to view. The following roles have view permission:
3700  - tenant admins
3701  - members of the user's organizations
3702*/
3703    pub fn list_users(&self) -> request::ListUsersRequest {
3704        request::ListUsersRequest {
3705            client: &self,
3706            ids: None,
3707            name: None,
3708            name_includes: None,
3709            names_any_of: None,
3710            names_any_of_case_sensitive: None,
3711            modified_at: None,
3712            member_of: None,
3713            admin_of: None,
3714            handles: None,
3715            password_last_changed_at: None,
3716            page_size: None,
3717            next_token: None,
3718            sort: None,
3719        }
3720    }
3721    /**Get a user by ID
3722
3723Returns a user by ID if the caller has permission to view. The following roles have view permission:
3724  - tenant admins
3725  - members of any of the user's organizations
3726*/
3727    pub fn get_user(&self, user_id: &str) -> request::GetUserRequest {
3728        request::GetUserRequest {
3729            client: &self,
3730            user_id: user_id.to_owned(),
3731        }
3732    }
3733    /**Create Benchling Warehouse credentials
3734
3735Allows for programmatically generating credentials to connect to the Benchling warehouse. You must have a warehouse configured to access this endpoint.
3736The credentials will authenticate as the same user calling the API.
3737Note that expiresIn is required - only temporary credentials are currently allowed.
3738*/
3739    pub fn create_warehouse_credentials(
3740        &self,
3741        expires_in: i64,
3742    ) -> request::CreateWarehouseCredentialsRequest {
3743        request::CreateWarehouseCredentialsRequest {
3744            client: &self,
3745            expires_in,
3746        }
3747    }
3748    ///List workflow outputs
3749    pub fn list_workflow_outputs(&self) -> request::ListWorkflowOutputsRequest {
3750        request::ListWorkflowOutputsRequest {
3751            client: &self,
3752            ids: None,
3753            workflow_task_group_ids: None,
3754            workflow_task_ids: None,
3755            schema_id: None,
3756            watcher_ids: None,
3757            responsible_team_ids: None,
3758            creation_origin_ids: None,
3759            linked_item_ids_any_of: None,
3760            linked_item_ids_all_of: None,
3761            linked_item_ids_none_of: None,
3762            schema_fields: None,
3763            name: None,
3764            name_includes: None,
3765            creator_ids: None,
3766            modified_at: None,
3767            next_token: None,
3768            page_size: None,
3769            display_ids: None,
3770            archive_reason: None,
3771        }
3772    }
3773    ///Create a new workflow output
3774    pub fn create_workflow_output(
3775        &self,
3776        fields: Fields,
3777        workflow_task_id: &str,
3778    ) -> request::CreateWorkflowOutputRequest {
3779        request::CreateWorkflowOutputRequest {
3780            client: &self,
3781            fields,
3782            workflow_task_id: workflow_task_id.to_owned(),
3783        }
3784    }
3785    ///Get a workflow output
3786    pub fn get_workflow_output(
3787        &self,
3788        workflow_output_id: &str,
3789    ) -> request::GetWorkflowOutputRequest {
3790        request::GetWorkflowOutputRequest {
3791            client: &self,
3792            workflow_output_id: workflow_output_id.to_owned(),
3793        }
3794    }
3795    ///Update a workflow output
3796    pub fn update_workflow_output(
3797        &self,
3798        workflow_output_id: &str,
3799        fields: Fields,
3800    ) -> request::UpdateWorkflowOutputRequest {
3801        request::UpdateWorkflowOutputRequest {
3802            client: &self,
3803            workflow_output_id: workflow_output_id.to_owned(),
3804            fields,
3805        }
3806    }
3807    ///Archive one or more workflow outputs
3808    pub fn archive_workflow_outputs(
3809        &self,
3810        reason: &str,
3811        workflow_output_ids: &[&str],
3812    ) -> request::ArchiveWorkflowOutputsRequest {
3813        request::ArchiveWorkflowOutputsRequest {
3814            client: &self,
3815            reason: reason.to_owned(),
3816            workflow_output_ids: workflow_output_ids
3817                .iter()
3818                .map(|&x| x.to_owned())
3819                .collect(),
3820        }
3821    }
3822    ///Bulk create new workflow outputs
3823    pub fn bulk_create_workflow_outputs(
3824        &self,
3825    ) -> request::BulkCreateWorkflowOutputsRequest {
3826        request::BulkCreateWorkflowOutputsRequest {
3827            client: &self,
3828            workflow_outputs: None,
3829        }
3830    }
3831    ///Bulk update workflow outputs
3832    pub fn bulk_update_workflow_outputs(
3833        &self,
3834    ) -> request::BulkUpdateWorkflowOutputsRequest {
3835        request::BulkUpdateWorkflowOutputsRequest {
3836            client: &self,
3837            workflow_outputs: None,
3838        }
3839    }
3840    ///Unarchive one or more workflow outputs
3841    pub fn unarchive_workflow_outputs(
3842        &self,
3843        workflow_output_ids: &[&str],
3844    ) -> request::UnarchiveWorkflowOutputsRequest {
3845        request::UnarchiveWorkflowOutputsRequest {
3846            client: &self,
3847            workflow_output_ids: workflow_output_ids
3848                .iter()
3849                .map(|&x| x.to_owned())
3850                .collect(),
3851        }
3852    }
3853    ///List stage run input samples
3854    pub fn list_stage_run_input_samples(
3855        &self,
3856        stage_run_id: &str,
3857    ) -> request::ListStageRunInputSamplesRequest {
3858        request::ListStageRunInputSamplesRequest {
3859            client: &self,
3860            stage_run_id: stage_run_id.to_owned(),
3861        }
3862    }
3863    ///List stage run output samples
3864    pub fn list_stage_run_output_samples(
3865        &self,
3866        stage_run_id: &str,
3867    ) -> request::ListStageRunOutputSamplesRequest {
3868        request::ListStageRunOutputSamplesRequest {
3869            client: &self,
3870            stage_run_id: stage_run_id.to_owned(),
3871        }
3872    }
3873    ///List stage run registered samples
3874    pub fn list_stage_run_registered_samples(
3875        &self,
3876        stage_run_id: &str,
3877    ) -> request::ListStageRunRegisteredSamplesRequest {
3878        request::ListStageRunRegisteredSamplesRequest {
3879            client: &self,
3880            stage_run_id: stage_run_id.to_owned(),
3881        }
3882    }
3883    ///List workflow stage runs
3884    pub fn list_workflow_stage_runs(
3885        &self,
3886        stage_id: &str,
3887    ) -> request::ListWorkflowStageRunsRequest {
3888        request::ListWorkflowStageRunsRequest {
3889            client: &self,
3890            stage_id: stage_id.to_owned(),
3891        }
3892    }
3893    ///List workflow task groups
3894    pub fn list_workflow_task_groups(&self) -> request::ListWorkflowTaskGroupsRequest {
3895        request::ListWorkflowTaskGroupsRequest {
3896            client: &self,
3897            ids: None,
3898            schema_id: None,
3899            folder_id: None,
3900            project_id: None,
3901            mentioned_in: None,
3902            watcher_ids: None,
3903            execution_types: None,
3904            responsible_team_ids: None,
3905            status_ids_any_of: None,
3906            status_ids_none_of: None,
3907            status_ids_only: None,
3908            name: None,
3909            name_includes: None,
3910            creator_ids: None,
3911            modified_at: None,
3912            next_token: None,
3913            page_size: None,
3914            display_ids: None,
3915            archive_reason: None,
3916        }
3917    }
3918    /**Create a new workflow task group
3919
3920Create a new workflow task group. If no name is specified, uses the workflow schema name and a unique incrementor separated by a single whitespace.*/
3921    pub fn create_workflow_task_group(
3922        &self,
3923        args: request::CreateWorkflowTaskGroupRequired,
3924    ) -> request::CreateWorkflowTaskGroupRequest {
3925        request::CreateWorkflowTaskGroupRequest {
3926            client: &self,
3927            folder_id: args.folder_id.to_owned(),
3928            name: args.name.to_owned(),
3929            watcher_ids: args.watcher_ids.iter().map(|&x| x.to_owned()).collect(),
3930            schema_id: args.schema_id.to_owned(),
3931        }
3932    }
3933    ///Get a workflow task group
3934    pub fn get_workflow_task_group(
3935        &self,
3936        workflow_task_group_id: &str,
3937    ) -> request::GetWorkflowTaskGroupRequest {
3938        request::GetWorkflowTaskGroupRequest {
3939            client: &self,
3940            workflow_task_group_id: workflow_task_group_id.to_owned(),
3941        }
3942    }
3943    ///Update a workflow task group
3944    pub fn update_workflow_task_group(
3945        &self,
3946        args: request::UpdateWorkflowTaskGroupRequired,
3947    ) -> request::UpdateWorkflowTaskGroupRequest {
3948        request::UpdateWorkflowTaskGroupRequest {
3949            client: &self,
3950            workflow_task_group_id: args.workflow_task_group_id.to_owned(),
3951            folder_id: args.folder_id.to_owned(),
3952            name: args.name.to_owned(),
3953            watcher_ids: args.watcher_ids.iter().map(|&x| x.to_owned()).collect(),
3954        }
3955    }
3956    ///Archive one or more workflows
3957    pub fn archive_workflow_task_groups(
3958        &self,
3959        reason: &str,
3960        workflow_task_group_ids: &[&str],
3961    ) -> request::ArchiveWorkflowTaskGroupsRequest {
3962        request::ArchiveWorkflowTaskGroupsRequest {
3963            client: &self,
3964            reason: reason.to_owned(),
3965            workflow_task_group_ids: workflow_task_group_ids
3966                .iter()
3967                .map(|&x| x.to_owned())
3968                .collect(),
3969        }
3970    }
3971    ///Unarchive one or more workflows
3972    pub fn unarchive_workflow_task_groups(
3973        &self,
3974        workflow_task_group_ids: &[&str],
3975    ) -> request::UnarchiveWorkflowTaskGroupsRequest {
3976        request::UnarchiveWorkflowTaskGroupsRequest {
3977            client: &self,
3978            workflow_task_group_ids: workflow_task_group_ids
3979                .iter()
3980                .map(|&x| x.to_owned())
3981                .collect(),
3982        }
3983    }
3984    ///List workflow task schemas
3985    pub fn list_workflow_task_schemas(&self) -> request::ListWorkflowTaskSchemasRequest {
3986        request::ListWorkflowTaskSchemasRequest {
3987            client: &self,
3988            next_token: None,
3989            page_size: None,
3990            modified_at: None,
3991        }
3992    }
3993    ///Get a workflow task schema
3994    pub fn get_workflow_task_schema(
3995        &self,
3996        schema_id: &str,
3997    ) -> request::GetWorkflowTaskSchemaRequest {
3998        request::GetWorkflowTaskSchemaRequest {
3999            client: &self,
4000            schema_id: schema_id.to_owned(),
4001        }
4002    }
4003    ///List workflow tasks
4004    pub fn list_workflow_tasks(&self) -> request::ListWorkflowTasksRequest {
4005        request::ListWorkflowTasksRequest {
4006            client: &self,
4007            ids: None,
4008            workflow_task_group_ids: None,
4009            schema_id: None,
4010            status_ids: None,
4011            assignee_ids: None,
4012            watcher_ids: None,
4013            responsible_team_ids: None,
4014            execution_origin_ids: None,
4015            execution_types: None,
4016            linked_item_ids_any_of: None,
4017            linked_item_ids_all_of: None,
4018            linked_item_ids_none_of: None,
4019            schema_fields: None,
4020            name: None,
4021            name_includes: None,
4022            creator_ids: None,
4023            scheduled_on: None,
4024            scheduled_on_lt: None,
4025            scheduled_on_lte: None,
4026            scheduled_on_gte: None,
4027            scheduled_on_gt: None,
4028            modified_at: None,
4029            next_token: None,
4030            page_size: None,
4031            display_ids: None,
4032            archive_reason: None,
4033        }
4034    }
4035    ///Create a new workflow task
4036    pub fn create_workflow_task(
4037        &self,
4038        args: request::CreateWorkflowTaskRequired,
4039    ) -> request::CreateWorkflowTaskRequest {
4040        request::CreateWorkflowTaskRequest {
4041            client: &self,
4042            assignee_id: args.assignee_id.to_owned(),
4043            fields: args.fields,
4044            scheduled_on: args.scheduled_on.to_owned(),
4045            workflow_task_group_id: args.workflow_task_group_id.to_owned(),
4046        }
4047    }
4048    ///Get a workflow task
4049    pub fn get_workflow_task(
4050        &self,
4051        workflow_task_id: &str,
4052    ) -> request::GetWorkflowTaskRequest {
4053        request::GetWorkflowTaskRequest {
4054            client: &self,
4055            workflow_task_id: workflow_task_id.to_owned(),
4056        }
4057    }
4058    ///Update a workflow task
4059    pub fn update_workflow_task(
4060        &self,
4061        workflow_task_id: &str,
4062    ) -> request::UpdateWorkflowTaskRequest {
4063        request::UpdateWorkflowTaskRequest {
4064            client: &self,
4065            workflow_task_id: workflow_task_id.to_owned(),
4066        }
4067    }
4068    /**Creates a new workflow task with the same fields and assignee as the provided task and creates a relationship between the two tasks
4069
4070
4071Creates a new workflow task based on the provided task*/
4072    pub fn copy_workflow_task(
4073        &self,
4074        workflow_task_id: &str,
4075    ) -> request::CopyWorkflowTaskRequest {
4076        request::CopyWorkflowTaskRequest {
4077            client: &self,
4078            workflow_task_id: workflow_task_id.to_owned(),
4079        }
4080    }
4081    ///Archive one or more workflow tasks
4082    pub fn archive_workflow_tasks(
4083        &self,
4084        reason: &str,
4085        workflow_task_ids: &[&str],
4086    ) -> request::ArchiveWorkflowTasksRequest {
4087        request::ArchiveWorkflowTasksRequest {
4088            client: &self,
4089            reason: reason.to_owned(),
4090            workflow_task_ids: workflow_task_ids.iter().map(|&x| x.to_owned()).collect(),
4091        }
4092    }
4093    /**Bulk creates new workflow tasks where each new task has the same fields and assignee as one of the provided tasks and creates a relationship between the provided task and its copy
4094
4095
4096Bulk creates new workflow tasks based on the provided tasks*/
4097    pub fn bulk_copy_workflow_tasks(&self) -> request::BulkCopyWorkflowTasksRequest {
4098        request::BulkCopyWorkflowTasksRequest {
4099            client: &self,
4100            workflow_task_ids: None,
4101        }
4102    }
4103    ///Create one or more workflow tasks
4104    pub fn bulk_create_workflow_tasks(&self) -> request::BulkCreateWorkflowTasksRequest {
4105        request::BulkCreateWorkflowTasksRequest {
4106            client: &self,
4107            workflow_tasks: None,
4108        }
4109    }
4110    /**Update one or more workflow task
4111
4112Update one or more workflow tasks*/
4113    pub fn bulk_update_workflow_tasks(&self) -> request::BulkUpdateWorkflowTasksRequest {
4114        request::BulkUpdateWorkflowTasksRequest {
4115            client: &self,
4116            workflow_tasks: None,
4117        }
4118    }
4119    ///Unarchive one or more workflow tasks
4120    pub fn unarchive_workflow_tasks(
4121        &self,
4122        workflow_task_ids: &[&str],
4123    ) -> request::UnarchiveWorkflowTasksRequest {
4124        request::UnarchiveWorkflowTasksRequest {
4125            client: &self,
4126            workflow_task_ids: workflow_task_ids.iter().map(|&x| x.to_owned()).collect(),
4127        }
4128    }
4129    ///List workflows
4130    pub fn list_workflows(&self) -> request::ListWorkflowsRequest {
4131        request::ListWorkflowsRequest {
4132            client: &self,
4133        }
4134    }
4135    /**Update workflow
4136
4137Update workflow metadata*/
4138    pub fn update_workflow_metadata(
4139        &self,
4140        workflow_id: &str,
4141    ) -> request::UpdateWorkflowMetadataRequest {
4142        request::UpdateWorkflowMetadataRequest {
4143            client: &self,
4144            workflow_id: workflow_id.to_owned(),
4145            description: None,
4146            name: None,
4147            project_id: None,
4148        }
4149    }
4150    ///List workflow stages
4151    pub fn list_workflow_stages(
4152        &self,
4153        workflow_id: &str,
4154    ) -> request::ListWorkflowStagesRequest {
4155        request::ListWorkflowStagesRequest {
4156            client: &self,
4157            workflow_id: workflow_id.to_owned(),
4158        }
4159    }
4160}
4161pub enum BenchlingAuthentication {
4162    BasicApiKeyAuth { basic_api_key_auth: String },
4163}
4164impl BenchlingAuthentication {
4165    pub fn from_env() -> Self {
4166        Self::BasicApiKeyAuth {
4167            basic_api_key_auth: std::env::var("BENCHLING_BASIC_API_KEY_AUTH")
4168                .expect("Environment variable BENCHLING_BASIC_API_KEY_AUTH is not set."),
4169        }
4170    }
4171}
benchling/lib.rs

benchling/
lib.rs
