coda_api/
client.rs

1use crate::types::{Column, Row, Table, TableReference};
2use crate::{ClientTablesError, Error, Limiter, RawClient, ResponseValue, RichRow, RowUpdateResultCorrect, RowsUpsertResultCorrect, TableId, types};
3use crate::{ItemsList, ValueFormatProvider, paginate_all};
4use errgonomic::handle;
5use serde::de::DeserializeOwned;
6use std::collections::HashMap;
7use std::time::Duration;
8use thiserror::Error;
9use tokio::time::sleep;
10
11pub struct Client {
12    pub raw: RawClient,
13    pub limiter: Limiter,
14}
15
16#[allow(clippy::too_many_arguments)]
17#[allow(clippy::needless_lifetimes)]
18impl Client {
19    pub const BASE_URL: &'static str = RawClient::BASE_URL;
20
21    pub fn new(baseurl: &str) -> Self {
22        let raw = RawClient::new(baseurl);
23        let limiter = Limiter::default();
24        Self {
25            raw,
26            limiter,
27        }
28    }
29
30    pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
31        let raw = RawClient::new_with_client(baseurl, client);
32        let limiter = Limiter::default();
33        Self {
34            raw,
35            limiter,
36        }
37    }
38
39    pub fn new_with_key(api_key: &str) -> reqwest::Result<Self> {
40        let raw = RawClient::new_with_key(api_key)?;
41        let limiter = Limiter::default();
42
43        Ok(Self {
44            raw,
45            limiter,
46        })
47    }
48
49    pub async fn list_categories<'a>(&'a self) -> Result<ResponseValue<types::DocCategoryList>, Error<types::ListCategoriesResponse>> {
50        self.limiter.read.until_ready().await;
51        self.raw.list_categories().await
52    }
53
54    pub async fn list_docs<'a>(&'a self, folder_id: Option<&'a str>, in_gallery: Option<bool>, is_owner: Option<bool>, is_published: Option<bool>, is_starred: Option<bool>, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>, query: Option<&'a str>, source_doc: Option<&'a str>, workspace_id: Option<&'a str>) -> Result<ResponseValue<types::DocList>, Error<types::ListDocsResponse>> {
55        self.limiter.list_docs.until_ready().await;
56        self.raw
57            .list_docs(folder_id, in_gallery, is_owner, is_published, is_starred, limit, page_token, query, source_doc, workspace_id)
58            .await
59    }
60
61    pub async fn create_doc<'a>(&'a self, body: &'a types::DocCreate) -> Result<ResponseValue<types::DocumentCreationResult>, Error<types::CreateDocResponse>> {
62        self.limiter.write_doc_content.until_ready().await;
63        self.raw.create_doc(body).await
64    }
65
66    pub async fn get_doc<'a>(&'a self, doc_id: &'a str) -> Result<ResponseValue<types::Doc>, Error<types::GetDocResponse>> {
67        self.limiter.read.until_ready().await;
68        self.raw.get_doc(doc_id).await
69    }
70
71    pub async fn delete_doc<'a>(&'a self, doc_id: &'a str) -> Result<ResponseValue<types::DocDelete>, Error<types::DeleteDocResponse>> {
72        self.limiter.write_doc_content.until_ready().await;
73        self.raw.delete_doc(doc_id).await
74    }
75
76    pub async fn update_doc<'a>(&'a self, doc_id: &'a str, body: &'a types::DocUpdate) -> Result<ResponseValue<types::DocUpdateResult>, Error<types::UpdateDocResponse>> {
77        self.limiter.write_doc_content.until_ready().await;
78        self.raw.update_doc(doc_id, body).await
79    }
80
81    pub async fn get_sharing_metadata<'a>(&'a self, doc_id: &'a str) -> Result<ResponseValue<types::AclMetadata>, Error<types::GetSharingMetadataResponse>> {
82        self.limiter.read.until_ready().await;
83        self.raw.get_sharing_metadata(doc_id).await
84    }
85
86    pub async fn get_permissions<'a>(&'a self, doc_id: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>) -> Result<ResponseValue<types::Acl>, Error<types::GetPermissionsResponse>> {
87        self.limiter.read.until_ready().await;
88        self.raw.get_permissions(doc_id, limit, page_token).await
89    }
90
91    pub async fn add_permission<'a>(&'a self, doc_id: &'a str, body: &'a types::AddPermissionRequest) -> Result<ResponseValue<types::AddPermissionResult>, Error<types::AddPermissionResponse>> {
92        self.limiter.write.until_ready().await;
93        self.raw.add_permission(doc_id, body).await
94    }
95
96    pub async fn delete_permission<'a>(&'a self, doc_id: &'a str, permission_id: &'a str) -> Result<ResponseValue<types::DeletePermissionResult>, Error<types::DeletePermissionResponse>> {
97        self.limiter.write.until_ready().await;
98        self.raw.delete_permission(doc_id, permission_id).await
99    }
100
101    pub async fn search_principals<'a>(&'a self, doc_id: &'a str, query: Option<&'a str>) -> Result<ResponseValue<types::SearchPrincipalsResponse>, Error<types::SearchPrincipalsResponse>> {
102        self.limiter.read.until_ready().await;
103        self.raw.search_principals(doc_id, query).await
104    }
105
106    pub async fn get_acl_settings<'a>(&'a self, doc_id: &'a str) -> Result<ResponseValue<types::AclSettings>, Error<types::GetAclSettingsResponse>> {
107        self.limiter.read.until_ready().await;
108        self.raw.get_acl_settings(doc_id).await
109    }
110
111    pub async fn update_acl_settings<'a>(&'a self, doc_id: &'a str, body: &'a types::UpdateAclSettingsRequest) -> Result<ResponseValue<types::AclSettings>, Error<types::UpdateAclSettingsResponse>> {
112        self.limiter.write.until_ready().await;
113        self.raw.update_acl_settings(doc_id, body).await
114    }
115
116    pub async fn publish_doc<'a>(&'a self, doc_id: &'a str, body: &'a types::DocPublish) -> Result<ResponseValue<types::PublishResult>, Error<types::PublishDocResponse>> {
117        self.limiter.write_doc_content.until_ready().await;
118        self.raw.publish_doc(doc_id, body).await
119    }
120
121    pub async fn unpublish_doc<'a>(&'a self, doc_id: &'a str) -> Result<ResponseValue<types::UnpublishResult>, Error<types::UnpublishDocResponse>> {
122        self.limiter.write_doc_content.until_ready().await;
123        self.raw.unpublish_doc(doc_id).await
124    }
125
126    pub async fn list_pages<'a>(&'a self, doc_id: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>) -> Result<ResponseValue<types::PageList>, Error<types::ListPagesResponse>> {
127        self.limiter.read.until_ready().await;
128        self.raw.list_pages(doc_id, limit, page_token).await
129    }
130
131    pub async fn create_page<'a>(&'a self, doc_id: &'a str, body: &'a types::PageCreate) -> Result<ResponseValue<types::PageCreateResult>, Error<types::CreatePageResponse>> {
132        self.limiter.write_doc_content.until_ready().await;
133        self.raw.create_page(doc_id, body).await
134    }
135
136    pub async fn get_page<'a>(&'a self, doc_id: &'a str, page_id_or_name: &'a str) -> Result<ResponseValue<types::Page>, Error<types::GetPageResponse>> {
137        self.limiter.read.until_ready().await;
138        self.raw.get_page(doc_id, page_id_or_name).await
139    }
140
141    pub async fn update_page<'a>(&'a self, doc_id: &'a str, page_id_or_name: &'a str, body: &'a types::PageUpdate) -> Result<ResponseValue<types::PageUpdateResult>, Error<types::UpdatePageResponse>> {
142        self.limiter.write_doc_content.until_ready().await;
143        self.raw.update_page(doc_id, page_id_or_name, body).await
144    }
145
146    pub async fn delete_page<'a>(&'a self, doc_id: &'a str, page_id_or_name: &'a str) -> Result<ResponseValue<types::PageDeleteResult>, Error<types::DeletePageResponse>> {
147        self.limiter.write_doc_content.until_ready().await;
148        self.raw.delete_page(doc_id, page_id_or_name).await
149    }
150
151    pub async fn begin_page_content_export<'a>(&'a self, doc_id: &'a str, page_id_or_name: &'a str, body: &'a types::BeginPageContentExportRequest) -> Result<ResponseValue<types::BeginPageContentExportResponse>, Error<types::BeginPageContentExportResponse>> {
152        self.limiter.write_doc_content.until_ready().await;
153        self.raw
154            .begin_page_content_export(doc_id, page_id_or_name, body)
155            .await
156    }
157
158    pub async fn get_page_content_export_status<'a>(&'a self, doc_id: &'a str, page_id_or_name: &'a str, request_id: &'a str) -> Result<ResponseValue<types::PageContentExportStatusResponse>, Error<types::GetPageContentExportStatusResponse>> {
159        self.limiter.read.until_ready().await;
160        self.raw
161            .get_page_content_export_status(doc_id, page_id_or_name, request_id)
162            .await
163    }
164
165    pub async fn list_tables<'a>(&'a self, doc_id: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>, sort_by: Option<types::SortBy>, table_types: Option<&'a ::std::vec::Vec<types::TableTypeEnum>>) -> Result<ResponseValue<types::TableList>, Error<types::ListTablesResponse>> {
166        self.limiter.read.until_ready().await;
167        self.raw
168            .list_tables(doc_id, limit, page_token, sort_by, table_types)
169            .await
170    }
171
172    pub async fn get_table<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, use_updated_table_layouts: Option<bool>) -> Result<ResponseValue<types::Table>, Error<types::GetTableResponse>> {
173        self.limiter.read.until_ready().await;
174        self.raw
175            .get_table(doc_id, table_id_or_name, use_updated_table_layouts)
176            .await
177    }
178
179    pub async fn list_columns<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>, visible_only: Option<bool>) -> Result<ResponseValue<types::ColumnList>, Error<types::ListColumnsResponse>> {
180        self.limiter.read.until_ready().await;
181        self.raw
182            .list_columns(doc_id, table_id_or_name, limit, page_token, visible_only)
183            .await
184    }
185
186    pub async fn list_rows<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>, query: Option<&'a str>, sort_by: Option<types::RowsSortBy>, sync_token: Option<&'a str>, use_column_names: Option<bool>, value_format: Option<types::ValueFormat>, visible_only: Option<bool>) -> Result<ResponseValue<types::RowList>, Error<types::ListRowsResponse>> {
187        self.limiter.read.until_ready().await;
188        self.raw
189            .list_rows(doc_id, table_id_or_name, limit, page_token, query, sort_by, sync_token, use_column_names, value_format, visible_only)
190            .await
191    }
192
193    #[deprecated = "use upsert_rows_correct"]
194    pub async fn upsert_rows<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, disable_parsing: Option<bool>, body: &'a types::RowsUpsert) -> Result<ResponseValue<types::RowsUpsertResult>, Error<types::UpsertRowsResponse>> {
195        self.limiter.write_doc_content.until_ready().await;
196        self.raw
197            .upsert_rows(doc_id, table_id_or_name, disable_parsing, body)
198            .await
199    }
200
201    pub async fn delete_rows<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, body: &'a types::RowsDelete) -> Result<ResponseValue<types::RowsDeleteResult>, Error<types::DeleteRowsResponse>> {
202        self.limiter.write_doc_content.until_ready().await;
203        self.raw.delete_rows(doc_id, table_id_or_name, body).await
204    }
205
206    #[deprecated = "use get_row_correct"]
207    pub async fn get_row<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, row_id_or_name: &'a str, use_column_names: Option<bool>, value_format: Option<types::ValueFormat>) -> Result<ResponseValue<types::RowDetail>, Error<types::GetRowResponse>> {
208        self.limiter.read.until_ready().await;
209        self.raw
210            .get_row(doc_id, table_id_or_name, row_id_or_name, use_column_names, value_format)
211            .await
212    }
213
214    pub async fn get_row_correct<'a, T: DeserializeOwned + ValueFormatProvider>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, row_id_or_name: &'a str, use_column_names: Option<bool>) -> Result<ResponseValue<T>, Error<types::GetRowResponse>> {
215        self.limiter.read.until_ready().await;
216        self.raw
217            .get_row_correct(doc_id, table_id_or_name, row_id_or_name, use_column_names)
218            .await
219    }
220
221    pub async fn update_row<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, row_id_or_name: &'a str, disable_parsing: Option<bool>, body: &'a types::RowUpdate) -> Result<ResponseValue<types::RowUpdateResult>, Error<types::UpdateRowResponse>> {
222        self.limiter.write_doc_content.until_ready().await;
223        self.raw
224            .update_row(doc_id, table_id_or_name, row_id_or_name, disable_parsing, body)
225            .await
226    }
227
228    pub async fn delete_row<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, row_id_or_name: &'a str) -> Result<ResponseValue<types::RowDeleteResult>, Error<types::DeleteRowResponse>> {
229        self.limiter.write_doc_content.until_ready().await;
230        self.raw
231            .delete_row(doc_id, table_id_or_name, row_id_or_name)
232            .await
233    }
234
235    pub async fn push_button<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, row_id_or_name: &'a str, column_id_or_name: &'a str) -> Result<ResponseValue<types::PushButtonResult>, Error<types::PushButtonResponse>> {
236        self.limiter.write_doc_content.until_ready().await;
237        self.raw
238            .push_button(doc_id, table_id_or_name, row_id_or_name, column_id_or_name)
239            .await
240    }
241
242    pub async fn get_column<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, column_id_or_name: &'a str) -> Result<ResponseValue<types::ColumnDetail>, Error<types::GetColumnResponse>> {
243        self.limiter.read.until_ready().await;
244        self.raw
245            .get_column(doc_id, table_id_or_name, column_id_or_name)
246            .await
247    }
248
249    pub async fn list_formulas<'a>(&'a self, doc_id: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>, sort_by: Option<types::SortBy>) -> Result<ResponseValue<types::FormulaList>, Error<types::ListFormulasResponse>> {
250        self.limiter.read.until_ready().await;
251        self.raw
252            .list_formulas(doc_id, limit, page_token, sort_by)
253            .await
254    }
255
256    pub async fn get_formula<'a>(&'a self, doc_id: &'a str, formula_id_or_name: &'a str) -> Result<ResponseValue<types::Formula>, Error<types::GetFormulaResponse>> {
257        self.limiter.read.until_ready().await;
258        self.raw.get_formula(doc_id, formula_id_or_name).await
259    }
260
261    pub async fn list_controls<'a>(&'a self, doc_id: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>, sort_by: Option<types::SortBy>) -> Result<ResponseValue<types::ControlList>, Error<types::ListControlsResponse>> {
262        self.limiter.read.until_ready().await;
263        self.raw
264            .list_controls(doc_id, limit, page_token, sort_by)
265            .await
266    }
267
268    pub async fn get_control<'a>(&'a self, doc_id: &'a str, control_id_or_name: &'a str) -> Result<ResponseValue<types::Control>, Error<types::GetControlResponse>> {
269        self.limiter.read.until_ready().await;
270        self.raw.get_control(doc_id, control_id_or_name).await
271    }
272
273    pub async fn list_custom_doc_domains<'a>(&'a self, doc_id: &'a str) -> Result<ResponseValue<types::CustomDocDomainList>, Error<types::ListCustomDocDomainsResponse>> {
274        self.limiter.read.until_ready().await;
275        self.raw.list_custom_doc_domains(doc_id).await
276    }
277
278    pub async fn add_custom_doc_domain<'a>(&'a self, doc_id: &'a str, body: &'a types::AddCustomDocDomainRequest) -> Result<ResponseValue<types::AddCustomDocDomainResponse>, Error<types::AddCustomDocDomainResponse>> {
279        self.limiter.write.until_ready().await;
280        self.raw.add_custom_doc_domain(doc_id, body).await
281    }
282
283    pub async fn delete_custom_doc_domain<'a>(&'a self, doc_id: &'a str, custom_doc_domain: &'a str) -> Result<ResponseValue<types::DeleteCustomDocDomainResponse>, Error<types::DeleteCustomDocDomainResponse>> {
284        self.limiter.write.until_ready().await;
285        self.raw
286            .delete_custom_doc_domain(doc_id, custom_doc_domain)
287            .await
288    }
289
290    pub async fn update_custom_doc_domain<'a>(&'a self, doc_id: &'a str, custom_doc_domain: &'a str, body: &'a types::UpdateCustomDocDomainRequest) -> Result<ResponseValue<types::UpdateCustomDocDomainResponse>, Error<types::UpdateCustomDocDomainResponse>> {
291        self.limiter.write.until_ready().await;
292        self.raw
293            .update_custom_doc_domain(doc_id, custom_doc_domain, body)
294            .await
295    }
296
297    pub async fn get_custom_doc_domain_provider<'a>(&'a self, custom_doc_domain: &'a str) -> Result<ResponseValue<types::CustomDocDomainProviderResponse>, Error<types::GetCustomDocDomainProviderResponse>> {
298        self.limiter.read.until_ready().await;
299        self.raw
300            .get_custom_doc_domain_provider(custom_doc_domain)
301            .await
302    }
303
304    pub async fn get_folder<'a>(&'a self, folder_id: &'a str) -> Result<ResponseValue<types::Folder>, Error<types::GetFolderResponse>> {
305        self.limiter.read.until_ready().await;
306        self.raw.get_folder(folder_id).await
307    }
308
309    pub async fn whoami<'a>(&'a self) -> Result<ResponseValue<types::User>, Error<types::WhoamiResponse>> {
310        self.limiter.read.until_ready().await;
311        self.raw.whoami().await
312    }
313
314    pub async fn resolve_browser_link<'a>(&'a self, degrade_gracefully: Option<bool>, url: &'a str) -> Result<ResponseValue<types::ApiLink>, Error<types::ResolveBrowserLinkResponse>> {
315        self.limiter.read.until_ready().await;
316        self.raw.resolve_browser_link(degrade_gracefully, url).await
317    }
318
319    pub async fn get_mutation_status<'a>(&'a self, request_id: &'a str) -> Result<ResponseValue<types::MutationStatus>, Error<types::GetMutationStatusResponse>> {
320        self.limiter.read.until_ready().await;
321        self.raw.get_mutation_status(request_id).await
322    }
323
324    pub async fn trigger_webhook_automation<'a>(&'a self, doc_id: &'a str, rule_id: &'a str, body: &'a types::WebhookTriggerPayload) -> Result<ResponseValue<types::WebhookTriggerResult>, Error<types::TriggerWebhookAutomationResponse>> {
325        self.limiter.write.until_ready().await;
326        self.raw
327            .trigger_webhook_automation(doc_id, rule_id, body)
328            .await
329    }
330
331    pub async fn list_doc_analytics<'a>(&'a self, direction: Option<types::SortDirection>, doc_ids: Option<&'a ::std::vec::Vec<::std::string::String>>, is_published: Option<bool>, limit: Option<::std::num::NonZeroU64>, order_by: Option<types::DocAnalyticsOrderBy>, page_token: Option<&'a str>, query: Option<&'a str>, scale: Option<types::AnalyticsScale>, since_date: Option<&'a ::chrono::naive::NaiveDate>, until_date: Option<&'a ::chrono::naive::NaiveDate>, workspace_id: Option<&'a str>) -> Result<ResponseValue<types::DocAnalyticsCollection>, Error<types::ListDocAnalyticsResponse>> {
332        self.limiter.read_analytics.until_ready().await;
333        self.raw
334            .list_doc_analytics(direction, doc_ids, is_published, limit, order_by, page_token, query, scale, since_date, until_date, workspace_id)
335            .await
336    }
337
338    pub async fn list_page_analytics<'a>(&'a self, doc_id: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>, since_date: Option<&'a ::chrono::naive::NaiveDate>, until_date: Option<&'a ::chrono::naive::NaiveDate>) -> Result<ResponseValue<types::PageAnalyticsCollection>, Error<types::ListPageAnalyticsResponse>> {
339        self.limiter.read_analytics.until_ready().await;
340        self.raw
341            .list_page_analytics(doc_id, limit, page_token, since_date, until_date)
342            .await
343    }
344
345    pub async fn list_doc_analytics_summary<'a>(&'a self, is_published: Option<bool>, since_date: Option<&'a ::chrono::naive::NaiveDate>, until_date: Option<&'a ::chrono::naive::NaiveDate>, workspace_id: Option<&'a str>) -> Result<ResponseValue<types::DocAnalyticsSummary>, Error<types::ListDocAnalyticsSummaryResponse>> {
346        self.limiter.read_analytics.until_ready().await;
347        self.raw
348            .list_doc_analytics_summary(is_published, since_date, until_date, workspace_id)
349            .await
350    }
351
352    pub async fn list_pack_analytics<'a>(&'a self, direction: Option<types::SortDirection>, is_published: Option<bool>, limit: Option<::std::num::NonZeroU64>, order_by: Option<types::PackAnalyticsOrderBy>, pack_ids: Option<&'a ::std::vec::Vec<i64>>, page_token: Option<&'a str>, query: Option<&'a str>, scale: Option<types::AnalyticsScale>, since_date: Option<&'a ::chrono::naive::NaiveDate>, until_date: Option<&'a ::chrono::naive::NaiveDate>, workspace_id: Option<&'a str>) -> Result<ResponseValue<types::PackAnalyticsCollection>, Error<types::ListPackAnalyticsResponse>> {
353        self.limiter.read_analytics.until_ready().await;
354        self.raw
355            .list_pack_analytics(direction, is_published, limit, order_by, pack_ids, page_token, query, scale, since_date, until_date, workspace_id)
356            .await
357    }
358
359    pub async fn list_pack_analytics_summary<'a>(&'a self, is_published: Option<bool>, pack_ids: Option<&'a ::std::vec::Vec<i64>>, since_date: Option<&'a ::chrono::naive::NaiveDate>, until_date: Option<&'a ::chrono::naive::NaiveDate>, workspace_id: Option<&'a str>) -> Result<ResponseValue<types::PackAnalyticsSummary>, Error<types::ListPackAnalyticsSummaryResponse>> {
360        self.limiter.read_analytics.until_ready().await;
361        self.raw
362            .list_pack_analytics_summary(is_published, pack_ids, since_date, until_date, workspace_id)
363            .await
364    }
365
366    pub async fn list_pack_formula_analytics<'a>(&'a self, pack_id: ::std::num::NonZeroU64, direction: Option<types::SortDirection>, limit: Option<::std::num::NonZeroU64>, order_by: Option<types::PackFormulaAnalyticsOrderBy>, pack_formula_names: Option<&'a ::std::vec::Vec<::std::string::String>>, pack_formula_types: Option<&'a ::std::vec::Vec<types::PackFormulaType>>, page_token: Option<&'a str>, scale: Option<types::AnalyticsScale>, since_date: Option<&'a ::chrono::naive::NaiveDate>, until_date: Option<&'a ::chrono::naive::NaiveDate>) -> Result<ResponseValue<types::PackFormulaAnalyticsCollection>, Error<types::ListPackFormulaAnalyticsResponse>> {
367        self.limiter.read_analytics.until_ready().await;
368        self.raw
369            .list_pack_formula_analytics(pack_id, direction, limit, order_by, pack_formula_names, pack_formula_types, page_token, scale, since_date, until_date)
370            .await
371    }
372
373    pub async fn get_analytics_last_updated<'a>(&'a self) -> Result<ResponseValue<types::AnalyticsLastUpdatedResponse>, Error<types::GetAnalyticsLastUpdatedResponse>> {
374        self.limiter.read_analytics.until_ready().await;
375        self.raw.get_analytics_last_updated().await
376    }
377
378    pub async fn list_workspace_members<'a>(&'a self, workspace_id: &'a str, included_roles: Option<&'a ::std::vec::Vec<types::WorkspaceUserRole>>, page_token: Option<&'a str>) -> Result<ResponseValue<types::WorkspaceMembersList>, Error<types::ListWorkspaceMembersResponse>> {
379        self.limiter.read.until_ready().await;
380        self.raw
381            .list_workspace_members(workspace_id, included_roles, page_token)
382            .await
383    }
384
385    pub async fn change_user_role<'a>(&'a self, workspace_id: &'a str, body: &'a types::ChangeRole) -> Result<ResponseValue<types::ChangeRoleResult>, Error<types::ChangeUserRoleResponse>> {
386        self.limiter.write.until_ready().await;
387        self.raw.change_user_role(workspace_id, body).await
388    }
389
390    pub async fn list_workspace_role_activity<'a>(&'a self, workspace_id: &'a str) -> Result<ResponseValue<types::GetWorkspaceRoleActivity>, Error<types::ListWorkspaceRoleActivityResponse>> {
391        self.limiter.read.until_ready().await;
392        self.raw.list_workspace_role_activity(workspace_id).await
393    }
394
395    pub async fn list_packs<'a>(&'a self, access_type: Option<types::PackAccessType>, access_types: Option<&'a ::std::vec::Vec<types::PackAccessType>>, direction: Option<types::SortDirection>, exclude_individual_acls: Option<bool>, exclude_public_packs: Option<bool>, exclude_workspace_acls: Option<bool>, limit: Option<::std::num::NonZeroU64>, only_workspace_id: Option<&'a str>, pack_entrypoint: Option<types::PackEntrypoint>, page_token: Option<&'a str>, parent_workspace_ids: Option<&'a ::std::vec::Vec<::std::string::String>>, sort_by: Option<types::PacksSortBy>) -> Result<ResponseValue<types::PackSummaryList>, Error<types::ListPacksResponse>> {
396        self.limiter.read.until_ready().await;
397        self.raw
398            .list_packs(access_type, access_types, direction, exclude_individual_acls, exclude_public_packs, exclude_workspace_acls, limit, only_workspace_id, pack_entrypoint, page_token, parent_workspace_ids, sort_by)
399            .await
400    }
401
402    pub async fn create_pack<'a>(&'a self, body: &'a types::CreatePackRequest) -> Result<ResponseValue<types::CreatePackResponse>, Error<types::CreatePackResponse>> {
403        self.limiter.write.until_ready().await;
404        self.raw.create_pack(body).await
405    }
406
407    pub async fn get_pack<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::Pack>, Error<types::GetPackResponse>> {
408        self.limiter.read.until_ready().await;
409        self.raw.get_pack(pack_id).await
410    }
411
412    pub async fn delete_pack<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::DeletePackResponse>, Error<types::DeletePackResponse>> {
413        self.limiter.write.until_ready().await;
414        self.raw.delete_pack(pack_id).await
415    }
416
417    pub async fn update_pack<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::UpdatePackRequest) -> Result<ResponseValue<types::Pack>, Error<types::UpdatePackResponse>> {
418        self.limiter.write.until_ready().await;
419        self.raw.update_pack(pack_id, body).await
420    }
421
422    pub async fn get_pack_configuration_schema<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::GetPackConfigurationJsonSchemaResponse>, Error<types::GetPackConfigurationSchemaResponse>> {
423        self.limiter.read.until_ready().await;
424        self.raw.get_pack_configuration_schema(pack_id).await
425    }
426
427    pub async fn list_pack_versions<'a>(&'a self, pack_id: ::std::num::NonZeroU64, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>) -> Result<ResponseValue<types::PackVersionList>, Error<types::ListPackVersionsResponse>> {
428        self.limiter.read.until_ready().await;
429        self.raw
430            .list_pack_versions(pack_id, limit, page_token)
431            .await
432    }
433
434    pub async fn get_next_pack_version<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::GetNextPackVersionRequest) -> Result<ResponseValue<types::NextPackVersionInfo>, Error<types::GetNextPackVersionResponse>> {
435        self.limiter.write.until_ready().await;
436        self.raw.get_next_pack_version(pack_id, body).await
437    }
438
439    pub async fn get_pack_version_diffs<'a>(&'a self, pack_id: ::std::num::NonZeroU64, base_pack_version: &'a str, target_pack_version: &'a str) -> Result<ResponseValue<types::PackVersionDiffs>, Error<types::GetPackVersionDiffsResponse>> {
440        self.limiter.read.until_ready().await;
441        self.raw
442            .get_pack_version_diffs(pack_id, base_pack_version, target_pack_version)
443            .await
444    }
445
446    pub async fn register_pack_version<'a>(&'a self, pack_id: ::std::num::NonZeroU64, pack_version: &'a str, body: &'a types::RegisterPackVersionRequest) -> Result<ResponseValue<types::PackVersionUploadInfo>, Error<types::RegisterPackVersionResponse>> {
447        self.limiter.write.until_ready().await;
448        self.raw
449            .register_pack_version(pack_id, pack_version, body)
450            .await
451    }
452
453    pub async fn pack_version_upload_complete<'a>(&'a self, pack_id: ::std::num::NonZeroU64, pack_version: &'a str, body: &'a types::CreatePackVersionRequest) -> Result<ResponseValue<types::CreatePackVersionResponse>, Error<types::PackVersionUploadCompleteResponse>> {
454        self.limiter.write.until_ready().await;
455        self.raw
456            .pack_version_upload_complete(pack_id, pack_version, body)
457            .await
458    }
459
460    pub async fn list_pack_releases<'a>(&'a self, pack_id: ::std::num::NonZeroU64, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>) -> Result<ResponseValue<types::PackReleaseList>, Error<types::ListPackReleasesResponse>> {
461        self.limiter.read.until_ready().await;
462        self.raw
463            .list_pack_releases(pack_id, limit, page_token)
464            .await
465    }
466
467    pub async fn create_pack_release<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::CreatePackReleaseRequest) -> Result<ResponseValue<types::PackRelease>, Error<types::CreatePackReleaseResponse>> {
468        self.limiter.write.until_ready().await;
469        self.raw.create_pack_release(pack_id, body).await
470    }
471
472    pub async fn update_pack_release<'a>(&'a self, pack_id: ::std::num::NonZeroU64, pack_release_id: ::std::num::NonZeroU64, body: &'a types::UpdatePackReleaseRequest) -> Result<ResponseValue<types::PackRelease>, Error<types::UpdatePackReleaseResponse>> {
473        self.limiter.write.until_ready().await;
474        self.raw
475            .update_pack_release(pack_id, pack_release_id, body)
476            .await
477    }
478
479    pub async fn get_pack_oauth_config<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::PackOauthConfigMetadata>, Error<types::GetPackOauthConfigResponse>> {
480        self.limiter.read.until_ready().await;
481        self.raw.get_pack_oauth_config(pack_id).await
482    }
483
484    pub async fn set_pack_oauth_config<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::SetPackOauthConfigRequest) -> Result<ResponseValue<types::PackOauthConfigMetadata>, Error<types::SetPackOauthConfigResponse>> {
485        self.limiter.write.until_ready().await;
486        self.raw.set_pack_oauth_config(pack_id, body).await
487    }
488
489    pub async fn get_pack_system_connection<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::PackSystemConnectionMetadata>, Error<types::GetPackSystemConnectionResponse>> {
490        self.limiter.read.until_ready().await;
491        self.raw.get_pack_system_connection(pack_id).await
492    }
493
494    pub async fn set_pack_system_connection<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::SetPackSystemConnectionRequest) -> Result<ResponseValue<types::PackSystemConnectionMetadata>, Error<types::SetPackSystemConnectionResponse>> {
495        self.limiter.write.until_ready().await;
496        self.raw.set_pack_system_connection(pack_id, body).await
497    }
498
499    pub async fn patch_pack_system_connection<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::PatchPackSystemConnectionRequest) -> Result<ResponseValue<types::PackSystemConnectionMetadata>, Error<types::PatchPackSystemConnectionResponse>> {
500        self.limiter.write.until_ready().await;
501        self.raw.patch_pack_system_connection(pack_id, body).await
502    }
503
504    pub async fn get_pack_permissions<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::PackPermissionList>, Error<types::GetPackPermissionsResponse>> {
505        self.limiter.read.until_ready().await;
506        self.raw.get_pack_permissions(pack_id).await
507    }
508
509    pub async fn add_pack_permission<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::AddPackPermissionRequest) -> Result<ResponseValue<types::AddPackPermissionResponse>, Error<types::AddPackPermissionResponse>> {
510        self.limiter.write.until_ready().await;
511        self.raw.add_pack_permission(pack_id, body).await
512    }
513
514    pub async fn delete_pack_permission<'a>(&'a self, pack_id: ::std::num::NonZeroU64, permission_id: &'a str) -> Result<ResponseValue<types::DeletePackPermissionResponse>, Error<types::DeletePackPermissionResponse>> {
515        self.limiter.write.until_ready().await;
516        self.raw
517            .delete_pack_permission(pack_id, permission_id)
518            .await
519    }
520
521    pub async fn list_user_pack_invitations<'a>(&'a self, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>) -> Result<ResponseValue<types::PackInvitationWithPackList>, Error<types::ListUserPackInvitationsResponse>> {
522        self.limiter.read.until_ready().await;
523        self.raw.list_user_pack_invitations(limit, page_token).await
524    }
525
526    pub async fn list_pack_invitations<'a>(&'a self, pack_id: ::std::num::NonZeroU64, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>) -> Result<ResponseValue<types::PackInvitationList>, Error<types::ListPackInvitationsResponse>> {
527        self.limiter.read.until_ready().await;
528        self.raw
529            .list_pack_invitations(pack_id, limit, page_token)
530            .await
531    }
532
533    pub async fn create_pack_invitation<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::CreatePackInvitationRequest) -> Result<ResponseValue<types::CreatePackInvitationResponse>, Error<types::CreatePackInvitationResponse>> {
534        self.limiter.write.until_ready().await;
535        self.raw.create_pack_invitation(pack_id, body).await
536    }
537
538    pub async fn update_pack_invitation<'a>(&'a self, pack_id: ::std::num::NonZeroU64, invitation_id: &'a ::uuid::Uuid, body: &'a types::UpdatePackInvitationRequest) -> Result<ResponseValue<types::UpdatePackInvitationResponse>, Error<types::UpdatePackInvitationResponse>> {
539        self.limiter.write.until_ready().await;
540        self.raw
541            .update_pack_invitation(pack_id, invitation_id, body)
542            .await
543    }
544
545    pub async fn delete_pack_invitation<'a>(&'a self, pack_id: ::std::num::NonZeroU64, invitation_id: &'a ::uuid::Uuid) -> Result<ResponseValue<types::DeletePackInvitationResponse>, Error<types::DeletePackInvitationResponse>> {
546        self.limiter.write.until_ready().await;
547        self.raw
548            .delete_pack_invitation(pack_id, invitation_id)
549            .await
550    }
551
552    pub async fn reply_to_pack_invitation<'a>(&'a self, invitation_id: &'a ::uuid::Uuid, body: &'a types::HandlePackInvitationRequest) -> Result<ResponseValue<types::HandlePackInvitationResponse>, Error<types::ReplyToPackInvitationResponse>> {
553        self.limiter.write.until_ready().await;
554        self.raw.reply_to_pack_invitation(invitation_id, body).await
555    }
556
557    pub async fn list_pack_makers<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::ListPackMakersResponse>, Error<types::ListPackMakersResponse>> {
558        self.limiter.read.until_ready().await;
559        self.raw.list_pack_makers(pack_id).await
560    }
561
562    pub async fn add_pack_maker<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::AddPackMakerRequest) -> Result<ResponseValue<types::AddPackMakerResponse>, Error<types::AddPackMakerResponse>> {
563        self.limiter.write.until_ready().await;
564        self.raw.add_pack_maker(pack_id, body).await
565    }
566
567    pub async fn delete_pack_maker<'a>(&'a self, pack_id: ::std::num::NonZeroU64, login_id: &'a str) -> Result<ResponseValue<types::DeletePackMakerResponse>, Error<types::DeletePackMakerResponse>> {
568        self.limiter.write.until_ready().await;
569        self.raw.delete_pack_maker(pack_id, login_id).await
570    }
571
572    pub async fn list_pack_categories<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::ListPackCategoriesResponse>, Error<types::ListPackCategoriesResponse>> {
573        self.limiter.read.until_ready().await;
574        self.raw.list_pack_categories(pack_id).await
575    }
576
577    pub async fn add_pack_category<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::AddPackCategoryRequest) -> Result<ResponseValue<types::AddPackCategoryResponse>, Error<types::AddPackCategoryResponse>> {
578        self.limiter.write.until_ready().await;
579        self.raw.add_pack_category(pack_id, body).await
580    }
581
582    pub async fn delete_pack_category<'a>(&'a self, pack_id: ::std::num::NonZeroU64, category_name: &'a str) -> Result<ResponseValue<types::DeletePackCategoryResponse>, Error<types::DeletePackCategoryResponse>> {
583        self.limiter.write.until_ready().await;
584        self.raw.delete_pack_category(pack_id, category_name).await
585    }
586
587    pub async fn upload_pack_asset<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::UploadPackAssetRequest) -> Result<ResponseValue<types::PackAssetUploadInfo>, Error<types::UploadPackAssetResponse>> {
588        self.limiter.write.until_ready().await;
589        self.raw.upload_pack_asset(pack_id, body).await
590    }
591
592    pub async fn upload_pack_source_code<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::UploadPackSourceCodeRequest) -> Result<ResponseValue<types::PackSourceCodeUploadInfo>, Error<types::UploadPackSourceCodeResponse>> {
593        self.limiter.write.until_ready().await;
594        self.raw.upload_pack_source_code(pack_id, body).await
595    }
596
597    pub async fn pack_asset_upload_complete<'a>(&'a self, pack_id: ::std::num::NonZeroU64, pack_asset_id: &'a str, pack_asset_type: types::PackAssetType) -> Result<ResponseValue<types::PackAssetUploadCompleteResponse>, Error<types::PackAssetUploadCompleteResponse>> {
598        self.limiter.write.until_ready().await;
599        self.raw
600            .pack_asset_upload_complete(pack_id, pack_asset_id, pack_asset_type)
601            .await
602    }
603
604    pub async fn pack_source_code_upload_complete<'a>(&'a self, pack_id: ::std::num::NonZeroU64, pack_version: &'a str, body: &'a types::PackSourceCodeUploadCompleteRequest) -> Result<ResponseValue<types::PackSourceCodeUploadCompleteResponse>, Error<types::PackSourceCodeUploadCompleteResponse>> {
605        self.limiter.write.until_ready().await;
606        self.raw
607            .pack_source_code_upload_complete(pack_id, pack_version, body)
608            .await
609    }
610
611    pub async fn get_pack_source_code<'a>(&'a self, pack_id: ::std::num::NonZeroU64, pack_version: &'a str) -> Result<ResponseValue<types::PackSourceCodeInfo>, Error<types::GetPackSourceCodeResponse>> {
612        self.limiter.read.until_ready().await;
613        self.raw.get_pack_source_code(pack_id, pack_version).await
614    }
615
616    pub async fn list_pack_listings<'a>(&'a self, certified_agents_only: Option<bool>, direction: Option<types::SortDirection>, exclude_individual_acls: Option<bool>, exclude_public_packs: Option<bool>, exclude_workspace_acls: Option<bool>, install_context: Option<types::PackListingInstallContextType>, limit: Option<::std::num::NonZeroU64>, only_workspace_id: Option<&'a str>, order_by: Option<types::PackListingsSortBy>, pack_access_types: Option<&'a types::PackAccessTypes>, pack_entrypoint: Option<types::PackEntrypoint>, pack_ids: Option<&'a ::std::vec::Vec<i64>>, page_token: Option<&'a str>, parent_workspace_ids: Option<&'a ::std::vec::Vec<::std::string::String>>, sort_by: Option<types::PackListingsSortBy>) -> Result<ResponseValue<types::PackListingList>, Error<types::ListPackListingsResponse>> {
617        self.limiter.read.until_ready().await;
618        self.raw
619            .list_pack_listings(certified_agents_only, direction, exclude_individual_acls, exclude_public_packs, exclude_workspace_acls, install_context, limit, only_workspace_id, order_by, pack_access_types, pack_entrypoint, pack_ids, page_token, parent_workspace_ids, sort_by)
620            .await
621    }
622
623    pub async fn get_pack_listing<'a>(&'a self, pack_id: ::std::num::NonZeroU64, doc_id: Option<&'a str>, ingestion_id: Option<&'a str>, install_context: Option<types::PackListingInstallContextType>, release_channel: Option<types::IngestionPackReleaseChannel>, workspace_id: Option<&'a str>) -> Result<ResponseValue<types::PackListingDetail>, Error<types::GetPackListingResponse>> {
624        self.limiter.read.until_ready().await;
625        self.raw
626            .get_pack_listing(pack_id, doc_id, ingestion_id, install_context, release_channel, workspace_id)
627            .await
628    }
629
630    pub async fn list_pack_logs<'a>(&'a self, pack_id: ::std::num::NonZeroU64, doc_id: &'a str, after_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, before_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, limit: Option<::std::num::NonZeroU64>, log_types: Option<&'a ::std::vec::Vec<types::PackLogType>>, order: Option<types::ListPackLogsOrder>, page_token: Option<&'a str>, q: Option<&'a str>, request_ids: Option<&'a ::std::vec::Vec<::std::string::String>>) -> Result<ResponseValue<types::PackLogsList>, Error<types::ListPackLogsResponse>> {
631        self.limiter.read.until_ready().await;
632        self.raw
633            .list_pack_logs(pack_id, doc_id, after_timestamp, before_timestamp, limit, log_types, order, page_token, q, request_ids)
634            .await
635    }
636
637    pub async fn list_ingestion_logs<'a>(&'a self, pack_id: ::std::num::NonZeroU64, tenant_id: &'a str, root_ingestion_id: &'a ::uuid::Uuid, after_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, before_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, ingestion_execution_id: Option<&'a ::uuid::Uuid>, ingestion_status: Option<types::IngestionStatus>, limit: Option<::std::num::NonZeroU64>, log_types: Option<&'a ::std::vec::Vec<types::PackLogType>>, only_execution_completions: Option<bool>, order: Option<types::ListIngestionLogsOrder>, page_token: Option<&'a str>, q: Option<&'a str>, request_ids: Option<&'a ::std::vec::Vec<::std::string::String>>) -> Result<ResponseValue<types::PackLogsList>, Error<types::ListIngestionLogsResponse>> {
638        self.limiter.read.until_ready().await;
639        self.raw
640            .list_ingestion_logs(pack_id, tenant_id, root_ingestion_id, after_timestamp, before_timestamp, ingestion_execution_id, ingestion_status, limit, log_types, only_execution_completions, order, page_token, q, request_ids)
641            .await
642    }
643
644    pub async fn list_grouped_pack_logs<'a>(&'a self, pack_id: ::std::num::NonZeroU64, doc_id: &'a str, after_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, before_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, limit: Option<::std::num::NonZeroU64>, order: Option<types::ListGroupedPackLogsOrder>, page_token: Option<&'a str>, q: Option<&'a str>) -> Result<ResponseValue<types::GroupedPackLogsList>, Error<types::ListGroupedPackLogsResponse>> {
645        self.limiter.read.until_ready().await;
646        self.raw
647            .list_grouped_pack_logs(pack_id, doc_id, after_timestamp, before_timestamp, limit, order, page_token, q)
648            .await
649    }
650
651    pub async fn list_grouped_ingestion_logs<'a>(&'a self, pack_id: ::std::num::NonZeroU64, tenant_id: &'a str, root_ingestion_id: &'a ::uuid::Uuid, after_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, before_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, ingestion_execution_id: Option<&'a ::uuid::Uuid>, limit: Option<::std::num::NonZeroU64>, order: Option<types::ListGroupedIngestionLogsOrder>, page_token: Option<&'a str>, q: Option<&'a str>) -> Result<ResponseValue<types::GroupedPackLogsList>, Error<types::ListGroupedIngestionLogsResponse>> {
652        self.limiter.read.until_ready().await;
653        self.raw
654            .list_grouped_ingestion_logs(pack_id, tenant_id, root_ingestion_id, after_timestamp, before_timestamp, ingestion_execution_id, limit, order, page_token, q)
655            .await
656    }
657
658    pub async fn list_ingestion_batch_executions<'a>(&'a self, pack_id: ::std::num::NonZeroU64, tenant_id: &'a str, root_ingestion_id: &'a ::uuid::Uuid, datasource: Option<&'a str>, execution_type: Option<types::IngestionExecutionType>, include_deleted_ingestions: Option<bool>, ingestion_execution_id: Option<&'a str>, ingestion_id: Option<&'a str>, ingestion_status: Option<types::IngestionStatus>, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>) -> Result<ResponseValue<types::IngestionBatchExecutionsList>, Error<types::ListIngestionBatchExecutionsResponse>> {
659        self.limiter.read.until_ready().await;
660        self.raw
661            .list_ingestion_batch_executions(pack_id, tenant_id, root_ingestion_id, datasource, execution_type, include_deleted_ingestions, ingestion_execution_id, ingestion_id, ingestion_status, limit, page_token)
662            .await
663    }
664
665    pub async fn list_ingestion_parent_items<'a>(&'a self, pack_id: ::std::num::NonZeroU64, tenant_id: &'a str, root_ingestion_id: &'a ::uuid::Uuid, ingestion_execution_id: &'a ::uuid::Uuid, ingestion_id: &'a ::uuid::Uuid, ingestion_status: Option<types::IngestionStatus>, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>) -> Result<ResponseValue<types::IngestionParentItemsList>, Error<types::ListIngestionParentItemsResponse>> {
666        self.limiter.read.until_ready().await;
667        self.raw
668            .list_ingestion_parent_items(pack_id, tenant_id, root_ingestion_id, ingestion_execution_id, ingestion_id, ingestion_status, limit, page_token)
669            .await
670    }
671
672    pub async fn get_pack_log_details<'a>(&'a self, pack_id: ::std::num::NonZeroU64, tenant_id: &'a str, root_ingestion_id: &'a ::uuid::Uuid, log_id: &'a str, details_key: &'a str) -> Result<ResponseValue<types::PackLogDetails>, Error<types::GetPackLogDetailsResponse>> {
673        self.limiter.read.until_ready().await;
674        self.raw
675            .get_pack_log_details(pack_id, tenant_id, root_ingestion_id, log_id, details_key)
676            .await
677    }
678
679    pub async fn list_pack_featured_docs<'a>(&'a self, pack_id: ::std::num::NonZeroU64) -> Result<ResponseValue<types::PackFeaturedDocsResponse>, Error<types::ListPackFeaturedDocsResponse>> {
680        self.limiter.read.until_ready().await;
681        self.raw.list_pack_featured_docs(pack_id).await
682    }
683
684    pub async fn update_pack_featured_docs<'a>(&'a self, pack_id: ::std::num::NonZeroU64, body: &'a types::UpdatePackFeaturedDocsRequest) -> Result<ResponseValue<types::UpdatePackFeaturedDocsResponse>, Error<types::UpdatePackFeaturedDocsResponse>> {
685        self.limiter.write.until_ready().await;
686        self.raw.update_pack_featured_docs(pack_id, body).await
687    }
688
689    pub async fn add_go_link<'a>(&'a self, organization_id: &'a str, body: &'a types::AddGoLinkRequest) -> Result<ResponseValue<types::AddGoLinkResult>, Error<types::AddGoLinkResponse>> {
690        self.limiter.write.until_ready().await;
691        self.raw.add_go_link(organization_id, body).await
692    }
693
694    pub async fn list_agent_session_ids<'a>(&'a self, tenant_id: &'a str, agent_instance_id: &'a ::uuid::Uuid, after_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, agent_session_id: Option<&'a ::uuid::Uuid>, before_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, limit: Option<::std::num::NonZeroU64>, log_types: Option<&'a ::std::vec::Vec<types::PackLogType>>, order: Option<types::ListAgentSessionIdsOrder>, page_token: Option<&'a str>, q: Option<&'a str>, request_ids: Option<&'a ::std::vec::Vec<::std::string::String>>) -> Result<ResponseValue<types::PackLogsList>, Error<types::ListAgentSessionIdsResponse>> {
695        self.limiter.read.until_ready().await;
696        self.raw
697            .list_agent_session_ids(tenant_id, agent_instance_id, after_timestamp, agent_session_id, before_timestamp, limit, log_types, order, page_token, q, request_ids)
698            .await
699    }
700
701    pub async fn list_agent_logs<'a>(&'a self, tenant_id: &'a str, agent_instance_id: &'a ::uuid::Uuid, after_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, agent_session_id: Option<&'a ::uuid::Uuid>, before_timestamp: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>, limit: Option<::std::num::NonZeroU64>, log_types: Option<&'a ::std::vec::Vec<types::PackLogType>>, order: Option<types::ListAgentLogsOrder>, page_token: Option<&'a str>, q: Option<&'a str>, request_ids: Option<&'a ::std::vec::Vec<::std::string::String>>) -> Result<ResponseValue<types::PackLogsList>, Error<types::ListAgentLogsResponse>> {
702        self.limiter.read.until_ready().await;
703        self.raw
704            .list_agent_logs(tenant_id, agent_instance_id, after_timestamp, agent_session_id, before_timestamp, limit, log_types, order, page_token, q, request_ids)
705            .await
706    }
707
708    pub async fn get_agent_pack_log_details<'a>(&'a self, tenant_id: &'a str, agent_instance_id: &'a ::uuid::Uuid, log_id: &'a str, details_key: &'a str) -> Result<ResponseValue<types::PackLogDetails>, Error<types::GetAgentPackLogDetailsResponse>> {
709        self.limiter.read.until_ready().await;
710        self.raw
711            .get_agent_pack_log_details(tenant_id, agent_instance_id, log_id, details_key)
712            .await
713    }
714    pub async fn table_refs(&self, doc_id: &str) -> Result<Vec<TableReference>, Error<types::ListTablesResponse>> {
715        paginate_all(move |page_token| async move {
716            self.list_tables(doc_id, None, page_token.as_deref(), None, None)
717                .await
718                .map(|response| response.into_inner())
719        })
720        .await
721    }
722
723    pub async fn tables(&self, doc_id: &str) -> Result<Vec<Table>, ClientTablesError> {
724        use ClientTablesError::*;
725        let table_refs = handle!(self.table_refs(doc_id).await, ListTablesFailed);
726        let mut all_tables = Vec::new();
727        for table_ref in table_refs {
728            let table_response = handle!(self.get_table(doc_id, &table_ref.id, None).await, GetTableFailed);
729            all_tables.push(table_response.into_inner());
730        }
731        Ok(all_tables)
732    }
733
734    pub async fn columns_map(&self, doc_id: &str, table_ids: impl IntoIterator<Item = TableId>) -> Result<HashMap<TableId, Vec<Column>>, Error<types::ListColumnsResponse>> {
735        let mut columns_map = HashMap::new();
736
737        for table_id in table_ids {
738            let table_id_ref = table_id.as_ref();
739            let columns = paginate_all(move |page_token| async move {
740                self.list_columns(doc_id, table_id_ref, None, page_token.as_deref(), None)
741                    .await
742                    .map(|response| response.into_inner())
743            })
744            .await?;
745
746            columns_map.insert(table_id, columns);
747        }
748
749        Ok(columns_map)
750    }
751
752    #[allow(clippy::too_many_arguments)]
753    pub async fn rows(&self, doc_id: &str, table_id: &str, query: Option<&str>, sort_by: Option<types::RowsSortBy>, sync_token: Option<&str>, use_column_names: Option<bool>, value_format: Option<types::ValueFormat>) -> Result<Vec<Row>, Error<types::ListRowsResponse>> {
754        paginate_all(move |page_token| async move {
755            self.list_rows(doc_id, table_id, None, page_token.as_deref(), query, sort_by, sync_token, use_column_names, value_format, None)
756                .await
757                .map(|response| response.into_inner())
758        })
759        .await
760    }
761
762    #[allow(clippy::too_many_arguments)]
763    pub async fn list_rows_correct<'a, T: DeserializeOwned + ValueFormatProvider>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, limit: Option<::std::num::NonZeroU64>, page_token: Option<&'a str>, query: Option<&'a str>, sort_by: Option<types::RowsSortBy>, sync_token: Option<&'a str>, use_column_names: Option<bool>, visible_only: Option<bool>) -> Result<ResponseValue<ItemsList<T>>, Error<types::ListRowsResponse>> {
764        self.limiter.read.until_ready().await;
765        self.raw
766            .list_rows_correct(doc_id, table_id_or_name, limit, page_token, query, sort_by, sync_token, use_column_names, visible_only)
767            .await
768    }
769
770    #[allow(clippy::too_many_arguments)]
771    pub async fn rows_correct<T: DeserializeOwned + ValueFormatProvider + Clone>(&self, doc_id: &str, table_id: &str, query: Option<&str>, sort_by: Option<types::RowsSortBy>, sync_token: Option<&str>, use_column_names: Option<bool>, visible_only: Option<bool>) -> Result<Vec<T>, Error<types::ListRowsResponse>> {
772        paginate_all(move |page_token| async move {
773            self.list_rows_correct(doc_id, table_id, None, page_token.as_deref(), query, sort_by, sync_token, use_column_names, visible_only)
774                .await
775                .map(|response| response.into_inner())
776        })
777        .await
778    }
779
780    #[allow(clippy::too_many_arguments)]
781    pub async fn rows_map(&self, doc_id: &str, table_ids: impl IntoIterator<Item = TableId>, query: Option<&str>, sort_by: Option<types::RowsSortBy>, sync_token: Option<&str>, use_column_names: Option<bool>, value_format: Option<types::ValueFormat>) -> Result<HashMap<TableId, Vec<Row>>, Error<types::ListRowsResponse>> {
782        let rows_futures = table_ids.into_iter().map(|table_id| async move {
783            let rows = self
784                .rows(doc_id, &table_id, query, sort_by, sync_token, use_column_names, value_format)
785                .await?;
786            Ok::<(TableId, Vec<Row>), Error<types::ListRowsResponse>>((table_id, rows))
787        });
788
789        let mut rows_map = HashMap::new();
790
791        for future in rows_futures {
792            let (table_id, rows) = future.await?;
793            rows_map.insert(table_id, rows);
794        }
795
796        Ok(rows_map)
797    }
798
799    pub async fn upsert_rows_correct<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, disable_parsing: Option<bool>, body: &'a types::RowsUpsert) -> Result<ResponseValue<RowsUpsertResultCorrect>, Error<types::UpsertRowsResponse>> {
800        self.limiter.write_doc_content.until_ready().await;
801        self.raw
802            .upsert_rows_correct(doc_id, table_id_or_name, disable_parsing, body)
803            .await
804    }
805
806    pub async fn upsert_rows_conclusively<'a, T: DeserializeOwned + ValueFormatProvider>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, disable_parsing: Option<bool>, body: &'a types::RowsUpsert, max_attempts: usize, delay_secs: u64) -> Result<UpsertRowsConclusivelyResult<T>, UpsertRowsConclusivelyError> {
807        use UpsertRowsConclusivelyError::*;
808
809        let upsert_result = handle!(
810            self.upsert_rows_correct(doc_id, table_id_or_name, disable_parsing, body)
811                .await,
812            UpsertFailed
813        )
814        .into_inner();
815
816        let row_ids = upsert_result.added_row_ids.clone();
817        let items = handle!(
818            self.wait_for_upserted_rows(doc_id, table_id_or_name, &row_ids, max_attempts, delay_secs)
819                .await,
820            EnsureRowsVisibleFailed,
821            request_id: upsert_result.request_id.clone(),
822            row_ids
823        );
824
825        Ok(UpsertRowsConclusivelyResult {
826            upsert_result,
827            items,
828        })
829    }
830
831    /// NOTE: This function works only for inserted rows, not for updated rows (it will always return after the first request for them)
832    pub async fn wait_for_upserted_rows<T: DeserializeOwned + ValueFormatProvider>(&self, doc_id: &str, table_id: &str, row_ids: &[String], max_attempts: usize, delay_secs: u64) -> Result<Vec<T>, WaitForRowsError> {
833        use WaitForRowsError::*;
834
835        if row_ids.is_empty() {
836            return Ok(Vec::new());
837        }
838
839        // initialize manually because T is not Clone
840        let mut rows: Vec<Option<T>> = Vec::with_capacity(row_ids.len());
841        for _ in row_ids {
842            rows.push(None);
843        }
844
845        let delay = Duration::from_secs(delay_secs);
846        let mut attempt = 0;
847
848        while attempt < max_attempts {
849            attempt += 1;
850
851            for (index, row_id) in row_ids.iter().enumerate() {
852                if rows[index].is_some() {
853                    continue;
854                }
855
856                let row_result = self
857                    .get_row_correct::<T>(doc_id, table_id, row_id, None)
858                    .await;
859                match row_result {
860                    Ok(row) => rows[index] = Some(row.into_inner()),
861                    Err(error) => {
862                        let status = error.status().map(|code| code.as_u16());
863                        if matches!(status, Some(404)) {
864                            continue;
865                        }
866                        return Err(RequestFailed {
867                            attempt,
868                            row_id: row_id.clone(),
869                            source: Box::new(error),
870                        });
871                    }
872                }
873            }
874
875            if rows.iter().all(Option::is_some) {
876                break;
877            }
878
879            sleep(delay).await;
880        }
881
882        if rows.iter().any(Option::is_none) {
883            let missing_row_ids = row_ids
884                .iter()
885                .enumerate()
886                .filter(|(index, _)| rows[*index].is_none())
887                .map(|(_, row_id)| row_id.clone())
888                .collect();
889            return Err(RowsMissing {
890                attempts: max_attempts,
891                missing_row_ids,
892            });
893        }
894
895        Ok(rows.into_iter().flatten().collect())
896    }
897
898    pub async fn update_row_correct<'a>(&'a self, doc_id: &'a str, table_id_or_name: &'a str, row_id_or_name: &'a str, disable_parsing: Option<bool>, body: &'a types::RowUpdate) -> Result<ResponseValue<RowUpdateResultCorrect>, Error<types::UpdateRowResponse>> {
899        self.limiter.write_doc_content.until_ready().await;
900        self.raw
901            .update_row_correct(doc_id, table_id_or_name, row_id_or_name, disable_parsing, body)
902            .await
903    }
904}
905
906#[derive(Debug)]
907pub struct UpsertRowsConclusivelyResult<T> {
908    pub upsert_result: RowsUpsertResultCorrect,
909    pub items: Vec<T>,
910}
911
912#[derive(Error, Debug)]
913pub enum UpsertRowsConclusivelyError {
914    #[error("failed to upsert rows")]
915    UpsertFailed { source: Error<types::UpsertRowsResponse> },
916    #[error("failed to ensure rows '{row_ids:?}' are visible for request '{request_id}'")]
917    EnsureRowsVisibleFailed { request_id: String, row_ids: Vec<String>, source: WaitForRowsError },
918}
919
920#[derive(Debug)]
921pub struct UpsertRowsConclusivelyRichResult {
922    pub upsert_result: RowsUpsertResultCorrect,
923    pub rows: Vec<RichRow>,
924}
925
926#[derive(Error, Debug)]
927pub enum UpsertRowsConclusivelyRichError {
928    #[error("failed to upsert rows")]
929    UpsertRowsConclusivelyFailed { source: UpsertRowsConclusivelyError },
930    // TODO: Failed to list rich rows
931    // #[error("failed to ensure rows '{row_ids:?}' are visible for request '{request_id}'")]
932    // EnsureRowsVisibleFailed { request_id: String, row_ids: Vec<String>, source: WaitForRowsError },
933}
934
935#[derive(Error, Debug)]
936pub enum WaitForRowsError {
937    #[error("get row '{row_id}' attempt {attempt} failed")]
938    RequestFailed { attempt: usize, row_id: String, source: Box<Error<types::GetRowResponse>> },
939    #[error("rows '{missing_row_ids:?}' did not appear after {attempts} attempts")]
940    RowsMissing { attempts: usize, missing_row_ids: Vec<String> },
941}
coda_api/client.rs

coda_api/
client.rs
