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

lance_namespace_reqwest_client/apis/
metadata_api.rs
