Skip to main content

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