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

lance_namespace_reqwest_client/apis/
metadata_api.rs
