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

lance_namespace_reqwest_client/apis/
metadata_api.rs
