lance_namespace_reqwest_client/apis/
table_api.rs

1/*
2 * Lance Namespace Specification
3 *
4 * This OpenAPI specification is a part of the Lance namespace specification. It contains 2 parts:  The `components/schemas`, `components/responses`, `components/examples`, `tags` sections define the request and response shape for each operation in a Lance Namespace across all implementations. See https://lance.org/format/namespace/operations for more details.  The `servers`, `security`, `paths`, `components/parameters` sections are for the Lance REST Namespace implementation, which defines a complete REST server that can work with Lance datasets. See https://lance.org/format/namespace/rest for more details. 
5 *
6 * The version of the OpenAPI document: 1.0.0
7 * 
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`alter_table_add_columns`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum AlterTableAddColumnsError {
22    Status400(models::ErrorResponse),
23    Status401(models::ErrorResponse),
24    Status403(models::ErrorResponse),
25    Status404(models::ErrorResponse),
26    Status503(models::ErrorResponse),
27    Status5XX(models::ErrorResponse),
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`alter_table_alter_columns`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum AlterTableAlterColumnsError {
35    Status400(models::ErrorResponse),
36    Status401(models::ErrorResponse),
37    Status403(models::ErrorResponse),
38    Status404(models::ErrorResponse),
39    Status503(models::ErrorResponse),
40    Status5XX(models::ErrorResponse),
41    UnknownValue(serde_json::Value),
42}
43
44/// struct for typed errors of method [`alter_table_backfill_columns`]
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum AlterTableBackfillColumnsError {
48    Status400(models::ErrorResponse),
49    Status401(models::ErrorResponse),
50    Status403(models::ErrorResponse),
51    Status404(models::ErrorResponse),
52    Status503(models::ErrorResponse),
53    Status5XX(models::ErrorResponse),
54    UnknownValue(serde_json::Value),
55}
56
57/// struct for typed errors of method [`alter_table_drop_columns`]
58#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum AlterTableDropColumnsError {
61    Status400(models::ErrorResponse),
62    Status401(models::ErrorResponse),
63    Status403(models::ErrorResponse),
64    Status404(models::ErrorResponse),
65    Status503(models::ErrorResponse),
66    Status5XX(models::ErrorResponse),
67    UnknownValue(serde_json::Value),
68}
69
70/// struct for typed errors of method [`analyze_table_query_plan`]
71#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum AnalyzeTableQueryPlanError {
74    Status400(models::ErrorResponse),
75    Status401(models::ErrorResponse),
76    Status403(models::ErrorResponse),
77    Status404(models::ErrorResponse),
78    Status503(models::ErrorResponse),
79    Status5XX(models::ErrorResponse),
80    UnknownValue(serde_json::Value),
81}
82
83/// struct for typed errors of method [`batch_commit_tables`]
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum BatchCommitTablesError {
87    Status400(models::ErrorResponse),
88    Status401(models::ErrorResponse),
89    Status403(models::ErrorResponse),
90    Status404(models::ErrorResponse),
91    Status409(models::ErrorResponse),
92    Status503(models::ErrorResponse),
93    Status5XX(models::ErrorResponse),
94    UnknownValue(serde_json::Value),
95}
96
97/// struct for typed errors of method [`batch_create_table_versions`]
98#[derive(Debug, Clone, Serialize, Deserialize)]
99#[serde(untagged)]
100pub enum BatchCreateTableVersionsError {
101    Status400(models::ErrorResponse),
102    Status401(models::ErrorResponse),
103    Status403(models::ErrorResponse),
104    Status404(models::ErrorResponse),
105    Status409(models::ErrorResponse),
106    Status503(models::ErrorResponse),
107    Status5XX(models::ErrorResponse),
108    UnknownValue(serde_json::Value),
109}
110
111/// struct for typed errors of method [`batch_delete_table_versions`]
112#[derive(Debug, Clone, Serialize, Deserialize)]
113#[serde(untagged)]
114pub enum BatchDeleteTableVersionsError {
115    Status400(models::ErrorResponse),
116    Status401(models::ErrorResponse),
117    Status403(models::ErrorResponse),
118    Status404(models::ErrorResponse),
119    Status503(models::ErrorResponse),
120    Status5XX(models::ErrorResponse),
121    UnknownValue(serde_json::Value),
122}
123
124/// struct for typed errors of method [`count_table_rows`]
125#[derive(Debug, Clone, Serialize, Deserialize)]
126#[serde(untagged)]
127pub enum CountTableRowsError {
128    Status400(models::ErrorResponse),
129    Status401(models::ErrorResponse),
130    Status403(models::ErrorResponse),
131    Status404(models::ErrorResponse),
132    Status503(models::ErrorResponse),
133    Status5XX(models::ErrorResponse),
134    UnknownValue(serde_json::Value),
135}
136
137/// struct for typed errors of method [`create_table`]
138#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum CreateTableError {
141    Status400(models::ErrorResponse),
142    Status401(models::ErrorResponse),
143    Status403(models::ErrorResponse),
144    Status404(models::ErrorResponse),
145    Status409(models::ErrorResponse),
146    Status503(models::ErrorResponse),
147    Status5XX(models::ErrorResponse),
148    UnknownValue(serde_json::Value),
149}
150
151/// struct for typed errors of method [`create_table_index`]
152#[derive(Debug, Clone, Serialize, Deserialize)]
153#[serde(untagged)]
154pub enum CreateTableIndexError {
155    Status400(models::ErrorResponse),
156    Status401(models::ErrorResponse),
157    Status403(models::ErrorResponse),
158    Status404(models::ErrorResponse),
159    Status503(models::ErrorResponse),
160    Status5XX(models::ErrorResponse),
161    UnknownValue(serde_json::Value),
162}
163
164/// struct for typed errors of method [`create_table_scalar_index`]
165#[derive(Debug, Clone, Serialize, Deserialize)]
166#[serde(untagged)]
167pub enum CreateTableScalarIndexError {
168    Status400(models::ErrorResponse),
169    Status401(models::ErrorResponse),
170    Status403(models::ErrorResponse),
171    Status404(models::ErrorResponse),
172    Status503(models::ErrorResponse),
173    Status5XX(models::ErrorResponse),
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`create_table_tag`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum CreateTableTagError {
181    Status400(models::ErrorResponse),
182    Status401(models::ErrorResponse),
183    Status403(models::ErrorResponse),
184    Status404(models::ErrorResponse),
185    Status409(models::ErrorResponse),
186    Status503(models::ErrorResponse),
187    Status5XX(models::ErrorResponse),
188    UnknownValue(serde_json::Value),
189}
190
191/// struct for typed errors of method [`create_table_version`]
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(untagged)]
194pub enum CreateTableVersionError {
195    Status400(models::ErrorResponse),
196    Status401(models::ErrorResponse),
197    Status403(models::ErrorResponse),
198    Status404(models::ErrorResponse),
199    Status409(models::ErrorResponse),
200    Status503(models::ErrorResponse),
201    Status5XX(models::ErrorResponse),
202    UnknownValue(serde_json::Value),
203}
204
205/// struct for typed errors of method [`declare_table`]
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(untagged)]
208pub enum DeclareTableError {
209    Status400(models::ErrorResponse),
210    Status401(models::ErrorResponse),
211    Status403(models::ErrorResponse),
212    Status404(models::ErrorResponse),
213    Status409(models::ErrorResponse),
214    Status503(models::ErrorResponse),
215    Status5XX(models::ErrorResponse),
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed errors of method [`delete_from_table`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum DeleteFromTableError {
223    Status400(models::ErrorResponse),
224    Status401(models::ErrorResponse),
225    Status403(models::ErrorResponse),
226    Status404(models::ErrorResponse),
227    Status503(models::ErrorResponse),
228    Status5XX(models::ErrorResponse),
229    UnknownValue(serde_json::Value),
230}
231
232/// struct for typed errors of method [`delete_table_tag`]
233#[derive(Debug, Clone, Serialize, Deserialize)]
234#[serde(untagged)]
235pub enum DeleteTableTagError {
236    Status400(models::ErrorResponse),
237    Status401(models::ErrorResponse),
238    Status403(models::ErrorResponse),
239    Status404(models::ErrorResponse),
240    Status503(models::ErrorResponse),
241    Status5XX(models::ErrorResponse),
242    UnknownValue(serde_json::Value),
243}
244
245/// struct for typed errors of method [`deregister_table`]
246#[derive(Debug, Clone, Serialize, Deserialize)]
247#[serde(untagged)]
248pub enum DeregisterTableError {
249    Status400(models::ErrorResponse),
250    Status401(models::ErrorResponse),
251    Status403(models::ErrorResponse),
252    Status404(models::ErrorResponse),
253    Status503(models::ErrorResponse),
254    Status5XX(models::ErrorResponse),
255    UnknownValue(serde_json::Value),
256}
257
258/// struct for typed errors of method [`describe_table`]
259#[derive(Debug, Clone, Serialize, Deserialize)]
260#[serde(untagged)]
261pub enum DescribeTableError {
262    Status400(models::ErrorResponse),
263    Status401(models::ErrorResponse),
264    Status403(models::ErrorResponse),
265    Status404(models::ErrorResponse),
266    Status503(models::ErrorResponse),
267    Status5XX(models::ErrorResponse),
268    UnknownValue(serde_json::Value),
269}
270
271/// struct for typed errors of method [`describe_table_index_stats`]
272#[derive(Debug, Clone, Serialize, Deserialize)]
273#[serde(untagged)]
274pub enum DescribeTableIndexStatsError {
275    Status400(models::ErrorResponse),
276    Status401(models::ErrorResponse),
277    Status403(models::ErrorResponse),
278    Status404(models::ErrorResponse),
279    Status503(models::ErrorResponse),
280    Status5XX(models::ErrorResponse),
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`describe_table_version`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum DescribeTableVersionError {
288    Status400(models::ErrorResponse),
289    Status401(models::ErrorResponse),
290    Status403(models::ErrorResponse),
291    Status404(models::ErrorResponse),
292    Status503(models::ErrorResponse),
293    Status5XX(models::ErrorResponse),
294    UnknownValue(serde_json::Value),
295}
296
297/// struct for typed errors of method [`drop_table`]
298#[derive(Debug, Clone, Serialize, Deserialize)]
299#[serde(untagged)]
300pub enum DropTableError {
301    Status400(models::ErrorResponse),
302    Status401(models::ErrorResponse),
303    Status403(models::ErrorResponse),
304    Status404(models::ErrorResponse),
305    Status503(models::ErrorResponse),
306    Status5XX(models::ErrorResponse),
307    UnknownValue(serde_json::Value),
308}
309
310/// struct for typed errors of method [`drop_table_index`]
311#[derive(Debug, Clone, Serialize, Deserialize)]
312#[serde(untagged)]
313pub enum DropTableIndexError {
314    Status400(models::ErrorResponse),
315    Status401(models::ErrorResponse),
316    Status403(models::ErrorResponse),
317    Status404(models::ErrorResponse),
318    Status503(models::ErrorResponse),
319    Status5XX(models::ErrorResponse),
320    UnknownValue(serde_json::Value),
321}
322
323/// struct for typed errors of method [`explain_table_query_plan`]
324#[derive(Debug, Clone, Serialize, Deserialize)]
325#[serde(untagged)]
326pub enum ExplainTableQueryPlanError {
327    Status400(models::ErrorResponse),
328    Status401(models::ErrorResponse),
329    Status403(models::ErrorResponse),
330    Status404(models::ErrorResponse),
331    Status503(models::ErrorResponse),
332    Status5XX(models::ErrorResponse),
333    UnknownValue(serde_json::Value),
334}
335
336/// struct for typed errors of method [`get_table_stats`]
337#[derive(Debug, Clone, Serialize, Deserialize)]
338#[serde(untagged)]
339pub enum GetTableStatsError {
340    Status400(models::ErrorResponse),
341    Status401(models::ErrorResponse),
342    Status403(models::ErrorResponse),
343    Status404(models::ErrorResponse),
344    Status503(models::ErrorResponse),
345    Status5XX(models::ErrorResponse),
346    UnknownValue(serde_json::Value),
347}
348
349/// struct for typed errors of method [`get_table_tag_version`]
350#[derive(Debug, Clone, Serialize, Deserialize)]
351#[serde(untagged)]
352pub enum GetTableTagVersionError {
353    Status400(models::ErrorResponse),
354    Status401(models::ErrorResponse),
355    Status403(models::ErrorResponse),
356    Status404(models::ErrorResponse),
357    Status503(models::ErrorResponse),
358    Status5XX(models::ErrorResponse),
359    UnknownValue(serde_json::Value),
360}
361
362/// struct for typed errors of method [`insert_into_table`]
363#[derive(Debug, Clone, Serialize, Deserialize)]
364#[serde(untagged)]
365pub enum InsertIntoTableError {
366    Status400(models::ErrorResponse),
367    Status401(models::ErrorResponse),
368    Status403(models::ErrorResponse),
369    Status404(models::ErrorResponse),
370    Status503(models::ErrorResponse),
371    Status5XX(models::ErrorResponse),
372    UnknownValue(serde_json::Value),
373}
374
375/// struct for typed errors of method [`list_all_tables`]
376#[derive(Debug, Clone, Serialize, Deserialize)]
377#[serde(untagged)]
378pub enum ListAllTablesError {
379    Status400(models::ErrorResponse),
380    Status401(models::ErrorResponse),
381    Status403(models::ErrorResponse),
382    Status503(models::ErrorResponse),
383    Status5XX(models::ErrorResponse),
384    UnknownValue(serde_json::Value),
385}
386
387/// struct for typed errors of method [`list_table_indices`]
388#[derive(Debug, Clone, Serialize, Deserialize)]
389#[serde(untagged)]
390pub enum ListTableIndicesError {
391    Status400(models::ErrorResponse),
392    Status401(models::ErrorResponse),
393    Status403(models::ErrorResponse),
394    Status404(models::ErrorResponse),
395    Status503(models::ErrorResponse),
396    Status5XX(models::ErrorResponse),
397    UnknownValue(serde_json::Value),
398}
399
400/// struct for typed errors of method [`list_table_tags`]
401#[derive(Debug, Clone, Serialize, Deserialize)]
402#[serde(untagged)]
403pub enum ListTableTagsError {
404    Status400(models::ErrorResponse),
405    Status401(models::ErrorResponse),
406    Status403(models::ErrorResponse),
407    Status404(models::ErrorResponse),
408    Status503(models::ErrorResponse),
409    Status5XX(models::ErrorResponse),
410    UnknownValue(serde_json::Value),
411}
412
413/// struct for typed errors of method [`list_table_versions`]
414#[derive(Debug, Clone, Serialize, Deserialize)]
415#[serde(untagged)]
416pub enum ListTableVersionsError {
417    Status400(models::ErrorResponse),
418    Status401(models::ErrorResponse),
419    Status403(models::ErrorResponse),
420    Status404(models::ErrorResponse),
421    Status503(models::ErrorResponse),
422    Status5XX(models::ErrorResponse),
423    UnknownValue(serde_json::Value),
424}
425
426/// struct for typed errors of method [`list_tables`]
427#[derive(Debug, Clone, Serialize, Deserialize)]
428#[serde(untagged)]
429pub enum ListTablesError {
430    Status400(models::ErrorResponse),
431    Status401(models::ErrorResponse),
432    Status403(models::ErrorResponse),
433    Status404(models::ErrorResponse),
434    Status406(models::ErrorResponse),
435    Status503(models::ErrorResponse),
436    Status5XX(models::ErrorResponse),
437    UnknownValue(serde_json::Value),
438}
439
440/// struct for typed errors of method [`merge_insert_into_table`]
441#[derive(Debug, Clone, Serialize, Deserialize)]
442#[serde(untagged)]
443pub enum MergeInsertIntoTableError {
444    Status400(models::ErrorResponse),
445    Status401(models::ErrorResponse),
446    Status403(models::ErrorResponse),
447    Status404(models::ErrorResponse),
448    Status503(models::ErrorResponse),
449    Status5XX(models::ErrorResponse),
450    UnknownValue(serde_json::Value),
451}
452
453/// struct for typed errors of method [`query_table`]
454#[derive(Debug, Clone, Serialize, Deserialize)]
455#[serde(untagged)]
456pub enum QueryTableError {
457    Status400(models::ErrorResponse),
458    Status401(models::ErrorResponse),
459    Status403(models::ErrorResponse),
460    Status404(models::ErrorResponse),
461    Status503(models::ErrorResponse),
462    Status5XX(models::ErrorResponse),
463    UnknownValue(serde_json::Value),
464}
465
466/// struct for typed errors of method [`register_table`]
467#[derive(Debug, Clone, Serialize, Deserialize)]
468#[serde(untagged)]
469pub enum RegisterTableError {
470    Status400(models::ErrorResponse),
471    Status401(models::ErrorResponse),
472    Status403(models::ErrorResponse),
473    Status404(models::ErrorResponse),
474    Status406(models::ErrorResponse),
475    Status409(models::ErrorResponse),
476    Status503(models::ErrorResponse),
477    Status5XX(models::ErrorResponse),
478    UnknownValue(serde_json::Value),
479}
480
481/// struct for typed errors of method [`rename_table`]
482#[derive(Debug, Clone, Serialize, Deserialize)]
483#[serde(untagged)]
484pub enum RenameTableError {
485    Status400(models::ErrorResponse),
486    Status401(models::ErrorResponse),
487    Status403(models::ErrorResponse),
488    Status404(models::ErrorResponse),
489    Status409(models::ErrorResponse),
490    Status503(models::ErrorResponse),
491    Status5XX(models::ErrorResponse),
492    UnknownValue(serde_json::Value),
493}
494
495/// struct for typed errors of method [`restore_table`]
496#[derive(Debug, Clone, Serialize, Deserialize)]
497#[serde(untagged)]
498pub enum RestoreTableError {
499    Status400(models::ErrorResponse),
500    Status401(models::ErrorResponse),
501    Status403(models::ErrorResponse),
502    Status404(models::ErrorResponse),
503    Status503(models::ErrorResponse),
504    Status5XX(models::ErrorResponse),
505    UnknownValue(serde_json::Value),
506}
507
508/// struct for typed errors of method [`table_exists`]
509#[derive(Debug, Clone, Serialize, Deserialize)]
510#[serde(untagged)]
511pub enum TableExistsError {
512    Status400(models::ErrorResponse),
513    Status401(models::ErrorResponse),
514    Status403(models::ErrorResponse),
515    Status404(models::ErrorResponse),
516    Status503(models::ErrorResponse),
517    Status5XX(models::ErrorResponse),
518    UnknownValue(serde_json::Value),
519}
520
521/// struct for typed errors of method [`update_table`]
522#[derive(Debug, Clone, Serialize, Deserialize)]
523#[serde(untagged)]
524pub enum UpdateTableError {
525    Status400(models::ErrorResponse),
526    Status401(models::ErrorResponse),
527    Status403(models::ErrorResponse),
528    Status404(models::ErrorResponse),
529    Status503(models::ErrorResponse),
530    Status5XX(models::ErrorResponse),
531    UnknownValue(serde_json::Value),
532}
533
534/// struct for typed errors of method [`update_table_schema_metadata`]
535#[derive(Debug, Clone, Serialize, Deserialize)]
536#[serde(untagged)]
537pub enum UpdateTableSchemaMetadataError {
538    Status400(models::ErrorResponse),
539    Status401(models::ErrorResponse),
540    Status403(models::ErrorResponse),
541    Status404(models::ErrorResponse),
542    Status503(models::ErrorResponse),
543    Status5XX(models::ErrorResponse),
544    UnknownValue(serde_json::Value),
545}
546
547/// struct for typed errors of method [`update_table_tag`]
548#[derive(Debug, Clone, Serialize, Deserialize)]
549#[serde(untagged)]
550pub enum UpdateTableTagError {
551    Status400(models::ErrorResponse),
552    Status401(models::ErrorResponse),
553    Status403(models::ErrorResponse),
554    Status404(models::ErrorResponse),
555    Status503(models::ErrorResponse),
556    Status5XX(models::ErrorResponse),
557    UnknownValue(serde_json::Value),
558}
559
560
561/// Add new columns to table `id` using SQL expressions or default values. 
562pub async fn alter_table_add_columns(configuration: &configuration::Configuration, id: &str, alter_table_add_columns_request: models::AlterTableAddColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableAddColumnsResponse, Error<AlterTableAddColumnsError>> {
563    // add a prefix to parameters to efficiently prevent name collisions
564    let p_id = id;
565    let p_alter_table_add_columns_request = alter_table_add_columns_request;
566    let p_delimiter = delimiter;
567
568    let uri_str = format!("{}/v1/table/{id}/add_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
569    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
570
571    if let Some(ref param_value) = p_delimiter {
572        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
573    }
574    if let Some(ref user_agent) = configuration.user_agent {
575        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
576    }
577    if let Some(ref token) = configuration.oauth_access_token {
578        req_builder = req_builder.bearer_auth(token.to_owned());
579    };
580    if let Some(ref apikey) = configuration.api_key {
581        let key = apikey.key.clone();
582        let value = match apikey.prefix {
583            Some(ref prefix) => format!("{} {}", prefix, key),
584            None => key,
585        };
586        req_builder = req_builder.header("x-api-key", value);
587    };
588    if let Some(ref token) = configuration.bearer_access_token {
589        req_builder = req_builder.bearer_auth(token.to_owned());
590    };
591    req_builder = req_builder.json(&p_alter_table_add_columns_request);
592
593    let req = req_builder.build()?;
594    let resp = configuration.client.execute(req).await?;
595
596    let status = resp.status();
597    let content_type = resp
598        .headers()
599        .get("content-type")
600        .and_then(|v| v.to_str().ok())
601        .unwrap_or("application/octet-stream");
602    let content_type = super::ContentType::from(content_type);
603
604    if !status.is_client_error() && !status.is_server_error() {
605        let content = resp.text().await?;
606        match content_type {
607            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
608            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableAddColumnsResponse`"))),
609            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableAddColumnsResponse`")))),
610        }
611    } else {
612        let content = resp.text().await?;
613        let entity: Option<AlterTableAddColumnsError> = serde_json::from_str(&content).ok();
614        Err(Error::ResponseError(ResponseContent { status, content, entity }))
615    }
616}
617
618/// Modify existing columns in table `id`, such as renaming or changing data types. 
619pub async fn alter_table_alter_columns(configuration: &configuration::Configuration, id: &str, alter_table_alter_columns_request: models::AlterTableAlterColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableAlterColumnsResponse, Error<AlterTableAlterColumnsError>> {
620    // add a prefix to parameters to efficiently prevent name collisions
621    let p_id = id;
622    let p_alter_table_alter_columns_request = alter_table_alter_columns_request;
623    let p_delimiter = delimiter;
624
625    let uri_str = format!("{}/v1/table/{id}/alter_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
626    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
627
628    if let Some(ref param_value) = p_delimiter {
629        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
630    }
631    if let Some(ref user_agent) = configuration.user_agent {
632        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
633    }
634    if let Some(ref token) = configuration.oauth_access_token {
635        req_builder = req_builder.bearer_auth(token.to_owned());
636    };
637    if let Some(ref apikey) = configuration.api_key {
638        let key = apikey.key.clone();
639        let value = match apikey.prefix {
640            Some(ref prefix) => format!("{} {}", prefix, key),
641            None => key,
642        };
643        req_builder = req_builder.header("x-api-key", value);
644    };
645    if let Some(ref token) = configuration.bearer_access_token {
646        req_builder = req_builder.bearer_auth(token.to_owned());
647    };
648    req_builder = req_builder.json(&p_alter_table_alter_columns_request);
649
650    let req = req_builder.build()?;
651    let resp = configuration.client.execute(req).await?;
652
653    let status = resp.status();
654    let content_type = resp
655        .headers()
656        .get("content-type")
657        .and_then(|v| v.to_str().ok())
658        .unwrap_or("application/octet-stream");
659    let content_type = super::ContentType::from(content_type);
660
661    if !status.is_client_error() && !status.is_server_error() {
662        let content = resp.text().await?;
663        match content_type {
664            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
665            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableAlterColumnsResponse`"))),
666            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableAlterColumnsResponse`")))),
667        }
668    } else {
669        let content = resp.text().await?;
670        let entity: Option<AlterTableAlterColumnsError> = serde_json::from_str(&content).ok();
671        Err(Error::ResponseError(ResponseContent { status, content, entity }))
672    }
673}
674
675/// Trigger an asynchronous backfill job for a computed column on table `id`. The column must be a virtual (UDF-backed) column. Returns a job ID for tracking. 
676pub async fn alter_table_backfill_columns(configuration: &configuration::Configuration, id: &str, alter_table_backfill_columns_request: models::AlterTableBackfillColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableBackfillColumnsResponse, Error<AlterTableBackfillColumnsError>> {
677    // add a prefix to parameters to efficiently prevent name collisions
678    let p_id = id;
679    let p_alter_table_backfill_columns_request = alter_table_backfill_columns_request;
680    let p_delimiter = delimiter;
681
682    let uri_str = format!("{}/v1/table/{id}/backfill_column", configuration.base_path, id=crate::apis::urlencode(p_id));
683    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
684
685    if let Some(ref param_value) = p_delimiter {
686        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
687    }
688    if let Some(ref user_agent) = configuration.user_agent {
689        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
690    }
691    if let Some(ref token) = configuration.oauth_access_token {
692        req_builder = req_builder.bearer_auth(token.to_owned());
693    };
694    if let Some(ref apikey) = configuration.api_key {
695        let key = apikey.key.clone();
696        let value = match apikey.prefix {
697            Some(ref prefix) => format!("{} {}", prefix, key),
698            None => key,
699        };
700        req_builder = req_builder.header("x-api-key", value);
701    };
702    if let Some(ref token) = configuration.bearer_access_token {
703        req_builder = req_builder.bearer_auth(token.to_owned());
704    };
705    req_builder = req_builder.json(&p_alter_table_backfill_columns_request);
706
707    let req = req_builder.build()?;
708    let resp = configuration.client.execute(req).await?;
709
710    let status = resp.status();
711    let content_type = resp
712        .headers()
713        .get("content-type")
714        .and_then(|v| v.to_str().ok())
715        .unwrap_or("application/octet-stream");
716    let content_type = super::ContentType::from(content_type);
717
718    if !status.is_client_error() && !status.is_server_error() {
719        let content = resp.text().await?;
720        match content_type {
721            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
722            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableBackfillColumnsResponse`"))),
723            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableBackfillColumnsResponse`")))),
724        }
725    } else {
726        let content = resp.text().await?;
727        let entity: Option<AlterTableBackfillColumnsError> = serde_json::from_str(&content).ok();
728        Err(Error::ResponseError(ResponseContent { status, content, entity }))
729    }
730}
731
732/// Remove specified columns from table `id`. 
733pub async fn alter_table_drop_columns(configuration: &configuration::Configuration, id: &str, alter_table_drop_columns_request: models::AlterTableDropColumnsRequest, delimiter: Option<&str>) -> Result<models::AlterTableDropColumnsResponse, Error<AlterTableDropColumnsError>> {
734    // add a prefix to parameters to efficiently prevent name collisions
735    let p_id = id;
736    let p_alter_table_drop_columns_request = alter_table_drop_columns_request;
737    let p_delimiter = delimiter;
738
739    let uri_str = format!("{}/v1/table/{id}/drop_columns", configuration.base_path, id=crate::apis::urlencode(p_id));
740    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
741
742    if let Some(ref param_value) = p_delimiter {
743        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
744    }
745    if let Some(ref user_agent) = configuration.user_agent {
746        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
747    }
748    if let Some(ref token) = configuration.oauth_access_token {
749        req_builder = req_builder.bearer_auth(token.to_owned());
750    };
751    if let Some(ref apikey) = configuration.api_key {
752        let key = apikey.key.clone();
753        let value = match apikey.prefix {
754            Some(ref prefix) => format!("{} {}", prefix, key),
755            None => key,
756        };
757        req_builder = req_builder.header("x-api-key", value);
758    };
759    if let Some(ref token) = configuration.bearer_access_token {
760        req_builder = req_builder.bearer_auth(token.to_owned());
761    };
762    req_builder = req_builder.json(&p_alter_table_drop_columns_request);
763
764    let req = req_builder.build()?;
765    let resp = configuration.client.execute(req).await?;
766
767    let status = resp.status();
768    let content_type = resp
769        .headers()
770        .get("content-type")
771        .and_then(|v| v.to_str().ok())
772        .unwrap_or("application/octet-stream");
773    let content_type = super::ContentType::from(content_type);
774
775    if !status.is_client_error() && !status.is_server_error() {
776        let content = resp.text().await?;
777        match content_type {
778            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
779            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AlterTableDropColumnsResponse`"))),
780            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AlterTableDropColumnsResponse`")))),
781        }
782    } else {
783        let content = resp.text().await?;
784        let entity: Option<AlterTableDropColumnsError> = serde_json::from_str(&content).ok();
785        Err(Error::ResponseError(ResponseContent { status, content, entity }))
786    }
787}
788
789/// Analyze the query execution plan for a query against table `id`. Returns detailed statistics and analysis of the query execution plan.  REST NAMESPACE ONLY REST namespace returns the response as a plain string instead of the `AnalyzeTableQueryPlanResponse` JSON object. 
790pub async fn analyze_table_query_plan(configuration: &configuration::Configuration, id: &str, analyze_table_query_plan_request: models::AnalyzeTableQueryPlanRequest, delimiter: Option<&str>) -> Result<String, Error<AnalyzeTableQueryPlanError>> {
791    // add a prefix to parameters to efficiently prevent name collisions
792    let p_id = id;
793    let p_analyze_table_query_plan_request = analyze_table_query_plan_request;
794    let p_delimiter = delimiter;
795
796    let uri_str = format!("{}/v1/table/{id}/analyze_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
797    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
798
799    if let Some(ref param_value) = p_delimiter {
800        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
801    }
802    if let Some(ref user_agent) = configuration.user_agent {
803        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
804    }
805    if let Some(ref token) = configuration.oauth_access_token {
806        req_builder = req_builder.bearer_auth(token.to_owned());
807    };
808    if let Some(ref apikey) = configuration.api_key {
809        let key = apikey.key.clone();
810        let value = match apikey.prefix {
811            Some(ref prefix) => format!("{} {}", prefix, key),
812            None => key,
813        };
814        req_builder = req_builder.header("x-api-key", value);
815    };
816    if let Some(ref token) = configuration.bearer_access_token {
817        req_builder = req_builder.bearer_auth(token.to_owned());
818    };
819    req_builder = req_builder.json(&p_analyze_table_query_plan_request);
820
821    let req = req_builder.build()?;
822    let resp = configuration.client.execute(req).await?;
823
824    let status = resp.status();
825    let content_type = resp
826        .headers()
827        .get("content-type")
828        .and_then(|v| v.to_str().ok())
829        .unwrap_or("application/octet-stream");
830    let content_type = super::ContentType::from(content_type);
831
832    if !status.is_client_error() && !status.is_server_error() {
833        let content = resp.text().await?;
834        match content_type {
835            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
836            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
837            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
838        }
839    } else {
840        let content = resp.text().await?;
841        let entity: Option<AnalyzeTableQueryPlanError> = serde_json::from_str(&content).ok();
842        Err(Error::ResponseError(ResponseContent { status, content, entity }))
843    }
844}
845
846/// Atomically commit a batch of table operations. This is a generalized version of `BatchCreateTableVersions` that supports mixed operation types within a single atomic transaction at the metadata layer.  Supported operation types: - `DeclareTable`: Declare (reserve) a new table - `CreateTableVersion`: Create a new version entry for a table - `DeleteTableVersions`: Delete version ranges from a table - `DeregisterTable`: Deregister (soft-delete) a table  All operations are committed atomically: either all succeed or none are applied. 
847pub async fn batch_commit_tables(configuration: &configuration::Configuration, batch_commit_tables_request: models::BatchCommitTablesRequest, delimiter: Option<&str>) -> Result<models::BatchCommitTablesResponse, Error<BatchCommitTablesError>> {
848    // add a prefix to parameters to efficiently prevent name collisions
849    let p_batch_commit_tables_request = batch_commit_tables_request;
850    let p_delimiter = delimiter;
851
852    let uri_str = format!("{}/v1/table/batch-commit", configuration.base_path);
853    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
854
855    if let Some(ref param_value) = p_delimiter {
856        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
857    }
858    if let Some(ref user_agent) = configuration.user_agent {
859        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
860    }
861    if let Some(ref token) = configuration.oauth_access_token {
862        req_builder = req_builder.bearer_auth(token.to_owned());
863    };
864    if let Some(ref apikey) = configuration.api_key {
865        let key = apikey.key.clone();
866        let value = match apikey.prefix {
867            Some(ref prefix) => format!("{} {}", prefix, key),
868            None => key,
869        };
870        req_builder = req_builder.header("x-api-key", value);
871    };
872    if let Some(ref token) = configuration.bearer_access_token {
873        req_builder = req_builder.bearer_auth(token.to_owned());
874    };
875    req_builder = req_builder.json(&p_batch_commit_tables_request);
876
877    let req = req_builder.build()?;
878    let resp = configuration.client.execute(req).await?;
879
880    let status = resp.status();
881    let content_type = resp
882        .headers()
883        .get("content-type")
884        .and_then(|v| v.to_str().ok())
885        .unwrap_or("application/octet-stream");
886    let content_type = super::ContentType::from(content_type);
887
888    if !status.is_client_error() && !status.is_server_error() {
889        let content = resp.text().await?;
890        match content_type {
891            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
892            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BatchCommitTablesResponse`"))),
893            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::BatchCommitTablesResponse`")))),
894        }
895    } else {
896        let content = resp.text().await?;
897        let entity: Option<BatchCommitTablesError> = serde_json::from_str(&content).ok();
898        Err(Error::ResponseError(ResponseContent { status, content, entity }))
899    }
900}
901
902/// Atomically create new version entries for multiple tables.  This operation is atomic: either all table versions are created successfully, or none are created. If any version creation fails (e.g., due to conflict), the entire batch operation fails.  Each entry in the request specifies the table identifier and version details. This supports `put_if_not_exists` semantics for each version entry. 
903pub async fn batch_create_table_versions(configuration: &configuration::Configuration, batch_create_table_versions_request: models::BatchCreateTableVersionsRequest, delimiter: Option<&str>) -> Result<models::BatchCreateTableVersionsResponse, Error<BatchCreateTableVersionsError>> {
904    // add a prefix to parameters to efficiently prevent name collisions
905    let p_batch_create_table_versions_request = batch_create_table_versions_request;
906    let p_delimiter = delimiter;
907
908    let uri_str = format!("{}/v1/table/version/batch-create", configuration.base_path);
909    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
910
911    if let Some(ref param_value) = p_delimiter {
912        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
913    }
914    if let Some(ref user_agent) = configuration.user_agent {
915        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
916    }
917    if let Some(ref token) = configuration.oauth_access_token {
918        req_builder = req_builder.bearer_auth(token.to_owned());
919    };
920    if let Some(ref apikey) = configuration.api_key {
921        let key = apikey.key.clone();
922        let value = match apikey.prefix {
923            Some(ref prefix) => format!("{} {}", prefix, key),
924            None => key,
925        };
926        req_builder = req_builder.header("x-api-key", value);
927    };
928    if let Some(ref token) = configuration.bearer_access_token {
929        req_builder = req_builder.bearer_auth(token.to_owned());
930    };
931    req_builder = req_builder.json(&p_batch_create_table_versions_request);
932
933    let req = req_builder.build()?;
934    let resp = configuration.client.execute(req).await?;
935
936    let status = resp.status();
937    let content_type = resp
938        .headers()
939        .get("content-type")
940        .and_then(|v| v.to_str().ok())
941        .unwrap_or("application/octet-stream");
942    let content_type = super::ContentType::from(content_type);
943
944    if !status.is_client_error() && !status.is_server_error() {
945        let content = resp.text().await?;
946        match content_type {
947            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
948            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BatchCreateTableVersionsResponse`"))),
949            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::BatchCreateTableVersionsResponse`")))),
950        }
951    } else {
952        let content = resp.text().await?;
953        let entity: Option<BatchCreateTableVersionsError> = serde_json::from_str(&content).ok();
954        Err(Error::ResponseError(ResponseContent { status, content, entity }))
955    }
956}
957
958/// Delete version metadata records for table `id`.  This operation deletes version tracking records, NOT the actual table data. It supports deleting ranges of versions for efficient bulk cleanup.  Special range values: - `start_version: 0` with `end_version: -1` means delete ALL version records 
959pub async fn batch_delete_table_versions(configuration: &configuration::Configuration, id: &str, batch_delete_table_versions_request: models::BatchDeleteTableVersionsRequest, delimiter: Option<&str>) -> Result<models::BatchDeleteTableVersionsResponse, Error<BatchDeleteTableVersionsError>> {
960    // add a prefix to parameters to efficiently prevent name collisions
961    let p_id = id;
962    let p_batch_delete_table_versions_request = batch_delete_table_versions_request;
963    let p_delimiter = delimiter;
964
965    let uri_str = format!("{}/v1/table/{id}/version/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
966    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
967
968    if let Some(ref param_value) = p_delimiter {
969        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
970    }
971    if let Some(ref user_agent) = configuration.user_agent {
972        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
973    }
974    if let Some(ref token) = configuration.oauth_access_token {
975        req_builder = req_builder.bearer_auth(token.to_owned());
976    };
977    if let Some(ref apikey) = configuration.api_key {
978        let key = apikey.key.clone();
979        let value = match apikey.prefix {
980            Some(ref prefix) => format!("{} {}", prefix, key),
981            None => key,
982        };
983        req_builder = req_builder.header("x-api-key", value);
984    };
985    if let Some(ref token) = configuration.bearer_access_token {
986        req_builder = req_builder.bearer_auth(token.to_owned());
987    };
988    req_builder = req_builder.json(&p_batch_delete_table_versions_request);
989
990    let req = req_builder.build()?;
991    let resp = configuration.client.execute(req).await?;
992
993    let status = resp.status();
994    let content_type = resp
995        .headers()
996        .get("content-type")
997        .and_then(|v| v.to_str().ok())
998        .unwrap_or("application/octet-stream");
999    let content_type = super::ContentType::from(content_type);
1000
1001    if !status.is_client_error() && !status.is_server_error() {
1002        let content = resp.text().await?;
1003        match content_type {
1004            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1005            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BatchDeleteTableVersionsResponse`"))),
1006            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::BatchDeleteTableVersionsResponse`")))),
1007        }
1008    } else {
1009        let content = resp.text().await?;
1010        let entity: Option<BatchDeleteTableVersionsError> = serde_json::from_str(&content).ok();
1011        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1012    }
1013}
1014
1015/// Count the number of rows in table `id`  REST NAMESPACE ONLY REST namespace returns the response as a plain integer instead of the `CountTableRowsResponse` JSON object. 
1016pub async fn count_table_rows(configuration: &configuration::Configuration, id: &str, count_table_rows_request: models::CountTableRowsRequest, delimiter: Option<&str>) -> Result<i64, Error<CountTableRowsError>> {
1017    // add a prefix to parameters to efficiently prevent name collisions
1018    let p_id = id;
1019    let p_count_table_rows_request = count_table_rows_request;
1020    let p_delimiter = delimiter;
1021
1022    let uri_str = format!("{}/v1/table/{id}/count_rows", configuration.base_path, id=crate::apis::urlencode(p_id));
1023    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1024
1025    if let Some(ref param_value) = p_delimiter {
1026        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1027    }
1028    if let Some(ref user_agent) = configuration.user_agent {
1029        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1030    }
1031    if let Some(ref token) = configuration.oauth_access_token {
1032        req_builder = req_builder.bearer_auth(token.to_owned());
1033    };
1034    if let Some(ref apikey) = configuration.api_key {
1035        let key = apikey.key.clone();
1036        let value = match apikey.prefix {
1037            Some(ref prefix) => format!("{} {}", prefix, key),
1038            None => key,
1039        };
1040        req_builder = req_builder.header("x-api-key", value);
1041    };
1042    if let Some(ref token) = configuration.bearer_access_token {
1043        req_builder = req_builder.bearer_auth(token.to_owned());
1044    };
1045    req_builder = req_builder.json(&p_count_table_rows_request);
1046
1047    let req = req_builder.build()?;
1048    let resp = configuration.client.execute(req).await?;
1049
1050    let status = resp.status();
1051    let content_type = resp
1052        .headers()
1053        .get("content-type")
1054        .and_then(|v| v.to_str().ok())
1055        .unwrap_or("application/octet-stream");
1056    let content_type = super::ContentType::from(content_type);
1057
1058    if !status.is_client_error() && !status.is_server_error() {
1059        let content = resp.text().await?;
1060        match content_type {
1061            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1062            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `i64`"))),
1063            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `i64`")))),
1064        }
1065    } else {
1066        let content = resp.text().await?;
1067        let entity: Option<CountTableRowsError> = serde_json::from_str(&content).ok();
1068        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1069    }
1070}
1071
1072/// Create table `id` in the namespace with the given data in Arrow IPC stream.  The schema of the Arrow IPC stream is used as the table schema. If the stream is empty, the API creates a new empty table.  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `CreateTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `mode`: pass through query parameter of the same name - `properties`: serialize as a single JSON-encoded query parameter such as   `properties={\"user\":\"alice\",\"team\":\"eng\"}`; these are business logic properties   managed by the namespace implementation outside Lance context - `storage_options`: serialize as a single JSON-encoded query parameter such as   `storage_options={\"aws_region\":\"us-east-1\",\"timeout\":\"30s\"}`; these configure   write-time overrides for data and metadata written during table creation 
1073pub async fn create_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, mode: Option<&str>, properties: Option<&str>, storage_options: Option<&str>) -> Result<models::CreateTableResponse, Error<CreateTableError>> {
1074    // add a prefix to parameters to efficiently prevent name collisions
1075    let p_id = id;
1076    let p_body = body;
1077    let p_delimiter = delimiter;
1078    let p_mode = mode;
1079    let p_properties = properties;
1080    let p_storage_options = storage_options;
1081
1082    let uri_str = format!("{}/v1/table/{id}/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1083    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1084
1085    if let Some(ref param_value) = p_delimiter {
1086        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1087    }
1088    if let Some(ref param_value) = p_mode {
1089        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
1090    }
1091    if let Some(ref param_value) = p_properties {
1092        req_builder = req_builder.query(&[("properties", &param_value.to_string())]);
1093    }
1094    if let Some(ref param_value) = p_storage_options {
1095        req_builder = req_builder.query(&[("storage_options", &param_value.to_string())]);
1096    }
1097    if let Some(ref user_agent) = configuration.user_agent {
1098        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1099    }
1100    if let Some(ref token) = configuration.oauth_access_token {
1101        req_builder = req_builder.bearer_auth(token.to_owned());
1102    };
1103    if let Some(ref apikey) = configuration.api_key {
1104        let key = apikey.key.clone();
1105        let value = match apikey.prefix {
1106            Some(ref prefix) => format!("{} {}", prefix, key),
1107            None => key,
1108        };
1109        req_builder = req_builder.header("x-api-key", value);
1110    };
1111    if let Some(ref token) = configuration.bearer_access_token {
1112        req_builder = req_builder.bearer_auth(token.to_owned());
1113    };
1114    req_builder = req_builder.body(p_body);
1115
1116    let req = req_builder.build()?;
1117    let resp = configuration.client.execute(req).await?;
1118
1119    let status = resp.status();
1120    let content_type = resp
1121        .headers()
1122        .get("content-type")
1123        .and_then(|v| v.to_str().ok())
1124        .unwrap_or("application/octet-stream");
1125    let content_type = super::ContentType::from(content_type);
1126
1127    if !status.is_client_error() && !status.is_server_error() {
1128        let content = resp.text().await?;
1129        match content_type {
1130            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1131            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableResponse`"))),
1132            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableResponse`")))),
1133        }
1134    } else {
1135        let content = resp.text().await?;
1136        let entity: Option<CreateTableError> = serde_json::from_str(&content).ok();
1137        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1138    }
1139}
1140
1141/// Create an index on a table column for faster search operations. Supports vector indexes (IVF_FLAT, IVF_HNSW_SQ, IVF_PQ, etc.) and scalar indexes (BTREE, BITMAP, FTS, etc.). Index creation is handled asynchronously. Use the `ListTableIndices` and `DescribeTableIndexStats` operations to monitor index creation progress. 
1142pub async fn create_table_index(configuration: &configuration::Configuration, id: &str, create_table_index_request: models::CreateTableIndexRequest, delimiter: Option<&str>) -> Result<models::CreateTableIndexResponse, Error<CreateTableIndexError>> {
1143    // add a prefix to parameters to efficiently prevent name collisions
1144    let p_id = id;
1145    let p_create_table_index_request = create_table_index_request;
1146    let p_delimiter = delimiter;
1147
1148    let uri_str = format!("{}/v1/table/{id}/create_index", configuration.base_path, id=crate::apis::urlencode(p_id));
1149    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1150
1151    if let Some(ref param_value) = p_delimiter {
1152        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1153    }
1154    if let Some(ref user_agent) = configuration.user_agent {
1155        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1156    }
1157    if let Some(ref token) = configuration.oauth_access_token {
1158        req_builder = req_builder.bearer_auth(token.to_owned());
1159    };
1160    if let Some(ref apikey) = configuration.api_key {
1161        let key = apikey.key.clone();
1162        let value = match apikey.prefix {
1163            Some(ref prefix) => format!("{} {}", prefix, key),
1164            None => key,
1165        };
1166        req_builder = req_builder.header("x-api-key", value);
1167    };
1168    if let Some(ref token) = configuration.bearer_access_token {
1169        req_builder = req_builder.bearer_auth(token.to_owned());
1170    };
1171    req_builder = req_builder.json(&p_create_table_index_request);
1172
1173    let req = req_builder.build()?;
1174    let resp = configuration.client.execute(req).await?;
1175
1176    let status = resp.status();
1177    let content_type = resp
1178        .headers()
1179        .get("content-type")
1180        .and_then(|v| v.to_str().ok())
1181        .unwrap_or("application/octet-stream");
1182    let content_type = super::ContentType::from(content_type);
1183
1184    if !status.is_client_error() && !status.is_server_error() {
1185        let content = resp.text().await?;
1186        match content_type {
1187            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1188            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableIndexResponse`"))),
1189            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableIndexResponse`")))),
1190        }
1191    } else {
1192        let content = resp.text().await?;
1193        let entity: Option<CreateTableIndexError> = serde_json::from_str(&content).ok();
1194        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1195    }
1196}
1197
1198/// Create a scalar index on a table column for faster filtering operations. Supports scalar indexes (BTREE, BITMAP, LABEL_LIST, FTS, etc.). This is an alias for CreateTableIndex specifically for scalar indexes. Index creation is handled asynchronously. Use the `ListTableIndices` and `DescribeTableIndexStats` operations to monitor index creation progress. 
1199pub async fn create_table_scalar_index(configuration: &configuration::Configuration, id: &str, create_table_index_request: models::CreateTableIndexRequest, delimiter: Option<&str>) -> Result<models::CreateTableScalarIndexResponse, Error<CreateTableScalarIndexError>> {
1200    // add a prefix to parameters to efficiently prevent name collisions
1201    let p_id = id;
1202    let p_create_table_index_request = create_table_index_request;
1203    let p_delimiter = delimiter;
1204
1205    let uri_str = format!("{}/v1/table/{id}/create_scalar_index", configuration.base_path, id=crate::apis::urlencode(p_id));
1206    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1207
1208    if let Some(ref param_value) = p_delimiter {
1209        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1210    }
1211    if let Some(ref user_agent) = configuration.user_agent {
1212        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1213    }
1214    if let Some(ref token) = configuration.oauth_access_token {
1215        req_builder = req_builder.bearer_auth(token.to_owned());
1216    };
1217    if let Some(ref apikey) = configuration.api_key {
1218        let key = apikey.key.clone();
1219        let value = match apikey.prefix {
1220            Some(ref prefix) => format!("{} {}", prefix, key),
1221            None => key,
1222        };
1223        req_builder = req_builder.header("x-api-key", value);
1224    };
1225    if let Some(ref token) = configuration.bearer_access_token {
1226        req_builder = req_builder.bearer_auth(token.to_owned());
1227    };
1228    req_builder = req_builder.json(&p_create_table_index_request);
1229
1230    let req = req_builder.build()?;
1231    let resp = configuration.client.execute(req).await?;
1232
1233    let status = resp.status();
1234    let content_type = resp
1235        .headers()
1236        .get("content-type")
1237        .and_then(|v| v.to_str().ok())
1238        .unwrap_or("application/octet-stream");
1239    let content_type = super::ContentType::from(content_type);
1240
1241    if !status.is_client_error() && !status.is_server_error() {
1242        let content = resp.text().await?;
1243        match content_type {
1244            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1245            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableScalarIndexResponse`"))),
1246            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableScalarIndexResponse`")))),
1247        }
1248    } else {
1249        let content = resp.text().await?;
1250        let entity: Option<CreateTableScalarIndexError> = serde_json::from_str(&content).ok();
1251        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1252    }
1253}
1254
1255/// Create a new tag for table `id` that points to a specific version. 
1256pub async fn create_table_tag(configuration: &configuration::Configuration, id: &str, create_table_tag_request: models::CreateTableTagRequest, delimiter: Option<&str>) -> Result<models::CreateTableTagResponse, Error<CreateTableTagError>> {
1257    // add a prefix to parameters to efficiently prevent name collisions
1258    let p_id = id;
1259    let p_create_table_tag_request = create_table_tag_request;
1260    let p_delimiter = delimiter;
1261
1262    let uri_str = format!("{}/v1/table/{id}/tags/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1263    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1264
1265    if let Some(ref param_value) = p_delimiter {
1266        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1267    }
1268    if let Some(ref user_agent) = configuration.user_agent {
1269        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1270    }
1271    if let Some(ref token) = configuration.oauth_access_token {
1272        req_builder = req_builder.bearer_auth(token.to_owned());
1273    };
1274    if let Some(ref apikey) = configuration.api_key {
1275        let key = apikey.key.clone();
1276        let value = match apikey.prefix {
1277            Some(ref prefix) => format!("{} {}", prefix, key),
1278            None => key,
1279        };
1280        req_builder = req_builder.header("x-api-key", value);
1281    };
1282    if let Some(ref token) = configuration.bearer_access_token {
1283        req_builder = req_builder.bearer_auth(token.to_owned());
1284    };
1285    req_builder = req_builder.json(&p_create_table_tag_request);
1286
1287    let req = req_builder.build()?;
1288    let resp = configuration.client.execute(req).await?;
1289
1290    let status = resp.status();
1291    let content_type = resp
1292        .headers()
1293        .get("content-type")
1294        .and_then(|v| v.to_str().ok())
1295        .unwrap_or("application/octet-stream");
1296    let content_type = super::ContentType::from(content_type);
1297
1298    if !status.is_client_error() && !status.is_server_error() {
1299        let content = resp.text().await?;
1300        match content_type {
1301            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1302            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableTagResponse`"))),
1303            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableTagResponse`")))),
1304        }
1305    } else {
1306        let content = resp.text().await?;
1307        let entity: Option<CreateTableTagError> = serde_json::from_str(&content).ok();
1308        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1309    }
1310}
1311
1312/// Create a new version entry for table `id`.  This operation supports `put_if_not_exists` semantics. The operation will fail with 409 Conflict if the version already exists. 
1313pub async fn create_table_version(configuration: &configuration::Configuration, id: &str, create_table_version_request: models::CreateTableVersionRequest, delimiter: Option<&str>) -> Result<models::CreateTableVersionResponse, Error<CreateTableVersionError>> {
1314    // add a prefix to parameters to efficiently prevent name collisions
1315    let p_id = id;
1316    let p_create_table_version_request = create_table_version_request;
1317    let p_delimiter = delimiter;
1318
1319    let uri_str = format!("{}/v1/table/{id}/version/create", configuration.base_path, id=crate::apis::urlencode(p_id));
1320    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1321
1322    if let Some(ref param_value) = p_delimiter {
1323        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1324    }
1325    if let Some(ref user_agent) = configuration.user_agent {
1326        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1327    }
1328    if let Some(ref token) = configuration.oauth_access_token {
1329        req_builder = req_builder.bearer_auth(token.to_owned());
1330    };
1331    if let Some(ref apikey) = configuration.api_key {
1332        let key = apikey.key.clone();
1333        let value = match apikey.prefix {
1334            Some(ref prefix) => format!("{} {}", prefix, key),
1335            None => key,
1336        };
1337        req_builder = req_builder.header("x-api-key", value);
1338    };
1339    if let Some(ref token) = configuration.bearer_access_token {
1340        req_builder = req_builder.bearer_auth(token.to_owned());
1341    };
1342    req_builder = req_builder.json(&p_create_table_version_request);
1343
1344    let req = req_builder.build()?;
1345    let resp = configuration.client.execute(req).await?;
1346
1347    let status = resp.status();
1348    let content_type = resp
1349        .headers()
1350        .get("content-type")
1351        .and_then(|v| v.to_str().ok())
1352        .unwrap_or("application/octet-stream");
1353    let content_type = super::ContentType::from(content_type);
1354
1355    if !status.is_client_error() && !status.is_server_error() {
1356        let content = resp.text().await?;
1357        match content_type {
1358            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1359            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTableVersionResponse`"))),
1360            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTableVersionResponse`")))),
1361        }
1362    } else {
1363        let content = resp.text().await?;
1364        let entity: Option<CreateTableVersionError> = serde_json::from_str(&content).ok();
1365        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1366    }
1367}
1368
1369/// Declare a table with the given name without touching storage. This is a metadata-only operation that records the table existence and sets up aspects like access control.  For DirectoryNamespace implementation, this creates a `.lance-reserved` file in the table directory to mark the table's existence without creating actual Lance data files. 
1370pub async fn declare_table(configuration: &configuration::Configuration, id: &str, declare_table_request: models::DeclareTableRequest, delimiter: Option<&str>) -> Result<models::DeclareTableResponse, Error<DeclareTableError>> {
1371    // add a prefix to parameters to efficiently prevent name collisions
1372    let p_id = id;
1373    let p_declare_table_request = declare_table_request;
1374    let p_delimiter = delimiter;
1375
1376    let uri_str = format!("{}/v1/table/{id}/declare", configuration.base_path, id=crate::apis::urlencode(p_id));
1377    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1378
1379    if let Some(ref param_value) = p_delimiter {
1380        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1381    }
1382    if let Some(ref user_agent) = configuration.user_agent {
1383        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1384    }
1385    if let Some(ref token) = configuration.oauth_access_token {
1386        req_builder = req_builder.bearer_auth(token.to_owned());
1387    };
1388    if let Some(ref apikey) = configuration.api_key {
1389        let key = apikey.key.clone();
1390        let value = match apikey.prefix {
1391            Some(ref prefix) => format!("{} {}", prefix, key),
1392            None => key,
1393        };
1394        req_builder = req_builder.header("x-api-key", value);
1395    };
1396    if let Some(ref token) = configuration.bearer_access_token {
1397        req_builder = req_builder.bearer_auth(token.to_owned());
1398    };
1399    req_builder = req_builder.json(&p_declare_table_request);
1400
1401    let req = req_builder.build()?;
1402    let resp = configuration.client.execute(req).await?;
1403
1404    let status = resp.status();
1405    let content_type = resp
1406        .headers()
1407        .get("content-type")
1408        .and_then(|v| v.to_str().ok())
1409        .unwrap_or("application/octet-stream");
1410    let content_type = super::ContentType::from(content_type);
1411
1412    if !status.is_client_error() && !status.is_server_error() {
1413        let content = resp.text().await?;
1414        match content_type {
1415            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1416            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeclareTableResponse`"))),
1417            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeclareTableResponse`")))),
1418        }
1419    } else {
1420        let content = resp.text().await?;
1421        let entity: Option<DeclareTableError> = serde_json::from_str(&content).ok();
1422        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1423    }
1424}
1425
1426/// Delete rows from table `id`. 
1427pub async fn delete_from_table(configuration: &configuration::Configuration, id: &str, delete_from_table_request: models::DeleteFromTableRequest, delimiter: Option<&str>) -> Result<models::DeleteFromTableResponse, Error<DeleteFromTableError>> {
1428    // add a prefix to parameters to efficiently prevent name collisions
1429    let p_id = id;
1430    let p_delete_from_table_request = delete_from_table_request;
1431    let p_delimiter = delimiter;
1432
1433    let uri_str = format!("{}/v1/table/{id}/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
1434    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1435
1436    if let Some(ref param_value) = p_delimiter {
1437        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1438    }
1439    if let Some(ref user_agent) = configuration.user_agent {
1440        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1441    }
1442    if let Some(ref token) = configuration.oauth_access_token {
1443        req_builder = req_builder.bearer_auth(token.to_owned());
1444    };
1445    if let Some(ref apikey) = configuration.api_key {
1446        let key = apikey.key.clone();
1447        let value = match apikey.prefix {
1448            Some(ref prefix) => format!("{} {}", prefix, key),
1449            None => key,
1450        };
1451        req_builder = req_builder.header("x-api-key", value);
1452    };
1453    if let Some(ref token) = configuration.bearer_access_token {
1454        req_builder = req_builder.bearer_auth(token.to_owned());
1455    };
1456    req_builder = req_builder.json(&p_delete_from_table_request);
1457
1458    let req = req_builder.build()?;
1459    let resp = configuration.client.execute(req).await?;
1460
1461    let status = resp.status();
1462    let content_type = resp
1463        .headers()
1464        .get("content-type")
1465        .and_then(|v| v.to_str().ok())
1466        .unwrap_or("application/octet-stream");
1467    let content_type = super::ContentType::from(content_type);
1468
1469    if !status.is_client_error() && !status.is_server_error() {
1470        let content = resp.text().await?;
1471        match content_type {
1472            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1473            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteFromTableResponse`"))),
1474            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteFromTableResponse`")))),
1475        }
1476    } else {
1477        let content = resp.text().await?;
1478        let entity: Option<DeleteFromTableError> = serde_json::from_str(&content).ok();
1479        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1480    }
1481}
1482
1483/// Delete an existing tag from table `id`. 
1484pub async fn delete_table_tag(configuration: &configuration::Configuration, id: &str, delete_table_tag_request: models::DeleteTableTagRequest, delimiter: Option<&str>) -> Result<models::DeleteTableTagResponse, Error<DeleteTableTagError>> {
1485    // add a prefix to parameters to efficiently prevent name collisions
1486    let p_id = id;
1487    let p_delete_table_tag_request = delete_table_tag_request;
1488    let p_delimiter = delimiter;
1489
1490    let uri_str = format!("{}/v1/table/{id}/tags/delete", configuration.base_path, id=crate::apis::urlencode(p_id));
1491    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1492
1493    if let Some(ref param_value) = p_delimiter {
1494        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1495    }
1496    if let Some(ref user_agent) = configuration.user_agent {
1497        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1498    }
1499    if let Some(ref token) = configuration.oauth_access_token {
1500        req_builder = req_builder.bearer_auth(token.to_owned());
1501    };
1502    if let Some(ref apikey) = configuration.api_key {
1503        let key = apikey.key.clone();
1504        let value = match apikey.prefix {
1505            Some(ref prefix) => format!("{} {}", prefix, key),
1506            None => key,
1507        };
1508        req_builder = req_builder.header("x-api-key", value);
1509    };
1510    if let Some(ref token) = configuration.bearer_access_token {
1511        req_builder = req_builder.bearer_auth(token.to_owned());
1512    };
1513    req_builder = req_builder.json(&p_delete_table_tag_request);
1514
1515    let req = req_builder.build()?;
1516    let resp = configuration.client.execute(req).await?;
1517
1518    let status = resp.status();
1519    let content_type = resp
1520        .headers()
1521        .get("content-type")
1522        .and_then(|v| v.to_str().ok())
1523        .unwrap_or("application/octet-stream");
1524    let content_type = super::ContentType::from(content_type);
1525
1526    if !status.is_client_error() && !status.is_server_error() {
1527        let content = resp.text().await?;
1528        match content_type {
1529            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1530            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteTableTagResponse`"))),
1531            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteTableTagResponse`")))),
1532        }
1533    } else {
1534        let content = resp.text().await?;
1535        let entity: Option<DeleteTableTagError> = serde_json::from_str(&content).ok();
1536        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1537    }
1538}
1539
1540/// Deregister table `id` from its namespace. 
1541pub async fn deregister_table(configuration: &configuration::Configuration, id: &str, deregister_table_request: models::DeregisterTableRequest, delimiter: Option<&str>) -> Result<models::DeregisterTableResponse, Error<DeregisterTableError>> {
1542    // add a prefix to parameters to efficiently prevent name collisions
1543    let p_id = id;
1544    let p_deregister_table_request = deregister_table_request;
1545    let p_delimiter = delimiter;
1546
1547    let uri_str = format!("{}/v1/table/{id}/deregister", configuration.base_path, id=crate::apis::urlencode(p_id));
1548    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1549
1550    if let Some(ref param_value) = p_delimiter {
1551        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1552    }
1553    if let Some(ref user_agent) = configuration.user_agent {
1554        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1555    }
1556    if let Some(ref token) = configuration.oauth_access_token {
1557        req_builder = req_builder.bearer_auth(token.to_owned());
1558    };
1559    if let Some(ref apikey) = configuration.api_key {
1560        let key = apikey.key.clone();
1561        let value = match apikey.prefix {
1562            Some(ref prefix) => format!("{} {}", prefix, key),
1563            None => key,
1564        };
1565        req_builder = req_builder.header("x-api-key", value);
1566    };
1567    if let Some(ref token) = configuration.bearer_access_token {
1568        req_builder = req_builder.bearer_auth(token.to_owned());
1569    };
1570    req_builder = req_builder.json(&p_deregister_table_request);
1571
1572    let req = req_builder.build()?;
1573    let resp = configuration.client.execute(req).await?;
1574
1575    let status = resp.status();
1576    let content_type = resp
1577        .headers()
1578        .get("content-type")
1579        .and_then(|v| v.to_str().ok())
1580        .unwrap_or("application/octet-stream");
1581    let content_type = super::ContentType::from(content_type);
1582
1583    if !status.is_client_error() && !status.is_server_error() {
1584        let content = resp.text().await?;
1585        match content_type {
1586            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1587            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeregisterTableResponse`"))),
1588            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeregisterTableResponse`")))),
1589        }
1590    } else {
1591        let content = resp.text().await?;
1592        let entity: Option<DeregisterTableError> = serde_json::from_str(&content).ok();
1593        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1594    }
1595}
1596
1597/// Describe the detailed information for table `id`.  REST NAMESPACE ONLY REST namespace passes `with_table_uri`, `load_detailed_metadata`, and `check_declared` as query parameters instead of in the request body. 
1598pub async fn describe_table(configuration: &configuration::Configuration, id: &str, describe_table_request: models::DescribeTableRequest, delimiter: Option<&str>, with_table_uri: Option<bool>, load_detailed_metadata: Option<bool>, check_declared: Option<bool>) -> Result<models::DescribeTableResponse, Error<DescribeTableError>> {
1599    // add a prefix to parameters to efficiently prevent name collisions
1600    let p_id = id;
1601    let p_describe_table_request = describe_table_request;
1602    let p_delimiter = delimiter;
1603    let p_with_table_uri = with_table_uri;
1604    let p_load_detailed_metadata = load_detailed_metadata;
1605    let p_check_declared = check_declared;
1606
1607    let uri_str = format!("{}/v1/table/{id}/describe", configuration.base_path, id=crate::apis::urlencode(p_id));
1608    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1609
1610    if let Some(ref param_value) = p_delimiter {
1611        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1612    }
1613    if let Some(ref param_value) = p_with_table_uri {
1614        req_builder = req_builder.query(&[("with_table_uri", &param_value.to_string())]);
1615    }
1616    if let Some(ref param_value) = p_load_detailed_metadata {
1617        req_builder = req_builder.query(&[("load_detailed_metadata", &param_value.to_string())]);
1618    }
1619    if let Some(ref param_value) = p_check_declared {
1620        req_builder = req_builder.query(&[("check_declared", &param_value.to_string())]);
1621    }
1622    if let Some(ref user_agent) = configuration.user_agent {
1623        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1624    }
1625    if let Some(ref token) = configuration.oauth_access_token {
1626        req_builder = req_builder.bearer_auth(token.to_owned());
1627    };
1628    if let Some(ref apikey) = configuration.api_key {
1629        let key = apikey.key.clone();
1630        let value = match apikey.prefix {
1631            Some(ref prefix) => format!("{} {}", prefix, key),
1632            None => key,
1633        };
1634        req_builder = req_builder.header("x-api-key", value);
1635    };
1636    if let Some(ref token) = configuration.bearer_access_token {
1637        req_builder = req_builder.bearer_auth(token.to_owned());
1638    };
1639    req_builder = req_builder.json(&p_describe_table_request);
1640
1641    let req = req_builder.build()?;
1642    let resp = configuration.client.execute(req).await?;
1643
1644    let status = resp.status();
1645    let content_type = resp
1646        .headers()
1647        .get("content-type")
1648        .and_then(|v| v.to_str().ok())
1649        .unwrap_or("application/octet-stream");
1650    let content_type = super::ContentType::from(content_type);
1651
1652    if !status.is_client_error() && !status.is_server_error() {
1653        let content = resp.text().await?;
1654        match content_type {
1655            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1656            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableResponse`"))),
1657            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DescribeTableResponse`")))),
1658        }
1659    } else {
1660        let content = resp.text().await?;
1661        let entity: Option<DescribeTableError> = serde_json::from_str(&content).ok();
1662        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1663    }
1664}
1665
1666/// Get statistics for a specific index on a table. Returns information about the index type, distance type (for vector indices), and row counts. 
1667pub async fn describe_table_index_stats(configuration: &configuration::Configuration, id: &str, index_name: &str, describe_table_index_stats_request: models::DescribeTableIndexStatsRequest, delimiter: Option<&str>) -> Result<models::DescribeTableIndexStatsResponse, Error<DescribeTableIndexStatsError>> {
1668    // add a prefix to parameters to efficiently prevent name collisions
1669    let p_id = id;
1670    let p_index_name = index_name;
1671    let p_describe_table_index_stats_request = describe_table_index_stats_request;
1672    let p_delimiter = delimiter;
1673
1674    let uri_str = format!("{}/v1/table/{id}/index/{index_name}/stats", configuration.base_path, id=crate::apis::urlencode(p_id), index_name=crate::apis::urlencode(p_index_name));
1675    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1676
1677    if let Some(ref param_value) = p_delimiter {
1678        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1679    }
1680    if let Some(ref user_agent) = configuration.user_agent {
1681        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1682    }
1683    if let Some(ref token) = configuration.oauth_access_token {
1684        req_builder = req_builder.bearer_auth(token.to_owned());
1685    };
1686    if let Some(ref apikey) = configuration.api_key {
1687        let key = apikey.key.clone();
1688        let value = match apikey.prefix {
1689            Some(ref prefix) => format!("{} {}", prefix, key),
1690            None => key,
1691        };
1692        req_builder = req_builder.header("x-api-key", value);
1693    };
1694    if let Some(ref token) = configuration.bearer_access_token {
1695        req_builder = req_builder.bearer_auth(token.to_owned());
1696    };
1697    req_builder = req_builder.json(&p_describe_table_index_stats_request);
1698
1699    let req = req_builder.build()?;
1700    let resp = configuration.client.execute(req).await?;
1701
1702    let status = resp.status();
1703    let content_type = resp
1704        .headers()
1705        .get("content-type")
1706        .and_then(|v| v.to_str().ok())
1707        .unwrap_or("application/octet-stream");
1708    let content_type = super::ContentType::from(content_type);
1709
1710    if !status.is_client_error() && !status.is_server_error() {
1711        let content = resp.text().await?;
1712        match content_type {
1713            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1714            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableIndexStatsResponse`"))),
1715            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DescribeTableIndexStatsResponse`")))),
1716        }
1717    } else {
1718        let content = resp.text().await?;
1719        let entity: Option<DescribeTableIndexStatsError> = serde_json::from_str(&content).ok();
1720        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1721    }
1722}
1723
1724/// Describe the detailed information for a specific version of table `id`.  Returns the manifest path and metadata for the specified version. 
1725pub async fn describe_table_version(configuration: &configuration::Configuration, id: &str, describe_table_version_request: models::DescribeTableVersionRequest, delimiter: Option<&str>) -> Result<models::DescribeTableVersionResponse, Error<DescribeTableVersionError>> {
1726    // add a prefix to parameters to efficiently prevent name collisions
1727    let p_id = id;
1728    let p_describe_table_version_request = describe_table_version_request;
1729    let p_delimiter = delimiter;
1730
1731    let uri_str = format!("{}/v1/table/{id}/version/describe", configuration.base_path, id=crate::apis::urlencode(p_id));
1732    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1733
1734    if let Some(ref param_value) = p_delimiter {
1735        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1736    }
1737    if let Some(ref user_agent) = configuration.user_agent {
1738        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1739    }
1740    if let Some(ref token) = configuration.oauth_access_token {
1741        req_builder = req_builder.bearer_auth(token.to_owned());
1742    };
1743    if let Some(ref apikey) = configuration.api_key {
1744        let key = apikey.key.clone();
1745        let value = match apikey.prefix {
1746            Some(ref prefix) => format!("{} {}", prefix, key),
1747            None => key,
1748        };
1749        req_builder = req_builder.header("x-api-key", value);
1750    };
1751    if let Some(ref token) = configuration.bearer_access_token {
1752        req_builder = req_builder.bearer_auth(token.to_owned());
1753    };
1754    req_builder = req_builder.json(&p_describe_table_version_request);
1755
1756    let req = req_builder.build()?;
1757    let resp = configuration.client.execute(req).await?;
1758
1759    let status = resp.status();
1760    let content_type = resp
1761        .headers()
1762        .get("content-type")
1763        .and_then(|v| v.to_str().ok())
1764        .unwrap_or("application/octet-stream");
1765    let content_type = super::ContentType::from(content_type);
1766
1767    if !status.is_client_error() && !status.is_server_error() {
1768        let content = resp.text().await?;
1769        match content_type {
1770            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1771            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeTableVersionResponse`"))),
1772            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DescribeTableVersionResponse`")))),
1773        }
1774    } else {
1775        let content = resp.text().await?;
1776        let entity: Option<DescribeTableVersionError> = serde_json::from_str(&content).ok();
1777        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1778    }
1779}
1780
1781/// Drop table `id` and delete its data.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `DropTableRequest` information is passed in the following way: - `id`: pass through path parameter of the same name 
1782pub async fn drop_table(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>) -> Result<models::DropTableResponse, Error<DropTableError>> {
1783    // add a prefix to parameters to efficiently prevent name collisions
1784    let p_id = id;
1785    let p_delimiter = delimiter;
1786
1787    let uri_str = format!("{}/v1/table/{id}/drop", configuration.base_path, id=crate::apis::urlencode(p_id));
1788    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1789
1790    if let Some(ref param_value) = p_delimiter {
1791        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1792    }
1793    if let Some(ref user_agent) = configuration.user_agent {
1794        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1795    }
1796    if let Some(ref token) = configuration.oauth_access_token {
1797        req_builder = req_builder.bearer_auth(token.to_owned());
1798    };
1799    if let Some(ref apikey) = configuration.api_key {
1800        let key = apikey.key.clone();
1801        let value = match apikey.prefix {
1802            Some(ref prefix) => format!("{} {}", prefix, key),
1803            None => key,
1804        };
1805        req_builder = req_builder.header("x-api-key", value);
1806    };
1807    if let Some(ref token) = configuration.bearer_access_token {
1808        req_builder = req_builder.bearer_auth(token.to_owned());
1809    };
1810
1811    let req = req_builder.build()?;
1812    let resp = configuration.client.execute(req).await?;
1813
1814    let status = resp.status();
1815    let content_type = resp
1816        .headers()
1817        .get("content-type")
1818        .and_then(|v| v.to_str().ok())
1819        .unwrap_or("application/octet-stream");
1820    let content_type = super::ContentType::from(content_type);
1821
1822    if !status.is_client_error() && !status.is_server_error() {
1823        let content = resp.text().await?;
1824        match content_type {
1825            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1826            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DropTableResponse`"))),
1827            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DropTableResponse`")))),
1828        }
1829    } else {
1830        let content = resp.text().await?;
1831        let entity: Option<DropTableError> = serde_json::from_str(&content).ok();
1832        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1833    }
1834}
1835
1836/// Drop the specified index from table `id`.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `DropTableIndexRequest` information is passed in the following way: - `id`: pass through path parameter of the same name - `index_name`: pass through path parameter of the same name 
1837pub async fn drop_table_index(configuration: &configuration::Configuration, id: &str, index_name: &str, delimiter: Option<&str>) -> Result<models::DropTableIndexResponse, Error<DropTableIndexError>> {
1838    // add a prefix to parameters to efficiently prevent name collisions
1839    let p_id = id;
1840    let p_index_name = index_name;
1841    let p_delimiter = delimiter;
1842
1843    let uri_str = format!("{}/v1/table/{id}/index/{index_name}/drop", configuration.base_path, id=crate::apis::urlencode(p_id), index_name=crate::apis::urlencode(p_index_name));
1844    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1845
1846    if let Some(ref param_value) = p_delimiter {
1847        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1848    }
1849    if let Some(ref user_agent) = configuration.user_agent {
1850        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1851    }
1852    if let Some(ref token) = configuration.oauth_access_token {
1853        req_builder = req_builder.bearer_auth(token.to_owned());
1854    };
1855    if let Some(ref apikey) = configuration.api_key {
1856        let key = apikey.key.clone();
1857        let value = match apikey.prefix {
1858            Some(ref prefix) => format!("{} {}", prefix, key),
1859            None => key,
1860        };
1861        req_builder = req_builder.header("x-api-key", value);
1862    };
1863    if let Some(ref token) = configuration.bearer_access_token {
1864        req_builder = req_builder.bearer_auth(token.to_owned());
1865    };
1866
1867    let req = req_builder.build()?;
1868    let resp = configuration.client.execute(req).await?;
1869
1870    let status = resp.status();
1871    let content_type = resp
1872        .headers()
1873        .get("content-type")
1874        .and_then(|v| v.to_str().ok())
1875        .unwrap_or("application/octet-stream");
1876    let content_type = super::ContentType::from(content_type);
1877
1878    if !status.is_client_error() && !status.is_server_error() {
1879        let content = resp.text().await?;
1880        match content_type {
1881            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1882            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DropTableIndexResponse`"))),
1883            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DropTableIndexResponse`")))),
1884        }
1885    } else {
1886        let content = resp.text().await?;
1887        let entity: Option<DropTableIndexError> = serde_json::from_str(&content).ok();
1888        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1889    }
1890}
1891
1892/// Get the query execution plan for a query against table `id`. Returns a human-readable explanation of how the query will be executed.  REST NAMESPACE ONLY REST namespace returns the response as a plain string instead of the `ExplainTableQueryPlanResponse` JSON object. 
1893pub async fn explain_table_query_plan(configuration: &configuration::Configuration, id: &str, explain_table_query_plan_request: models::ExplainTableQueryPlanRequest, delimiter: Option<&str>) -> Result<String, Error<ExplainTableQueryPlanError>> {
1894    // add a prefix to parameters to efficiently prevent name collisions
1895    let p_id = id;
1896    let p_explain_table_query_plan_request = explain_table_query_plan_request;
1897    let p_delimiter = delimiter;
1898
1899    let uri_str = format!("{}/v1/table/{id}/explain_plan", configuration.base_path, id=crate::apis::urlencode(p_id));
1900    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1901
1902    if let Some(ref param_value) = p_delimiter {
1903        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1904    }
1905    if let Some(ref user_agent) = configuration.user_agent {
1906        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1907    }
1908    if let Some(ref token) = configuration.oauth_access_token {
1909        req_builder = req_builder.bearer_auth(token.to_owned());
1910    };
1911    if let Some(ref apikey) = configuration.api_key {
1912        let key = apikey.key.clone();
1913        let value = match apikey.prefix {
1914            Some(ref prefix) => format!("{} {}", prefix, key),
1915            None => key,
1916        };
1917        req_builder = req_builder.header("x-api-key", value);
1918    };
1919    if let Some(ref token) = configuration.bearer_access_token {
1920        req_builder = req_builder.bearer_auth(token.to_owned());
1921    };
1922    req_builder = req_builder.json(&p_explain_table_query_plan_request);
1923
1924    let req = req_builder.build()?;
1925    let resp = configuration.client.execute(req).await?;
1926
1927    let status = resp.status();
1928    let content_type = resp
1929        .headers()
1930        .get("content-type")
1931        .and_then(|v| v.to_str().ok())
1932        .unwrap_or("application/octet-stream");
1933    let content_type = super::ContentType::from(content_type);
1934
1935    if !status.is_client_error() && !status.is_server_error() {
1936        let content = resp.text().await?;
1937        match content_type {
1938            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1939            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `String`"))),
1940            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
1941        }
1942    } else {
1943        let content = resp.text().await?;
1944        let entity: Option<ExplainTableQueryPlanError> = serde_json::from_str(&content).ok();
1945        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1946    }
1947}
1948
1949/// Get statistics for table `id`, including row counts, data sizes, and column statistics. 
1950pub async fn get_table_stats(configuration: &configuration::Configuration, id: &str, get_table_stats_request: models::GetTableStatsRequest, delimiter: Option<&str>) -> Result<models::GetTableStatsResponse, Error<GetTableStatsError>> {
1951    // add a prefix to parameters to efficiently prevent name collisions
1952    let p_id = id;
1953    let p_get_table_stats_request = get_table_stats_request;
1954    let p_delimiter = delimiter;
1955
1956    let uri_str = format!("{}/v1/table/{id}/stats", configuration.base_path, id=crate::apis::urlencode(p_id));
1957    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1958
1959    if let Some(ref param_value) = p_delimiter {
1960        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
1961    }
1962    if let Some(ref user_agent) = configuration.user_agent {
1963        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1964    }
1965    if let Some(ref token) = configuration.oauth_access_token {
1966        req_builder = req_builder.bearer_auth(token.to_owned());
1967    };
1968    if let Some(ref apikey) = configuration.api_key {
1969        let key = apikey.key.clone();
1970        let value = match apikey.prefix {
1971            Some(ref prefix) => format!("{} {}", prefix, key),
1972            None => key,
1973        };
1974        req_builder = req_builder.header("x-api-key", value);
1975    };
1976    if let Some(ref token) = configuration.bearer_access_token {
1977        req_builder = req_builder.bearer_auth(token.to_owned());
1978    };
1979    req_builder = req_builder.json(&p_get_table_stats_request);
1980
1981    let req = req_builder.build()?;
1982    let resp = configuration.client.execute(req).await?;
1983
1984    let status = resp.status();
1985    let content_type = resp
1986        .headers()
1987        .get("content-type")
1988        .and_then(|v| v.to_str().ok())
1989        .unwrap_or("application/octet-stream");
1990    let content_type = super::ContentType::from(content_type);
1991
1992    if !status.is_client_error() && !status.is_server_error() {
1993        let content = resp.text().await?;
1994        match content_type {
1995            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1996            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetTableStatsResponse`"))),
1997            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetTableStatsResponse`")))),
1998        }
1999    } else {
2000        let content = resp.text().await?;
2001        let entity: Option<GetTableStatsError> = serde_json::from_str(&content).ok();
2002        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2003    }
2004}
2005
2006/// Get the version number that a specific tag points to for table `id`. 
2007pub async fn get_table_tag_version(configuration: &configuration::Configuration, id: &str, get_table_tag_version_request: models::GetTableTagVersionRequest, delimiter: Option<&str>) -> Result<models::GetTableTagVersionResponse, Error<GetTableTagVersionError>> {
2008    // add a prefix to parameters to efficiently prevent name collisions
2009    let p_id = id;
2010    let p_get_table_tag_version_request = get_table_tag_version_request;
2011    let p_delimiter = delimiter;
2012
2013    let uri_str = format!("{}/v1/table/{id}/tags/version", configuration.base_path, id=crate::apis::urlencode(p_id));
2014    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2015
2016    if let Some(ref param_value) = p_delimiter {
2017        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2018    }
2019    if let Some(ref user_agent) = configuration.user_agent {
2020        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2021    }
2022    if let Some(ref token) = configuration.oauth_access_token {
2023        req_builder = req_builder.bearer_auth(token.to_owned());
2024    };
2025    if let Some(ref apikey) = configuration.api_key {
2026        let key = apikey.key.clone();
2027        let value = match apikey.prefix {
2028            Some(ref prefix) => format!("{} {}", prefix, key),
2029            None => key,
2030        };
2031        req_builder = req_builder.header("x-api-key", value);
2032    };
2033    if let Some(ref token) = configuration.bearer_access_token {
2034        req_builder = req_builder.bearer_auth(token.to_owned());
2035    };
2036    req_builder = req_builder.json(&p_get_table_tag_version_request);
2037
2038    let req = req_builder.build()?;
2039    let resp = configuration.client.execute(req).await?;
2040
2041    let status = resp.status();
2042    let content_type = resp
2043        .headers()
2044        .get("content-type")
2045        .and_then(|v| v.to_str().ok())
2046        .unwrap_or("application/octet-stream");
2047    let content_type = super::ContentType::from(content_type);
2048
2049    if !status.is_client_error() && !status.is_server_error() {
2050        let content = resp.text().await?;
2051        match content_type {
2052            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2053            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetTableTagVersionResponse`"))),
2054            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetTableTagVersionResponse`")))),
2055        }
2056    } else {
2057        let content = resp.text().await?;
2058        let entity: Option<GetTableTagVersionError> = serde_json::from_str(&content).ok();
2059        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2060    }
2061}
2062
2063/// Insert new records into table `id`.  For tables that have been declared but not yet created on storage (is_only_declared=true), this operation will create the table with the provided data.  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `InsertIntoTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `mode`: pass through query parameter of the same name 
2064pub async fn insert_into_table(configuration: &configuration::Configuration, id: &str, body: Vec<u8>, delimiter: Option<&str>, mode: Option<&str>) -> Result<models::InsertIntoTableResponse, Error<InsertIntoTableError>> {
2065    // add a prefix to parameters to efficiently prevent name collisions
2066    let p_id = id;
2067    let p_body = body;
2068    let p_delimiter = delimiter;
2069    let p_mode = mode;
2070
2071    let uri_str = format!("{}/v1/table/{id}/insert", configuration.base_path, id=crate::apis::urlencode(p_id));
2072    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2073
2074    if let Some(ref param_value) = p_delimiter {
2075        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2076    }
2077    if let Some(ref param_value) = p_mode {
2078        req_builder = req_builder.query(&[("mode", &param_value.to_string())]);
2079    }
2080    if let Some(ref user_agent) = configuration.user_agent {
2081        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2082    }
2083    if let Some(ref token) = configuration.oauth_access_token {
2084        req_builder = req_builder.bearer_auth(token.to_owned());
2085    };
2086    if let Some(ref apikey) = configuration.api_key {
2087        let key = apikey.key.clone();
2088        let value = match apikey.prefix {
2089            Some(ref prefix) => format!("{} {}", prefix, key),
2090            None => key,
2091        };
2092        req_builder = req_builder.header("x-api-key", value);
2093    };
2094    if let Some(ref token) = configuration.bearer_access_token {
2095        req_builder = req_builder.bearer_auth(token.to_owned());
2096    };
2097    req_builder = req_builder.body(p_body);
2098
2099    let req = req_builder.build()?;
2100    let resp = configuration.client.execute(req).await?;
2101
2102    let status = resp.status();
2103    let content_type = resp
2104        .headers()
2105        .get("content-type")
2106        .and_then(|v| v.to_str().ok())
2107        .unwrap_or("application/octet-stream");
2108    let content_type = super::ContentType::from(content_type);
2109
2110    if !status.is_client_error() && !status.is_server_error() {
2111        let content = resp.text().await?;
2112        match content_type {
2113            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2114            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::InsertIntoTableResponse`"))),
2115            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::InsertIntoTableResponse`")))),
2116        }
2117    } else {
2118        let content = resp.text().await?;
2119        let entity: Option<InsertIntoTableError> = serde_json::from_str(&content).ok();
2120        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2121    }
2122}
2123
2124/// List all tables across all namespaces.  REST NAMESPACE ONLY REST namespace uses GET to perform this operation without a request body. It passes in the `ListAllTablesRequest` information in the following way: - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name - `delimiter`: pass through query parameter of the same name - `include_declared`: pass through query parameter of the same name 
2125pub async fn list_all_tables(configuration: &configuration::Configuration, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>, include_declared: Option<bool>) -> Result<models::ListTablesResponse, Error<ListAllTablesError>> {
2126    // add a prefix to parameters to efficiently prevent name collisions
2127    let p_delimiter = delimiter;
2128    let p_page_token = page_token;
2129    let p_limit = limit;
2130    let p_include_declared = include_declared;
2131
2132    let uri_str = format!("{}/v1/table", configuration.base_path);
2133    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2134
2135    if let Some(ref param_value) = p_delimiter {
2136        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2137    }
2138    if let Some(ref param_value) = p_page_token {
2139        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2140    }
2141    if let Some(ref param_value) = p_limit {
2142        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2143    }
2144    if let Some(ref param_value) = p_include_declared {
2145        req_builder = req_builder.query(&[("include_declared", &param_value.to_string())]);
2146    }
2147    if let Some(ref user_agent) = configuration.user_agent {
2148        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2149    }
2150    if let Some(ref token) = configuration.oauth_access_token {
2151        req_builder = req_builder.bearer_auth(token.to_owned());
2152    };
2153    if let Some(ref apikey) = configuration.api_key {
2154        let key = apikey.key.clone();
2155        let value = match apikey.prefix {
2156            Some(ref prefix) => format!("{} {}", prefix, key),
2157            None => key,
2158        };
2159        req_builder = req_builder.header("x-api-key", value);
2160    };
2161    if let Some(ref token) = configuration.bearer_access_token {
2162        req_builder = req_builder.bearer_auth(token.to_owned());
2163    };
2164
2165    let req = req_builder.build()?;
2166    let resp = configuration.client.execute(req).await?;
2167
2168    let status = resp.status();
2169    let content_type = resp
2170        .headers()
2171        .get("content-type")
2172        .and_then(|v| v.to_str().ok())
2173        .unwrap_or("application/octet-stream");
2174    let content_type = super::ContentType::from(content_type);
2175
2176    if !status.is_client_error() && !status.is_server_error() {
2177        let content = resp.text().await?;
2178        match content_type {
2179            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2180            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTablesResponse`"))),
2181            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTablesResponse`")))),
2182        }
2183    } else {
2184        let content = resp.text().await?;
2185        let entity: Option<ListAllTablesError> = serde_json::from_str(&content).ok();
2186        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2187    }
2188}
2189
2190/// List all indices created on a table. Returns information about each index including name, columns, status, and UUID. 
2191pub async fn list_table_indices(configuration: &configuration::Configuration, id: &str, list_table_indices_request: models::ListTableIndicesRequest, delimiter: Option<&str>) -> Result<models::ListTableIndicesResponse, Error<ListTableIndicesError>> {
2192    // add a prefix to parameters to efficiently prevent name collisions
2193    let p_id = id;
2194    let p_list_table_indices_request = list_table_indices_request;
2195    let p_delimiter = delimiter;
2196
2197    let uri_str = format!("{}/v1/table/{id}/index/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2198    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2199
2200    if let Some(ref param_value) = p_delimiter {
2201        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2202    }
2203    if let Some(ref user_agent) = configuration.user_agent {
2204        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2205    }
2206    if let Some(ref token) = configuration.oauth_access_token {
2207        req_builder = req_builder.bearer_auth(token.to_owned());
2208    };
2209    if let Some(ref apikey) = configuration.api_key {
2210        let key = apikey.key.clone();
2211        let value = match apikey.prefix {
2212            Some(ref prefix) => format!("{} {}", prefix, key),
2213            None => key,
2214        };
2215        req_builder = req_builder.header("x-api-key", value);
2216    };
2217    if let Some(ref token) = configuration.bearer_access_token {
2218        req_builder = req_builder.bearer_auth(token.to_owned());
2219    };
2220    req_builder = req_builder.json(&p_list_table_indices_request);
2221
2222    let req = req_builder.build()?;
2223    let resp = configuration.client.execute(req).await?;
2224
2225    let status = resp.status();
2226    let content_type = resp
2227        .headers()
2228        .get("content-type")
2229        .and_then(|v| v.to_str().ok())
2230        .unwrap_or("application/octet-stream");
2231    let content_type = super::ContentType::from(content_type);
2232
2233    if !status.is_client_error() && !status.is_server_error() {
2234        let content = resp.text().await?;
2235        match content_type {
2236            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2237            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableIndicesResponse`"))),
2238            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTableIndicesResponse`")))),
2239        }
2240    } else {
2241        let content = resp.text().await?;
2242        let entity: Option<ListTableIndicesError> = serde_json::from_str(&content).ok();
2243        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2244    }
2245}
2246
2247/// List all tags that have been created for table `id`. Returns a map of tag names to their corresponding version numbers and metadata.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `ListTableTagsRequest` information is passed in the following way: - `id`: pass through path parameter of the same name - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name 
2248pub async fn list_table_tags(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>) -> Result<models::ListTableTagsResponse, Error<ListTableTagsError>> {
2249    // add a prefix to parameters to efficiently prevent name collisions
2250    let p_id = id;
2251    let p_delimiter = delimiter;
2252    let p_page_token = page_token;
2253    let p_limit = limit;
2254
2255    let uri_str = format!("{}/v1/table/{id}/tags/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2256    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2257
2258    if let Some(ref param_value) = p_delimiter {
2259        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2260    }
2261    if let Some(ref param_value) = p_page_token {
2262        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2263    }
2264    if let Some(ref param_value) = p_limit {
2265        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2266    }
2267    if let Some(ref user_agent) = configuration.user_agent {
2268        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2269    }
2270    if let Some(ref token) = configuration.oauth_access_token {
2271        req_builder = req_builder.bearer_auth(token.to_owned());
2272    };
2273    if let Some(ref apikey) = configuration.api_key {
2274        let key = apikey.key.clone();
2275        let value = match apikey.prefix {
2276            Some(ref prefix) => format!("{} {}", prefix, key),
2277            None => key,
2278        };
2279        req_builder = req_builder.header("x-api-key", value);
2280    };
2281    if let Some(ref token) = configuration.bearer_access_token {
2282        req_builder = req_builder.bearer_auth(token.to_owned());
2283    };
2284
2285    let req = req_builder.build()?;
2286    let resp = configuration.client.execute(req).await?;
2287
2288    let status = resp.status();
2289    let content_type = resp
2290        .headers()
2291        .get("content-type")
2292        .and_then(|v| v.to_str().ok())
2293        .unwrap_or("application/octet-stream");
2294    let content_type = super::ContentType::from(content_type);
2295
2296    if !status.is_client_error() && !status.is_server_error() {
2297        let content = resp.text().await?;
2298        match content_type {
2299            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2300            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableTagsResponse`"))),
2301            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTableTagsResponse`")))),
2302        }
2303    } else {
2304        let content = resp.text().await?;
2305        let entity: Option<ListTableTagsError> = serde_json::from_str(&content).ok();
2306        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2307    }
2308}
2309
2310/// List all versions (commits) of table `id` with their metadata.  Use `descending=true` to guarantee versions are returned in descending order (latest to oldest). Otherwise, the ordering is implementation-defined.  REST NAMESPACE ONLY REST namespace does not use a request body for this operation. The `ListTableVersionsRequest` information is passed in the following way: - `id`: pass through path parameter of the same name - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name - `descending`: pass through query parameter of the same name 
2311pub async fn list_table_versions(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>, descending: Option<bool>) -> Result<models::ListTableVersionsResponse, Error<ListTableVersionsError>> {
2312    // add a prefix to parameters to efficiently prevent name collisions
2313    let p_id = id;
2314    let p_delimiter = delimiter;
2315    let p_page_token = page_token;
2316    let p_limit = limit;
2317    let p_descending = descending;
2318
2319    let uri_str = format!("{}/v1/table/{id}/version/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2320    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2321
2322    if let Some(ref param_value) = p_delimiter {
2323        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2324    }
2325    if let Some(ref param_value) = p_page_token {
2326        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2327    }
2328    if let Some(ref param_value) = p_limit {
2329        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2330    }
2331    if let Some(ref param_value) = p_descending {
2332        req_builder = req_builder.query(&[("descending", &param_value.to_string())]);
2333    }
2334    if let Some(ref user_agent) = configuration.user_agent {
2335        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2336    }
2337    if let Some(ref token) = configuration.oauth_access_token {
2338        req_builder = req_builder.bearer_auth(token.to_owned());
2339    };
2340    if let Some(ref apikey) = configuration.api_key {
2341        let key = apikey.key.clone();
2342        let value = match apikey.prefix {
2343            Some(ref prefix) => format!("{} {}", prefix, key),
2344            None => key,
2345        };
2346        req_builder = req_builder.header("x-api-key", value);
2347    };
2348    if let Some(ref token) = configuration.bearer_access_token {
2349        req_builder = req_builder.bearer_auth(token.to_owned());
2350    };
2351
2352    let req = req_builder.build()?;
2353    let resp = configuration.client.execute(req).await?;
2354
2355    let status = resp.status();
2356    let content_type = resp
2357        .headers()
2358        .get("content-type")
2359        .and_then(|v| v.to_str().ok())
2360        .unwrap_or("application/octet-stream");
2361    let content_type = super::ContentType::from(content_type);
2362
2363    if !status.is_client_error() && !status.is_server_error() {
2364        let content = resp.text().await?;
2365        match content_type {
2366            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2367            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTableVersionsResponse`"))),
2368            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTableVersionsResponse`")))),
2369        }
2370    } else {
2371        let content = resp.text().await?;
2372        let entity: Option<ListTableVersionsError> = serde_json::from_str(&content).ok();
2373        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2374    }
2375}
2376
2377/// List all child table names of the parent namespace `id`.  REST NAMESPACE ONLY REST namespace uses GET to perform this operation without a request body. It passes in the `ListTablesRequest` information in the following way: - `id`: pass through path parameter of the same name - `page_token`: pass through query parameter of the same name - `limit`: pass through query parameter of the same name - `include_declared`: pass through query parameter of the same name 
2378pub async fn list_tables(configuration: &configuration::Configuration, id: &str, delimiter: Option<&str>, page_token: Option<&str>, limit: Option<i32>, include_declared: Option<bool>) -> Result<models::ListTablesResponse, Error<ListTablesError>> {
2379    // add a prefix to parameters to efficiently prevent name collisions
2380    let p_id = id;
2381    let p_delimiter = delimiter;
2382    let p_page_token = page_token;
2383    let p_limit = limit;
2384    let p_include_declared = include_declared;
2385
2386    let uri_str = format!("{}/v1/namespace/{id}/table/list", configuration.base_path, id=crate::apis::urlencode(p_id));
2387    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2388
2389    if let Some(ref param_value) = p_delimiter {
2390        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2391    }
2392    if let Some(ref param_value) = p_page_token {
2393        req_builder = req_builder.query(&[("page_token", &param_value.to_string())]);
2394    }
2395    if let Some(ref param_value) = p_limit {
2396        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
2397    }
2398    if let Some(ref param_value) = p_include_declared {
2399        req_builder = req_builder.query(&[("include_declared", &param_value.to_string())]);
2400    }
2401    if let Some(ref user_agent) = configuration.user_agent {
2402        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2403    }
2404    if let Some(ref token) = configuration.oauth_access_token {
2405        req_builder = req_builder.bearer_auth(token.to_owned());
2406    };
2407    if let Some(ref apikey) = configuration.api_key {
2408        let key = apikey.key.clone();
2409        let value = match apikey.prefix {
2410            Some(ref prefix) => format!("{} {}", prefix, key),
2411            None => key,
2412        };
2413        req_builder = req_builder.header("x-api-key", value);
2414    };
2415    if let Some(ref token) = configuration.bearer_access_token {
2416        req_builder = req_builder.bearer_auth(token.to_owned());
2417    };
2418
2419    let req = req_builder.build()?;
2420    let resp = configuration.client.execute(req).await?;
2421
2422    let status = resp.status();
2423    let content_type = resp
2424        .headers()
2425        .get("content-type")
2426        .and_then(|v| v.to_str().ok())
2427        .unwrap_or("application/octet-stream");
2428    let content_type = super::ContentType::from(content_type);
2429
2430    if !status.is_client_error() && !status.is_server_error() {
2431        let content = resp.text().await?;
2432        match content_type {
2433            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2434            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTablesResponse`"))),
2435            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTablesResponse`")))),
2436        }
2437    } else {
2438        let content = resp.text().await?;
2439        let entity: Option<ListTablesError> = serde_json::from_str(&content).ok();
2440        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2441    }
2442}
2443
2444/// Performs a merge insert (upsert) operation on table `id`. This operation updates existing rows based on a matching column and inserts new rows that don't match. It returns the number of rows inserted and updated.  For tables that have been declared but not yet created on storage (is_only_declared=true), this operation will create the table with the provided data (since there are no existing rows to merge with).  REST NAMESPACE ONLY REST namespace uses Arrow IPC stream as the request body. It passes in the `MergeInsertIntoTableRequest` information in the following way: - `id`: pass through path parameter of the same name - `on`: pass through query parameter of the same name - `when_matched_update_all`: pass through query parameter of the same name - `when_matched_update_all_filt`: pass through query parameter of the same name - `when_not_matched_insert_all`: pass through query parameter of the same name - `when_not_matched_by_source_delete`: pass through query parameter of the same name - `when_not_matched_by_source_delete_filt`: pass through query parameter of the same name 
2445pub async fn merge_insert_into_table(configuration: &configuration::Configuration, id: &str, on: &str, body: Vec<u8>, delimiter: Option<&str>, when_matched_update_all: Option<bool>, when_matched_update_all_filt: Option<&str>, when_not_matched_insert_all: Option<bool>, when_not_matched_by_source_delete: Option<bool>, when_not_matched_by_source_delete_filt: Option<&str>, timeout: Option<&str>, use_index: Option<bool>) -> Result<models::MergeInsertIntoTableResponse, Error<MergeInsertIntoTableError>> {
2446    // add a prefix to parameters to efficiently prevent name collisions
2447    let p_id = id;
2448    let p_on = on;
2449    let p_body = body;
2450    let p_delimiter = delimiter;
2451    let p_when_matched_update_all = when_matched_update_all;
2452    let p_when_matched_update_all_filt = when_matched_update_all_filt;
2453    let p_when_not_matched_insert_all = when_not_matched_insert_all;
2454    let p_when_not_matched_by_source_delete = when_not_matched_by_source_delete;
2455    let p_when_not_matched_by_source_delete_filt = when_not_matched_by_source_delete_filt;
2456    let p_timeout = timeout;
2457    let p_use_index = use_index;
2458
2459    let uri_str = format!("{}/v1/table/{id}/merge_insert", configuration.base_path, id=crate::apis::urlencode(p_id));
2460    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2461
2462    if let Some(ref param_value) = p_delimiter {
2463        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2464    }
2465    req_builder = req_builder.query(&[("on", &p_on.to_string())]);
2466    if let Some(ref param_value) = p_when_matched_update_all {
2467        req_builder = req_builder.query(&[("when_matched_update_all", &param_value.to_string())]);
2468    }
2469    if let Some(ref param_value) = p_when_matched_update_all_filt {
2470        req_builder = req_builder.query(&[("when_matched_update_all_filt", &param_value.to_string())]);
2471    }
2472    if let Some(ref param_value) = p_when_not_matched_insert_all {
2473        req_builder = req_builder.query(&[("when_not_matched_insert_all", &param_value.to_string())]);
2474    }
2475    if let Some(ref param_value) = p_when_not_matched_by_source_delete {
2476        req_builder = req_builder.query(&[("when_not_matched_by_source_delete", &param_value.to_string())]);
2477    }
2478    if let Some(ref param_value) = p_when_not_matched_by_source_delete_filt {
2479        req_builder = req_builder.query(&[("when_not_matched_by_source_delete_filt", &param_value.to_string())]);
2480    }
2481    if let Some(ref param_value) = p_timeout {
2482        req_builder = req_builder.query(&[("timeout", &param_value.to_string())]);
2483    }
2484    if let Some(ref param_value) = p_use_index {
2485        req_builder = req_builder.query(&[("use_index", &param_value.to_string())]);
2486    }
2487    if let Some(ref user_agent) = configuration.user_agent {
2488        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2489    }
2490    if let Some(ref token) = configuration.oauth_access_token {
2491        req_builder = req_builder.bearer_auth(token.to_owned());
2492    };
2493    if let Some(ref apikey) = configuration.api_key {
2494        let key = apikey.key.clone();
2495        let value = match apikey.prefix {
2496            Some(ref prefix) => format!("{} {}", prefix, key),
2497            None => key,
2498        };
2499        req_builder = req_builder.header("x-api-key", value);
2500    };
2501    if let Some(ref token) = configuration.bearer_access_token {
2502        req_builder = req_builder.bearer_auth(token.to_owned());
2503    };
2504    req_builder = req_builder.body(p_body);
2505
2506    let req = req_builder.build()?;
2507    let resp = configuration.client.execute(req).await?;
2508
2509    let status = resp.status();
2510    let content_type = resp
2511        .headers()
2512        .get("content-type")
2513        .and_then(|v| v.to_str().ok())
2514        .unwrap_or("application/octet-stream");
2515    let content_type = super::ContentType::from(content_type);
2516
2517    if !status.is_client_error() && !status.is_server_error() {
2518        let content = resp.text().await?;
2519        match content_type {
2520            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2521            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MergeInsertIntoTableResponse`"))),
2522            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::MergeInsertIntoTableResponse`")))),
2523        }
2524    } else {
2525        let content = resp.text().await?;
2526        let entity: Option<MergeInsertIntoTableError> = serde_json::from_str(&content).ok();
2527        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2528    }
2529}
2530
2531/// Query table `id` with vector search, full text search and optional SQL filtering. Returns results in Arrow IPC file or stream format.  REST NAMESPACE ONLY REST namespace returns the response as Arrow IPC file binary data instead of the `QueryTableResponse` JSON object. 
2532pub async fn query_table(configuration: &configuration::Configuration, id: &str, query_table_request: models::QueryTableRequest, delimiter: Option<&str>) -> Result<reqwest::Response, Error<QueryTableError>> {
2533    // add a prefix to parameters to efficiently prevent name collisions
2534    let p_id = id;
2535    let p_query_table_request = query_table_request;
2536    let p_delimiter = delimiter;
2537
2538    let uri_str = format!("{}/v1/table/{id}/query", configuration.base_path, id=crate::apis::urlencode(p_id));
2539    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2540
2541    if let Some(ref param_value) = p_delimiter {
2542        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2543    }
2544    if let Some(ref user_agent) = configuration.user_agent {
2545        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2546    }
2547    if let Some(ref token) = configuration.oauth_access_token {
2548        req_builder = req_builder.bearer_auth(token.to_owned());
2549    };
2550    if let Some(ref apikey) = configuration.api_key {
2551        let key = apikey.key.clone();
2552        let value = match apikey.prefix {
2553            Some(ref prefix) => format!("{} {}", prefix, key),
2554            None => key,
2555        };
2556        req_builder = req_builder.header("x-api-key", value);
2557    };
2558    if let Some(ref token) = configuration.bearer_access_token {
2559        req_builder = req_builder.bearer_auth(token.to_owned());
2560    };
2561    req_builder = req_builder.json(&p_query_table_request);
2562
2563    let req = req_builder.build()?;
2564    let resp = configuration.client.execute(req).await?;
2565
2566    let status = resp.status();
2567
2568    if !status.is_client_error() && !status.is_server_error() {
2569        Ok(resp)
2570    } else {
2571        let content = resp.text().await?;
2572        let entity: Option<QueryTableError> = serde_json::from_str(&content).ok();
2573        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2574    }
2575}
2576
2577/// Register an existing table at a given storage location as `id`. 
2578pub async fn register_table(configuration: &configuration::Configuration, id: &str, register_table_request: models::RegisterTableRequest, delimiter: Option<&str>) -> Result<models::RegisterTableResponse, Error<RegisterTableError>> {
2579    // add a prefix to parameters to efficiently prevent name collisions
2580    let p_id = id;
2581    let p_register_table_request = register_table_request;
2582    let p_delimiter = delimiter;
2583
2584    let uri_str = format!("{}/v1/table/{id}/register", configuration.base_path, id=crate::apis::urlencode(p_id));
2585    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2586
2587    if let Some(ref param_value) = p_delimiter {
2588        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2589    }
2590    if let Some(ref user_agent) = configuration.user_agent {
2591        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2592    }
2593    if let Some(ref token) = configuration.oauth_access_token {
2594        req_builder = req_builder.bearer_auth(token.to_owned());
2595    };
2596    if let Some(ref apikey) = configuration.api_key {
2597        let key = apikey.key.clone();
2598        let value = match apikey.prefix {
2599            Some(ref prefix) => format!("{} {}", prefix, key),
2600            None => key,
2601        };
2602        req_builder = req_builder.header("x-api-key", value);
2603    };
2604    if let Some(ref token) = configuration.bearer_access_token {
2605        req_builder = req_builder.bearer_auth(token.to_owned());
2606    };
2607    req_builder = req_builder.json(&p_register_table_request);
2608
2609    let req = req_builder.build()?;
2610    let resp = configuration.client.execute(req).await?;
2611
2612    let status = resp.status();
2613    let content_type = resp
2614        .headers()
2615        .get("content-type")
2616        .and_then(|v| v.to_str().ok())
2617        .unwrap_or("application/octet-stream");
2618    let content_type = super::ContentType::from(content_type);
2619
2620    if !status.is_client_error() && !status.is_server_error() {
2621        let content = resp.text().await?;
2622        match content_type {
2623            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2624            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RegisterTableResponse`"))),
2625            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RegisterTableResponse`")))),
2626        }
2627    } else {
2628        let content = resp.text().await?;
2629        let entity: Option<RegisterTableError> = serde_json::from_str(&content).ok();
2630        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2631    }
2632}
2633
2634/// Rename table `id` to a new name. 
2635pub async fn rename_table(configuration: &configuration::Configuration, id: &str, rename_table_request: models::RenameTableRequest, delimiter: Option<&str>) -> Result<models::RenameTableResponse, Error<RenameTableError>> {
2636    // add a prefix to parameters to efficiently prevent name collisions
2637    let p_id = id;
2638    let p_rename_table_request = rename_table_request;
2639    let p_delimiter = delimiter;
2640
2641    let uri_str = format!("{}/v1/table/{id}/rename", configuration.base_path, id=crate::apis::urlencode(p_id));
2642    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2643
2644    if let Some(ref param_value) = p_delimiter {
2645        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2646    }
2647    if let Some(ref user_agent) = configuration.user_agent {
2648        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2649    }
2650    if let Some(ref token) = configuration.oauth_access_token {
2651        req_builder = req_builder.bearer_auth(token.to_owned());
2652    };
2653    if let Some(ref apikey) = configuration.api_key {
2654        let key = apikey.key.clone();
2655        let value = match apikey.prefix {
2656            Some(ref prefix) => format!("{} {}", prefix, key),
2657            None => key,
2658        };
2659        req_builder = req_builder.header("x-api-key", value);
2660    };
2661    if let Some(ref token) = configuration.bearer_access_token {
2662        req_builder = req_builder.bearer_auth(token.to_owned());
2663    };
2664    req_builder = req_builder.json(&p_rename_table_request);
2665
2666    let req = req_builder.build()?;
2667    let resp = configuration.client.execute(req).await?;
2668
2669    let status = resp.status();
2670    let content_type = resp
2671        .headers()
2672        .get("content-type")
2673        .and_then(|v| v.to_str().ok())
2674        .unwrap_or("application/octet-stream");
2675    let content_type = super::ContentType::from(content_type);
2676
2677    if !status.is_client_error() && !status.is_server_error() {
2678        let content = resp.text().await?;
2679        match content_type {
2680            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2681            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RenameTableResponse`"))),
2682            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RenameTableResponse`")))),
2683        }
2684    } else {
2685        let content = resp.text().await?;
2686        let entity: Option<RenameTableError> = serde_json::from_str(&content).ok();
2687        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2688    }
2689}
2690
2691/// Restore table `id` to a specific version. 
2692pub async fn restore_table(configuration: &configuration::Configuration, id: &str, restore_table_request: models::RestoreTableRequest, delimiter: Option<&str>) -> Result<models::RestoreTableResponse, Error<RestoreTableError>> {
2693    // add a prefix to parameters to efficiently prevent name collisions
2694    let p_id = id;
2695    let p_restore_table_request = restore_table_request;
2696    let p_delimiter = delimiter;
2697
2698    let uri_str = format!("{}/v1/table/{id}/restore", configuration.base_path, id=crate::apis::urlencode(p_id));
2699    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2700
2701    if let Some(ref param_value) = p_delimiter {
2702        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2703    }
2704    if let Some(ref user_agent) = configuration.user_agent {
2705        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2706    }
2707    if let Some(ref token) = configuration.oauth_access_token {
2708        req_builder = req_builder.bearer_auth(token.to_owned());
2709    };
2710    if let Some(ref apikey) = configuration.api_key {
2711        let key = apikey.key.clone();
2712        let value = match apikey.prefix {
2713            Some(ref prefix) => format!("{} {}", prefix, key),
2714            None => key,
2715        };
2716        req_builder = req_builder.header("x-api-key", value);
2717    };
2718    if let Some(ref token) = configuration.bearer_access_token {
2719        req_builder = req_builder.bearer_auth(token.to_owned());
2720    };
2721    req_builder = req_builder.json(&p_restore_table_request);
2722
2723    let req = req_builder.build()?;
2724    let resp = configuration.client.execute(req).await?;
2725
2726    let status = resp.status();
2727    let content_type = resp
2728        .headers()
2729        .get("content-type")
2730        .and_then(|v| v.to_str().ok())
2731        .unwrap_or("application/octet-stream");
2732    let content_type = super::ContentType::from(content_type);
2733
2734    if !status.is_client_error() && !status.is_server_error() {
2735        let content = resp.text().await?;
2736        match content_type {
2737            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2738            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RestoreTableResponse`"))),
2739            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RestoreTableResponse`")))),
2740        }
2741    } else {
2742        let content = resp.text().await?;
2743        let entity: Option<RestoreTableError> = serde_json::from_str(&content).ok();
2744        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2745    }
2746}
2747
2748/// Check if table `id` exists.  This operation should behave exactly like DescribeTable, except it does not contain a response body.  For DirectoryNamespace implementation, a table exists if either: - The table has Lance data versions (regular table created with CreateTable) - A `.lance-reserved` file exists in the table directory (declared table created with DeclareTable) 
2749pub async fn table_exists(configuration: &configuration::Configuration, id: &str, table_exists_request: models::TableExistsRequest, delimiter: Option<&str>) -> Result<(), Error<TableExistsError>> {
2750    // add a prefix to parameters to efficiently prevent name collisions
2751    let p_id = id;
2752    let p_table_exists_request = table_exists_request;
2753    let p_delimiter = delimiter;
2754
2755    let uri_str = format!("{}/v1/table/{id}/exists", configuration.base_path, id=crate::apis::urlencode(p_id));
2756    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2757
2758    if let Some(ref param_value) = p_delimiter {
2759        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2760    }
2761    if let Some(ref user_agent) = configuration.user_agent {
2762        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2763    }
2764    if let Some(ref token) = configuration.oauth_access_token {
2765        req_builder = req_builder.bearer_auth(token.to_owned());
2766    };
2767    if let Some(ref apikey) = configuration.api_key {
2768        let key = apikey.key.clone();
2769        let value = match apikey.prefix {
2770            Some(ref prefix) => format!("{} {}", prefix, key),
2771            None => key,
2772        };
2773        req_builder = req_builder.header("x-api-key", value);
2774    };
2775    if let Some(ref token) = configuration.bearer_access_token {
2776        req_builder = req_builder.bearer_auth(token.to_owned());
2777    };
2778    req_builder = req_builder.json(&p_table_exists_request);
2779
2780    let req = req_builder.build()?;
2781    let resp = configuration.client.execute(req).await?;
2782
2783    let status = resp.status();
2784
2785    if !status.is_client_error() && !status.is_server_error() {
2786        Ok(())
2787    } else {
2788        let content = resp.text().await?;
2789        let entity: Option<TableExistsError> = serde_json::from_str(&content).ok();
2790        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2791    }
2792}
2793
2794/// Update existing rows in table `id`. 
2795pub async fn update_table(configuration: &configuration::Configuration, id: &str, update_table_request: models::UpdateTableRequest, delimiter: Option<&str>) -> Result<models::UpdateTableResponse, Error<UpdateTableError>> {
2796    // add a prefix to parameters to efficiently prevent name collisions
2797    let p_id = id;
2798    let p_update_table_request = update_table_request;
2799    let p_delimiter = delimiter;
2800
2801    let uri_str = format!("{}/v1/table/{id}/update", configuration.base_path, id=crate::apis::urlencode(p_id));
2802    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2803
2804    if let Some(ref param_value) = p_delimiter {
2805        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2806    }
2807    if let Some(ref user_agent) = configuration.user_agent {
2808        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2809    }
2810    if let Some(ref token) = configuration.oauth_access_token {
2811        req_builder = req_builder.bearer_auth(token.to_owned());
2812    };
2813    if let Some(ref apikey) = configuration.api_key {
2814        let key = apikey.key.clone();
2815        let value = match apikey.prefix {
2816            Some(ref prefix) => format!("{} {}", prefix, key),
2817            None => key,
2818        };
2819        req_builder = req_builder.header("x-api-key", value);
2820    };
2821    if let Some(ref token) = configuration.bearer_access_token {
2822        req_builder = req_builder.bearer_auth(token.to_owned());
2823    };
2824    req_builder = req_builder.json(&p_update_table_request);
2825
2826    let req = req_builder.build()?;
2827    let resp = configuration.client.execute(req).await?;
2828
2829    let status = resp.status();
2830    let content_type = resp
2831        .headers()
2832        .get("content-type")
2833        .and_then(|v| v.to_str().ok())
2834        .unwrap_or("application/octet-stream");
2835    let content_type = super::ContentType::from(content_type);
2836
2837    if !status.is_client_error() && !status.is_server_error() {
2838        let content = resp.text().await?;
2839        match content_type {
2840            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2841            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTableResponse`"))),
2842            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTableResponse`")))),
2843        }
2844    } else {
2845        let content = resp.text().await?;
2846        let entity: Option<UpdateTableError> = serde_json::from_str(&content).ok();
2847        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2848    }
2849}
2850
2851/// Replace the schema metadata for table `id` with the provided key-value pairs.  REST NAMESPACE ONLY REST namespace uses a direct object (map of string to string) as both request and response body instead of the wrapped `UpdateTableSchemaMetadataRequest` and `UpdateTableSchemaMetadataResponse`. 
2852pub async fn update_table_schema_metadata(configuration: &configuration::Configuration, id: &str, request_body: std::collections::HashMap<String, String>, delimiter: Option<&str>) -> Result<std::collections::HashMap<String, String>, Error<UpdateTableSchemaMetadataError>> {
2853    // add a prefix to parameters to efficiently prevent name collisions
2854    let p_id = id;
2855    let p_request_body = request_body;
2856    let p_delimiter = delimiter;
2857
2858    let uri_str = format!("{}/v1/table/{id}/schema_metadata/update", configuration.base_path, id=crate::apis::urlencode(p_id));
2859    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2860
2861    if let Some(ref param_value) = p_delimiter {
2862        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2863    }
2864    if let Some(ref user_agent) = configuration.user_agent {
2865        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2866    }
2867    if let Some(ref token) = configuration.oauth_access_token {
2868        req_builder = req_builder.bearer_auth(token.to_owned());
2869    };
2870    if let Some(ref apikey) = configuration.api_key {
2871        let key = apikey.key.clone();
2872        let value = match apikey.prefix {
2873            Some(ref prefix) => format!("{} {}", prefix, key),
2874            None => key,
2875        };
2876        req_builder = req_builder.header("x-api-key", value);
2877    };
2878    if let Some(ref token) = configuration.bearer_access_token {
2879        req_builder = req_builder.bearer_auth(token.to_owned());
2880    };
2881    req_builder = req_builder.json(&p_request_body);
2882
2883    let req = req_builder.build()?;
2884    let resp = configuration.client.execute(req).await?;
2885
2886    let status = resp.status();
2887    let content_type = resp
2888        .headers()
2889        .get("content-type")
2890        .and_then(|v| v.to_str().ok())
2891        .unwrap_or("application/octet-stream");
2892    let content_type = super::ContentType::from(content_type);
2893
2894    if !status.is_client_error() && !status.is_server_error() {
2895        let content = resp.text().await?;
2896        match content_type {
2897            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2898            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap&lt;String, String&gt;`"))),
2899            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, String&gt;`")))),
2900        }
2901    } else {
2902        let content = resp.text().await?;
2903        let entity: Option<UpdateTableSchemaMetadataError> = serde_json::from_str(&content).ok();
2904        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2905    }
2906}
2907
2908/// Update an existing tag for table `id` to point to a different version. 
2909pub async fn update_table_tag(configuration: &configuration::Configuration, id: &str, update_table_tag_request: models::UpdateTableTagRequest, delimiter: Option<&str>) -> Result<models::UpdateTableTagResponse, Error<UpdateTableTagError>> {
2910    // add a prefix to parameters to efficiently prevent name collisions
2911    let p_id = id;
2912    let p_update_table_tag_request = update_table_tag_request;
2913    let p_delimiter = delimiter;
2914
2915    let uri_str = format!("{}/v1/table/{id}/tags/update", configuration.base_path, id=crate::apis::urlencode(p_id));
2916    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2917
2918    if let Some(ref param_value) = p_delimiter {
2919        req_builder = req_builder.query(&[("delimiter", &param_value.to_string())]);
2920    }
2921    if let Some(ref user_agent) = configuration.user_agent {
2922        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2923    }
2924    if let Some(ref token) = configuration.oauth_access_token {
2925        req_builder = req_builder.bearer_auth(token.to_owned());
2926    };
2927    if let Some(ref apikey) = configuration.api_key {
2928        let key = apikey.key.clone();
2929        let value = match apikey.prefix {
2930            Some(ref prefix) => format!("{} {}", prefix, key),
2931            None => key,
2932        };
2933        req_builder = req_builder.header("x-api-key", value);
2934    };
2935    if let Some(ref token) = configuration.bearer_access_token {
2936        req_builder = req_builder.bearer_auth(token.to_owned());
2937    };
2938    req_builder = req_builder.json(&p_update_table_tag_request);
2939
2940    let req = req_builder.build()?;
2941    let resp = configuration.client.execute(req).await?;
2942
2943    let status = resp.status();
2944    let content_type = resp
2945        .headers()
2946        .get("content-type")
2947        .and_then(|v| v.to_str().ok())
2948        .unwrap_or("application/octet-stream");
2949    let content_type = super::ContentType::from(content_type);
2950
2951    if !status.is_client_error() && !status.is_server_error() {
2952        let content = resp.text().await?;
2953        match content_type {
2954            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2955            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTableTagResponse`"))),
2956            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTableTagResponse`")))),
2957        }
2958    } else {
2959        let content = resp.text().await?;
2960        let entity: Option<UpdateTableTagError> = serde_json::from_str(&content).ok();
2961        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2962    }
2963}
2964
lance_namespace_reqwest_client/apis/table_api.rs

lance_namespace_reqwest_client/apis/
table_api.rs
