lodestone_client/
generated.rs

1//! @generated by scripts/proofs/native-api/generate-rust-client.py; do not edit by hand.
2
3use lodestone_wire::*;
4
5use crate::{CallOptions, Client, ClientError};
6
7pub const RUST_CLIENT_METHOD_COUNT: usize = 99;
8pub(crate) const MAX_NATIVE_REQUEST_BYTES: usize = 2097152;
9pub(crate) const MAX_NATIVE_RESPONSE_BYTES: usize = 2097152;
10
11#[derive(Clone, Debug, Eq, PartialEq)]
12pub(crate) enum GeneratedCollectionIndexRef {
13    None,
14    Caller,
15    Exact(String),
16}
17
18pub const fn request_command(request: &RequestBody) -> Command {
19    match request {
20        RequestBody::Discover(_) => Command::Discover,
21        RequestBody::ListIndexes(_) => Command::ListIndexes,
22        RequestBody::GetIndex(_) => Command::GetIndex,
23        RequestBody::ValidateIndexChange(_) => Command::ValidateIndexChange,
24        RequestBody::ApplyIndexChange(_) => Command::ApplyIndexChange,
25        RequestBody::ApplyAdministrationMutation(_) => Command::ApplyAdministrationMutation,
26        RequestBody::ListAliases(_) => Command::ListAliases,
27        RequestBody::GetAlias(_) => Command::GetAlias,
28        RequestBody::ListDataStreams(_) => Command::ListDataStreams,
29        RequestBody::GetDataStream(_) => Command::GetDataStream,
30        RequestBody::ListComponentTemplates(_) => Command::ListComponentTemplates,
31        RequestBody::GetComponentTemplate(_) => Command::GetComponentTemplate,
32        RequestBody::ListIndexTemplates(_) => Command::ListIndexTemplates,
33        RequestBody::GetIndexTemplate(_) => Command::GetIndexTemplate,
34        RequestBody::ListIngestPipelines(_) => Command::ListIngestPipelines,
35        RequestBody::GetIngestPipeline(_) => Command::GetIngestPipeline,
36        RequestBody::SimulateIngestPipeline(_) => Command::SimulateIngestPipeline,
37        RequestBody::ReprocessByQuery(_) => Command::ReprocessByQuery,
38        RequestBody::ListLifecyclePolicies(_) => Command::ListLifecyclePolicies,
39        RequestBody::GetLifecyclePolicy(_) => Command::GetLifecyclePolicy,
40        RequestBody::PrepareCreateIndex(_) => Command::PrepareCreateIndex,
41        RequestBody::PrepareDeleteIndex(_) => Command::PrepareDeleteIndex,
42        RequestBody::SubmitCatalogAction(_) => Command::SubmitCatalogAction,
43        RequestBody::ResolveCatalogAction(_) => Command::ResolveCatalogAction,
44        RequestBody::PrepareReplayableSourceIndex(_) => Command::PrepareReplayableSourceIndex,
45        RequestBody::SubmitReplayableSourceIndex(_) => Command::SubmitReplayableSourceIndex,
46        RequestBody::GetReplayableSource(_) => Command::GetReplayableSource,
47        RequestBody::ControlReplayableSource(_) => Command::ControlReplayableSource,
48        RequestBody::CloneIndex(_) => Command::CloneIndex,
49        RequestBody::ConfigureHistory(_) => Command::ConfigureHistory,
50        RequestBody::GetHistory(_) => Command::GetHistory,
51        RequestBody::ResolveHistory(_) => Command::ResolveHistory,
52        RequestBody::PlaceHistoryHold(_) => Command::PlaceHistoryHold,
53        RequestBody::ReleaseHistoryHold(_) => Command::ReleaseHistoryHold,
54        RequestBody::PrepareDocumentMutation(_) => Command::PrepareDocumentMutation,
55        RequestBody::SubmitDocumentMutation(_) => Command::SubmitDocumentMutation,
56        RequestBody::PrepareDocumentBulk(_) => Command::PrepareDocumentBulk,
57        RequestBody::SubmitDocumentBulk(_) => Command::SubmitDocumentBulk,
58        RequestBody::ResolveDocumentBulk(_) => Command::ResolveDocumentBulk,
59        RequestBody::PrepareAppendBulk(_) => Command::PrepareAppendBulk,
60        RequestBody::SubmitAppendBulk(_) => Command::SubmitAppendBulk,
61        RequestBody::ResolveAppendBulk(_) => Command::ResolveAppendBulk,
62        RequestBody::ObserveAppendCommitted(_) => Command::ObserveAppendCommitted,
63        RequestBody::ResolveDocumentMutation(_) => Command::ResolveDocumentMutation,
64        RequestBody::GetDocument(_) => Command::GetDocument,
65        RequestBody::Search(_) => Command::Search,
66        RequestBody::OpenPit(_) => Command::OpenPit,
67        RequestBody::RenewPit(_) => Command::RenewPit,
68        RequestBody::ClosePit(_) => Command::ClosePit,
69        RequestBody::ListOperations(_) => Command::ListOperations,
70        RequestBody::GetOperation(_) => Command::GetOperation,
71        RequestBody::CancelOperation(_) => Command::CancelOperation,
72        RequestBody::ListAuditEvents(_) => Command::ListAuditEvents,
73        RequestBody::ExportAuditEvents(_) => Command::ExportAuditEvents,
74        RequestBody::ReserveServiceCredential(_) => Command::ReserveServiceCredential,
75        RequestBody::ReserveServiceCredentialRotation(_) => Command::ReserveServiceCredentialRotation,
76        RequestBody::ActivateServiceCredential(_) => Command::ActivateServiceCredential,
77        RequestBody::ResolveServiceCredentialReservation(_) => Command::ResolveServiceCredentialReservation,
78        RequestBody::PrepareRevokeServiceCredential(_) => Command::PrepareRevokeServiceCredential,
79        RequestBody::RevokeServiceCredential(_) => Command::RevokeServiceCredential,
80        RequestBody::ResolveSecurityAction(_) => Command::ResolveSecurityAction,
81        RequestBody::GetSecurityRole(_) => Command::GetSecurityRole,
82        RequestBody::PrepareRoleAppendAccessChange(_) => Command::PrepareRoleAppendAccessChange,
83        RequestBody::SubmitRoleAppendAccessChange(_) => Command::SubmitRoleAppendAccessChange,
84        RequestBody::ListServiceCredentials(_) => Command::ListServiceCredentials,
85        RequestBody::ListBackups(_) => Command::ListBackups,
86        RequestBody::GetBackup(_) => Command::GetBackup,
87        RequestBody::CreateBackup(_) => Command::CreateBackup,
88        RequestBody::ResolveBackupAction(_) => Command::ResolveBackupAction,
89        RequestBody::GetRuntimeStatus(_) => Command::GetRuntimeStatus,
90        RequestBody::GetResultCacheStatus(_) => Command::GetResultCacheStatus,
91        RequestBody::GetFieldPromotionStatus(_) => Command::GetFieldPromotionStatus,
92        RequestBody::GetOverloadStatus(_) => Command::GetOverloadStatus,
93        RequestBody::ConfigureExternalKey(_) => Command::ConfigureExternalKey,
94        RequestBody::RotateExternalKeyBinding(_) => Command::RotateExternalKeyBinding,
95        RequestBody::ConfigureAggregateThenDelete(_) => Command::ConfigureAggregateThenDelete,
96        RequestBody::GetLifecycleStatus(_) => Command::GetLifecycleStatus,
97        RequestBody::GetQuota(_) => Command::GetQuota,
98        RequestBody::UpdateQuota(_) => Command::UpdateQuota,
99        RequestBody::GetBinding(_) => Command::GetBinding,
100        RequestBody::GetAdmissionStatus(_) => Command::GetAdmissionStatus,
101        RequestBody::SetAdmission(_) => Command::SetAdmission,
102        RequestBody::GetQuiesceStatus(_) => Command::GetQuiesceStatus,
103        RequestBody::GetDecommissionReadiness(_) => Command::GetDecommissionReadiness,
104        RequestBody::GetUpgradeReadiness(_) => Command::GetUpgradeReadiness,
105        RequestBody::GetMaintenanceStatus(_) => Command::GetMaintenanceStatus,
106        RequestBody::GetRestoreReadiness(_) => Command::GetRestoreReadiness,
107        RequestBody::WarmVectorIndex(_) => Command::WarmVectorIndex,
108        RequestBody::EvaluateVectorRecall(_) => Command::EvaluateVectorRecall,
109        RequestBody::CalibrateVectorStrategy(_) => Command::CalibrateVectorStrategy,
110        RequestBody::GetVectorDiagnostic(_) => Command::GetVectorDiagnostic,
111        RequestBody::CreateDiagnostic(_) => Command::CreateDiagnostic,
112        RequestBody::GetDiagnostic(_) => Command::GetDiagnostic,
113        RequestBody::ReadArtifactChunk(_) => Command::ReadArtifactChunk,
114        RequestBody::ExportUsage(_) => Command::ExportUsage,
115        RequestBody::ExecuteStateRead(_) => Command::ExecuteStateRead,
116        RequestBody::PrepareStateWrite(_) => Command::PrepareStateWrite,
117        RequestBody::SubmitStateWrite(_) => Command::SubmitStateWrite,
118        RequestBody::ResolveStateWrite(_) => Command::ResolveStateWrite,
119    }
120}
121
122pub(crate) fn request_collection_index_ref(request: &RequestBody) -> Result<GeneratedCollectionIndexRef, ClientError> {
123    match request {
124        RequestBody::Discover(_) => Ok(GeneratedCollectionIndexRef::None),
125        RequestBody::ListIndexes(_) => Ok(GeneratedCollectionIndexRef::None),
126        RequestBody::GetIndex(_) => Ok(GeneratedCollectionIndexRef::None),
127        RequestBody::ValidateIndexChange(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
128        RequestBody::ApplyIndexChange(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
129        RequestBody::ApplyAdministrationMutation(_) => Ok(GeneratedCollectionIndexRef::None),
130        RequestBody::ListAliases(_) => Ok(GeneratedCollectionIndexRef::None),
131        RequestBody::GetAlias(_) => Ok(GeneratedCollectionIndexRef::None),
132        RequestBody::ListDataStreams(_) => Ok(GeneratedCollectionIndexRef::None),
133        RequestBody::GetDataStream(_) => Ok(GeneratedCollectionIndexRef::None),
134        RequestBody::ListComponentTemplates(_) => Ok(GeneratedCollectionIndexRef::None),
135        RequestBody::GetComponentTemplate(_) => Ok(GeneratedCollectionIndexRef::None),
136        RequestBody::ListIndexTemplates(_) => Ok(GeneratedCollectionIndexRef::None),
137        RequestBody::GetIndexTemplate(_) => Ok(GeneratedCollectionIndexRef::None),
138        RequestBody::ListIngestPipelines(_) => Ok(GeneratedCollectionIndexRef::None),
139        RequestBody::GetIngestPipeline(_) => Ok(GeneratedCollectionIndexRef::None),
140        RequestBody::SimulateIngestPipeline(_) => Ok(GeneratedCollectionIndexRef::None),
141        RequestBody::ReprocessByQuery(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
142        RequestBody::ListLifecyclePolicies(_) => Ok(GeneratedCollectionIndexRef::None),
143        RequestBody::GetLifecyclePolicy(_) => Ok(GeneratedCollectionIndexRef::None),
144        RequestBody::PrepareCreateIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
145        RequestBody::PrepareDeleteIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
146        RequestBody::SubmitCatalogAction(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
147        RequestBody::ResolveCatalogAction(_) => Ok(GeneratedCollectionIndexRef::Caller),
148        RequestBody::PrepareReplayableSourceIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
149        RequestBody::SubmitReplayableSourceIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
150        RequestBody::GetReplayableSource(_) => Ok(GeneratedCollectionIndexRef::None),
151        RequestBody::ControlReplayableSource(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
152        RequestBody::CloneIndex(_) => Ok(GeneratedCollectionIndexRef::Caller),
153        RequestBody::ConfigureHistory(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
154        RequestBody::GetHistory(_) => Ok(GeneratedCollectionIndexRef::None),
155        RequestBody::ResolveHistory(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
156        RequestBody::PlaceHistoryHold(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
157        RequestBody::ReleaseHistoryHold(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
158        RequestBody::PrepareDocumentMutation(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
159        RequestBody::SubmitDocumentMutation(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
160        RequestBody::PrepareDocumentBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
161        RequestBody::SubmitDocumentBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
162        RequestBody::ResolveDocumentBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
163        RequestBody::PrepareAppendBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
164        RequestBody::SubmitAppendBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
165        RequestBody::ResolveAppendBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
166        RequestBody::ObserveAppendCommitted(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
167        RequestBody::ResolveDocumentMutation(_) => Ok(GeneratedCollectionIndexRef::Caller),
168        RequestBody::GetDocument(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
169        RequestBody::Search(value) => value.indexes.as_deref().map_or(
170            Ok(GeneratedCollectionIndexRef::None),
171            generated_uniform_collection_index_ref,
172        ),
173        RequestBody::OpenPit(value) => generated_uniform_collection_index_ref(&value.indexes),
174        RequestBody::RenewPit(_) => Ok(GeneratedCollectionIndexRef::None),
175        RequestBody::ClosePit(_) => Ok(GeneratedCollectionIndexRef::None),
176        RequestBody::ListOperations(_) => Ok(GeneratedCollectionIndexRef::None),
177        RequestBody::GetOperation(_) => Ok(GeneratedCollectionIndexRef::None),
178        RequestBody::CancelOperation(_) => Ok(GeneratedCollectionIndexRef::None),
179        RequestBody::ListAuditEvents(_) => Ok(GeneratedCollectionIndexRef::None),
180        RequestBody::ExportAuditEvents(_) => Ok(GeneratedCollectionIndexRef::None),
181        RequestBody::ReserveServiceCredential(_) => Ok(GeneratedCollectionIndexRef::None),
182        RequestBody::ReserveServiceCredentialRotation(_) => Ok(GeneratedCollectionIndexRef::None),
183        RequestBody::ActivateServiceCredential(_) => Ok(GeneratedCollectionIndexRef::None),
184        RequestBody::ResolveServiceCredentialReservation(_) => Ok(GeneratedCollectionIndexRef::None),
185        RequestBody::PrepareRevokeServiceCredential(_) => Ok(GeneratedCollectionIndexRef::None),
186        RequestBody::RevokeServiceCredential(_) => Ok(GeneratedCollectionIndexRef::None),
187        RequestBody::ResolveSecurityAction(_) => Ok(GeneratedCollectionIndexRef::None),
188        RequestBody::GetSecurityRole(_) => Ok(GeneratedCollectionIndexRef::None),
189        RequestBody::PrepareRoleAppendAccessChange(_) => Ok(GeneratedCollectionIndexRef::None),
190        RequestBody::SubmitRoleAppendAccessChange(_) => Ok(GeneratedCollectionIndexRef::None),
191        RequestBody::ListServiceCredentials(_) => Ok(GeneratedCollectionIndexRef::None),
192        RequestBody::ListBackups(_) => Ok(GeneratedCollectionIndexRef::None),
193        RequestBody::GetBackup(_) => Ok(GeneratedCollectionIndexRef::None),
194        RequestBody::CreateBackup(_) => Ok(GeneratedCollectionIndexRef::None),
195        RequestBody::ResolveBackupAction(_) => Ok(GeneratedCollectionIndexRef::None),
196        RequestBody::GetRuntimeStatus(_) => Ok(GeneratedCollectionIndexRef::None),
197        RequestBody::GetResultCacheStatus(_) => Ok(GeneratedCollectionIndexRef::None),
198        RequestBody::GetFieldPromotionStatus(_) => Ok(GeneratedCollectionIndexRef::None),
199        RequestBody::GetOverloadStatus(_) => Ok(GeneratedCollectionIndexRef::None),
200        RequestBody::ConfigureExternalKey(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
201        RequestBody::RotateExternalKeyBinding(value) => {
202            Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone()))
203        }
204        RequestBody::ConfigureAggregateThenDelete(value) => {
205            Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone()))
206        }
207        RequestBody::GetLifecycleStatus(_) => Ok(GeneratedCollectionIndexRef::None),
208        RequestBody::GetQuota(_) => Ok(GeneratedCollectionIndexRef::None),
209        RequestBody::UpdateQuota(_) => Ok(GeneratedCollectionIndexRef::None),
210        RequestBody::GetBinding(_) => Ok(GeneratedCollectionIndexRef::None),
211        RequestBody::GetAdmissionStatus(_) => Ok(GeneratedCollectionIndexRef::None),
212        RequestBody::SetAdmission(_) => Ok(GeneratedCollectionIndexRef::None),
213        RequestBody::GetQuiesceStatus(_) => Ok(GeneratedCollectionIndexRef::None),
214        RequestBody::GetDecommissionReadiness(_) => Ok(GeneratedCollectionIndexRef::None),
215        RequestBody::GetUpgradeReadiness(_) => Ok(GeneratedCollectionIndexRef::None),
216        RequestBody::GetMaintenanceStatus(value) => {
217            Ok(value.index.as_ref().map_or(GeneratedCollectionIndexRef::None, |index| {
218                GeneratedCollectionIndexRef::Exact(index.name.clone())
219            }))
220        }
221        RequestBody::GetRestoreReadiness(_) => Ok(GeneratedCollectionIndexRef::None),
222        RequestBody::WarmVectorIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
223        RequestBody::EvaluateVectorRecall(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
224        RequestBody::CalibrateVectorStrategy(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
225        RequestBody::GetVectorDiagnostic(_) => Ok(GeneratedCollectionIndexRef::None),
226        RequestBody::CreateDiagnostic(_) => Ok(GeneratedCollectionIndexRef::None),
227        RequestBody::GetDiagnostic(_) => Ok(GeneratedCollectionIndexRef::None),
228        RequestBody::ReadArtifactChunk(_) => Ok(GeneratedCollectionIndexRef::None),
229        RequestBody::ExportUsage(_) => Ok(GeneratedCollectionIndexRef::None),
230        RequestBody::ExecuteStateRead(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
231        RequestBody::PrepareStateWrite(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
232        RequestBody::SubmitStateWrite(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
233        RequestBody::ResolveStateWrite(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
234    }
235}
236
237fn generated_uniform_collection_index_ref(indexes: &[Resource]) -> Result<GeneratedCollectionIndexRef, ClientError> {
238    if indexes.is_empty() {
239        return Err(ClientError::CollectionIndexRefRequired);
240    }
241    if indexes
242        .iter()
243        .enumerate()
244        .any(|(position, index)| indexes[..position].contains(index))
245    {
246        return Err(ClientError::CollectionIndexRefMismatch);
247    }
248    Ok(GeneratedCollectionIndexRef::None)
249}
250
251impl Client {
252    /// Calls the generated `discover` Lodestone API command.
253    pub async fn discover(
254        &self,
255        request: DiscoverRequest,
256        options: CallOptions,
257    ) -> Result<DiscoverResult, ClientError> {
258        match self.call(RequestBody::Discover(request), options).await? {
259            ResultBody::Discover(result) => Ok(result),
260            _ => Err(ClientError::ResponseCommandMismatch),
261        }
262    }
263
264    /// Calls the generated `list_indexes` Lodestone API command.
265    pub async fn list_indexes(
266        &self,
267        request: ListIndexesRequest,
268        options: CallOptions,
269    ) -> Result<ListIndexesResult, ClientError> {
270        match self.call(RequestBody::ListIndexes(request), options).await? {
271            ResultBody::ListIndexes(result) => Ok(result),
272            _ => Err(ClientError::ResponseCommandMismatch),
273        }
274    }
275
276    /// Calls the generated `get_index` Lodestone API command.
277    pub async fn get_index(
278        &self,
279        request: GetIndexRequest,
280        options: CallOptions,
281    ) -> Result<GetIndexResult, ClientError> {
282        match self.call(RequestBody::GetIndex(request), options).await? {
283            ResultBody::GetIndex(result) => Ok(result),
284            _ => Err(ClientError::ResponseCommandMismatch),
285        }
286    }
287
288    /// Calls the generated `validate_index_change` Lodestone API command.
289    pub async fn validate_index_change(
290        &self,
291        request: ValidateIndexChangeRequest,
292        options: CallOptions,
293    ) -> Result<ValidateIndexChangeResult, ClientError> {
294        match self.call(RequestBody::ValidateIndexChange(request), options).await? {
295            ResultBody::ValidateIndexChange(result) => Ok(result),
296            _ => Err(ClientError::ResponseCommandMismatch),
297        }
298    }
299
300    /// Calls the generated `apply_index_change` Lodestone API command.
301    pub async fn apply_index_change(
302        &self,
303        request: ApplyIndexChangeRequest,
304        options: CallOptions,
305    ) -> Result<ApplyIndexChangeResult, ClientError> {
306        match self.call(RequestBody::ApplyIndexChange(request), options).await? {
307            ResultBody::ApplyIndexChange(result) => Ok(result),
308            _ => Err(ClientError::ResponseCommandMismatch),
309        }
310    }
311
312    /// Calls the generated `apply_administration_mutation` Lodestone API command.
313    pub async fn apply_administration_mutation(
314        &self,
315        request: ApplyAdministrationMutationRequest,
316        options: CallOptions,
317    ) -> Result<ApplyAdministrationMutationResult, ClientError> {
318        match self
319            .call(RequestBody::ApplyAdministrationMutation(request), options)
320            .await?
321        {
322            ResultBody::ApplyAdministrationMutation(result) => Ok(result),
323            _ => Err(ClientError::ResponseCommandMismatch),
324        }
325    }
326
327    /// Calls the generated `list_aliases` Lodestone API command.
328    pub async fn list_aliases(
329        &self,
330        request: ListAliasesRequest,
331        options: CallOptions,
332    ) -> Result<ListAliasesResult, ClientError> {
333        match self.call(RequestBody::ListAliases(request), options).await? {
334            ResultBody::ListAliases(result) => Ok(result),
335            _ => Err(ClientError::ResponseCommandMismatch),
336        }
337    }
338
339    /// Calls the generated `get_alias` Lodestone API command.
340    pub async fn get_alias(
341        &self,
342        request: GetAliasRequest,
343        options: CallOptions,
344    ) -> Result<GetAliasResult, ClientError> {
345        match self.call(RequestBody::GetAlias(request), options).await? {
346            ResultBody::GetAlias(result) => Ok(result),
347            _ => Err(ClientError::ResponseCommandMismatch),
348        }
349    }
350
351    /// Calls the generated `list_data_streams` Lodestone API command.
352    pub async fn list_data_streams(
353        &self,
354        request: ListDataStreamsRequest,
355        options: CallOptions,
356    ) -> Result<ListDataStreamsResult, ClientError> {
357        match self.call(RequestBody::ListDataStreams(request), options).await? {
358            ResultBody::ListDataStreams(result) => Ok(result),
359            _ => Err(ClientError::ResponseCommandMismatch),
360        }
361    }
362
363    /// Calls the generated `get_data_stream` Lodestone API command.
364    pub async fn get_data_stream(
365        &self,
366        request: GetDataStreamRequest,
367        options: CallOptions,
368    ) -> Result<GetDataStreamResult, ClientError> {
369        match self.call(RequestBody::GetDataStream(request), options).await? {
370            ResultBody::GetDataStream(result) => Ok(result),
371            _ => Err(ClientError::ResponseCommandMismatch),
372        }
373    }
374
375    /// Calls the generated `list_component_templates` Lodestone API command.
376    pub async fn list_component_templates(
377        &self,
378        request: ListComponentTemplatesRequest,
379        options: CallOptions,
380    ) -> Result<ListComponentTemplatesResult, ClientError> {
381        match self.call(RequestBody::ListComponentTemplates(request), options).await? {
382            ResultBody::ListComponentTemplates(result) => Ok(result),
383            _ => Err(ClientError::ResponseCommandMismatch),
384        }
385    }
386
387    /// Calls the generated `get_component_template` Lodestone API command.
388    pub async fn get_component_template(
389        &self,
390        request: GetComponentTemplateRequest,
391        options: CallOptions,
392    ) -> Result<GetComponentTemplateResult, ClientError> {
393        match self.call(RequestBody::GetComponentTemplate(request), options).await? {
394            ResultBody::GetComponentTemplate(result) => Ok(result),
395            _ => Err(ClientError::ResponseCommandMismatch),
396        }
397    }
398
399    /// Calls the generated `list_index_templates` Lodestone API command.
400    pub async fn list_index_templates(
401        &self,
402        request: ListIndexTemplatesRequest,
403        options: CallOptions,
404    ) -> Result<ListIndexTemplatesResult, ClientError> {
405        match self.call(RequestBody::ListIndexTemplates(request), options).await? {
406            ResultBody::ListIndexTemplates(result) => Ok(result),
407            _ => Err(ClientError::ResponseCommandMismatch),
408        }
409    }
410
411    /// Calls the generated `get_index_template` Lodestone API command.
412    pub async fn get_index_template(
413        &self,
414        request: GetIndexTemplateRequest,
415        options: CallOptions,
416    ) -> Result<GetIndexTemplateResult, ClientError> {
417        match self.call(RequestBody::GetIndexTemplate(request), options).await? {
418            ResultBody::GetIndexTemplate(result) => Ok(result),
419            _ => Err(ClientError::ResponseCommandMismatch),
420        }
421    }
422
423    /// Calls the generated `list_ingest_pipelines` Lodestone API command.
424    pub async fn list_ingest_pipelines(
425        &self,
426        request: ListIngestPipelinesRequest,
427        options: CallOptions,
428    ) -> Result<ListIngestPipelinesResult, ClientError> {
429        match self.call(RequestBody::ListIngestPipelines(request), options).await? {
430            ResultBody::ListIngestPipelines(result) => Ok(result),
431            _ => Err(ClientError::ResponseCommandMismatch),
432        }
433    }
434
435    /// Calls the generated `get_ingest_pipeline` Lodestone API command.
436    pub async fn get_ingest_pipeline(
437        &self,
438        request: GetIngestPipelineRequest,
439        options: CallOptions,
440    ) -> Result<GetIngestPipelineResult, ClientError> {
441        match self.call(RequestBody::GetIngestPipeline(request), options).await? {
442            ResultBody::GetIngestPipeline(result) => Ok(result),
443            _ => Err(ClientError::ResponseCommandMismatch),
444        }
445    }
446
447    /// Calls the generated `simulate_ingest_pipeline` Lodestone API command.
448    pub async fn simulate_ingest_pipeline(
449        &self,
450        request: SimulateIngestPipelineRequest,
451        options: CallOptions,
452    ) -> Result<SimulateIngestPipelineResult, ClientError> {
453        match self.call(RequestBody::SimulateIngestPipeline(request), options).await? {
454            ResultBody::SimulateIngestPipeline(result) => Ok(result),
455            _ => Err(ClientError::ResponseCommandMismatch),
456        }
457    }
458
459    /// Calls the generated `reprocess_by_query` Lodestone API command.
460    pub async fn reprocess_by_query(
461        &self,
462        request: ReprocessByQueryRequest,
463        options: CallOptions,
464    ) -> Result<ReprocessByQueryResult, ClientError> {
465        match self.call(RequestBody::ReprocessByQuery(request), options).await? {
466            ResultBody::ReprocessByQuery(result) => Ok(result),
467            _ => Err(ClientError::ResponseCommandMismatch),
468        }
469    }
470
471    /// Calls the generated `list_lifecycle_policies` Lodestone API command.
472    pub async fn list_lifecycle_policies(
473        &self,
474        request: ListLifecyclePoliciesRequest,
475        options: CallOptions,
476    ) -> Result<ListLifecyclePoliciesResult, ClientError> {
477        match self.call(RequestBody::ListLifecyclePolicies(request), options).await? {
478            ResultBody::ListLifecyclePolicies(result) => Ok(result),
479            _ => Err(ClientError::ResponseCommandMismatch),
480        }
481    }
482
483    /// Calls the generated `get_lifecycle_policy` Lodestone API command.
484    pub async fn get_lifecycle_policy(
485        &self,
486        request: GetLifecyclePolicyRequest,
487        options: CallOptions,
488    ) -> Result<GetLifecyclePolicyResult, ClientError> {
489        match self.call(RequestBody::GetLifecyclePolicy(request), options).await? {
490            ResultBody::GetLifecyclePolicy(result) => Ok(result),
491            _ => Err(ClientError::ResponseCommandMismatch),
492        }
493    }
494
495    /// Calls the generated `prepare_create_index` Lodestone API command.
496    pub async fn prepare_create_index(
497        &self,
498        request: PrepareCreateIndexRequest,
499        options: CallOptions,
500    ) -> Result<PrepareCreateIndexResult, ClientError> {
501        match self.call(RequestBody::PrepareCreateIndex(request), options).await? {
502            ResultBody::PrepareCreateIndex(result) => Ok(result),
503            _ => Err(ClientError::ResponseCommandMismatch),
504        }
505    }
506
507    /// Calls the generated `prepare_delete_index` Lodestone API command.
508    pub async fn prepare_delete_index(
509        &self,
510        request: PrepareDeleteIndexRequest,
511        options: CallOptions,
512    ) -> Result<PrepareDeleteIndexResult, ClientError> {
513        match self.call(RequestBody::PrepareDeleteIndex(request), options).await? {
514            ResultBody::PrepareDeleteIndex(result) => Ok(result),
515            _ => Err(ClientError::ResponseCommandMismatch),
516        }
517    }
518
519    /// Calls the generated `submit_catalog_action` Lodestone API command.
520    pub async fn submit_catalog_action(
521        &self,
522        request: SubmitCatalogActionRequest,
523        options: CallOptions,
524    ) -> Result<SubmitCatalogActionResult, ClientError> {
525        match self.call(RequestBody::SubmitCatalogAction(request), options).await? {
526            ResultBody::SubmitCatalogAction(result) => Ok(result),
527            _ => Err(ClientError::ResponseCommandMismatch),
528        }
529    }
530
531    /// Calls the generated `resolve_catalog_action` Lodestone API command.
532    pub async fn resolve_catalog_action(
533        &self,
534        request: ResolveCatalogActionRequest,
535        options: CallOptions,
536    ) -> Result<ResolveCatalogActionResult, ClientError> {
537        match self.call(RequestBody::ResolveCatalogAction(request), options).await? {
538            ResultBody::ResolveCatalogAction(result) => Ok(result),
539            _ => Err(ClientError::ResponseCommandMismatch),
540        }
541    }
542
543    /// Calls the generated `prepare_replayable_source_index` Lodestone API command.
544    pub async fn prepare_replayable_source_index(
545        &self,
546        request: PrepareReplayableSourceIndexRequest,
547        options: CallOptions,
548    ) -> Result<PrepareReplayableSourceIndexResult, ClientError> {
549        match self
550            .call(RequestBody::PrepareReplayableSourceIndex(request), options)
551            .await?
552        {
553            ResultBody::PrepareReplayableSourceIndex(result) => Ok(result),
554            _ => Err(ClientError::ResponseCommandMismatch),
555        }
556    }
557
558    /// Calls the generated `submit_replayable_source_index` Lodestone API command.
559    pub async fn submit_replayable_source_index(
560        &self,
561        request: SubmitReplayableSourceIndexRequest,
562        options: CallOptions,
563    ) -> Result<SubmitReplayableSourceIndexResult, ClientError> {
564        match self
565            .call(RequestBody::SubmitReplayableSourceIndex(request), options)
566            .await?
567        {
568            ResultBody::SubmitReplayableSourceIndex(result) => Ok(result),
569            _ => Err(ClientError::ResponseCommandMismatch),
570        }
571    }
572
573    /// Calls the generated `get_replayable_source` Lodestone API command.
574    pub async fn get_replayable_source(
575        &self,
576        request: GetReplayableSourceRequest,
577        options: CallOptions,
578    ) -> Result<GetReplayableSourceResult, ClientError> {
579        match self.call(RequestBody::GetReplayableSource(request), options).await? {
580            ResultBody::GetReplayableSource(result) => Ok(result),
581            _ => Err(ClientError::ResponseCommandMismatch),
582        }
583    }
584
585    /// Calls the generated `control_replayable_source` Lodestone API command.
586    pub async fn control_replayable_source(
587        &self,
588        request: ControlReplayableSourceRequest,
589        options: CallOptions,
590    ) -> Result<ControlReplayableSourceResult, ClientError> {
591        match self
592            .call(RequestBody::ControlReplayableSource(request), options)
593            .await?
594        {
595            ResultBody::ControlReplayableSource(result) => Ok(result),
596            _ => Err(ClientError::ResponseCommandMismatch),
597        }
598    }
599
600    /// Calls the generated `clone_index` Lodestone API command.
601    pub async fn clone_index(
602        &self,
603        request: CloneIndexRequest,
604        options: CallOptions,
605    ) -> Result<CloneIndexResult, ClientError> {
606        match self.call(RequestBody::CloneIndex(request), options).await? {
607            ResultBody::CloneIndex(result) => Ok(result),
608            _ => Err(ClientError::ResponseCommandMismatch),
609        }
610    }
611
612    /// Calls the generated `configure_history` Lodestone API command.
613    pub async fn configure_history(
614        &self,
615        request: ConfigureHistoryRequest,
616        options: CallOptions,
617    ) -> Result<ConfigureHistoryResult, ClientError> {
618        match self.call(RequestBody::ConfigureHistory(request), options).await? {
619            ResultBody::ConfigureHistory(result) => Ok(result),
620            _ => Err(ClientError::ResponseCommandMismatch),
621        }
622    }
623
624    /// Calls the generated `get_history` Lodestone API command.
625    pub async fn get_history(
626        &self,
627        request: GetHistoryRequest,
628        options: CallOptions,
629    ) -> Result<GetHistoryResult, ClientError> {
630        match self.call(RequestBody::GetHistory(request), options).await? {
631            ResultBody::GetHistory(result) => Ok(result),
632            _ => Err(ClientError::ResponseCommandMismatch),
633        }
634    }
635
636    /// Calls the generated `resolve_history` Lodestone API command.
637    pub async fn resolve_history(
638        &self,
639        request: ResolveHistoryRequest,
640        options: CallOptions,
641    ) -> Result<ResolveHistoryResult, ClientError> {
642        match self.call(RequestBody::ResolveHistory(request), options).await? {
643            ResultBody::ResolveHistory(result) => Ok(result),
644            _ => Err(ClientError::ResponseCommandMismatch),
645        }
646    }
647
648    /// Calls the generated `place_history_hold` Lodestone API command.
649    pub async fn place_history_hold(
650        &self,
651        request: PlaceHistoryHoldRequest,
652        options: CallOptions,
653    ) -> Result<PlaceHistoryHoldResult, ClientError> {
654        match self.call(RequestBody::PlaceHistoryHold(request), options).await? {
655            ResultBody::PlaceHistoryHold(result) => Ok(result),
656            _ => Err(ClientError::ResponseCommandMismatch),
657        }
658    }
659
660    /// Calls the generated `release_history_hold` Lodestone API command.
661    pub async fn release_history_hold(
662        &self,
663        request: ReleaseHistoryHoldRequest,
664        options: CallOptions,
665    ) -> Result<ReleaseHistoryHoldResult, ClientError> {
666        match self.call(RequestBody::ReleaseHistoryHold(request), options).await? {
667            ResultBody::ReleaseHistoryHold(result) => Ok(result),
668            _ => Err(ClientError::ResponseCommandMismatch),
669        }
670    }
671
672    /// Calls the generated `prepare_document_mutation` Lodestone API command.
673    pub async fn prepare_document_mutation(
674        &self,
675        request: PrepareDocumentMutationRequest,
676        options: CallOptions,
677    ) -> Result<PrepareDocumentMutationResult, ClientError> {
678        match self
679            .call(RequestBody::PrepareDocumentMutation(request), options)
680            .await?
681        {
682            ResultBody::PrepareDocumentMutation(result) => Ok(result),
683            _ => Err(ClientError::ResponseCommandMismatch),
684        }
685    }
686
687    /// Calls the generated `submit_document_mutation` Lodestone API command.
688    pub async fn submit_document_mutation(
689        &self,
690        request: SubmitDocumentMutationRequest,
691        options: CallOptions,
692    ) -> Result<SubmitDocumentMutationResult, ClientError> {
693        match self.call(RequestBody::SubmitDocumentMutation(request), options).await? {
694            ResultBody::SubmitDocumentMutation(result) => Ok(result),
695            _ => Err(ClientError::ResponseCommandMismatch),
696        }
697    }
698
699    /// Calls the generated `prepare_document_bulk` Lodestone API command.
700    pub async fn prepare_document_bulk(
701        &self,
702        request: PrepareDocumentBulkRequest,
703        options: CallOptions,
704    ) -> Result<PrepareDocumentBulkResult, ClientError> {
705        match self.call(RequestBody::PrepareDocumentBulk(request), options).await? {
706            ResultBody::PrepareDocumentBulk(result) => Ok(result),
707            _ => Err(ClientError::ResponseCommandMismatch),
708        }
709    }
710
711    /// Calls the generated `submit_document_bulk` Lodestone API command.
712    pub async fn submit_document_bulk(
713        &self,
714        request: SubmitDocumentBulkRequest,
715        options: CallOptions,
716    ) -> Result<SubmitDocumentBulkResult, ClientError> {
717        match self.call(RequestBody::SubmitDocumentBulk(request), options).await? {
718            ResultBody::SubmitDocumentBulk(result) => Ok(result),
719            _ => Err(ClientError::ResponseCommandMismatch),
720        }
721    }
722
723    /// Calls the generated `resolve_document_bulk` Lodestone API command.
724    pub async fn resolve_document_bulk(
725        &self,
726        request: ResolveDocumentBulkRequest,
727        options: CallOptions,
728    ) -> Result<ResolveDocumentBulkResult, ClientError> {
729        match self.call(RequestBody::ResolveDocumentBulk(request), options).await? {
730            ResultBody::ResolveDocumentBulk(result) => Ok(result),
731            _ => Err(ClientError::ResponseCommandMismatch),
732        }
733    }
734
735    /// Calls the generated `prepare_append_bulk` Lodestone API command.
736    pub async fn prepare_append_bulk(
737        &self,
738        request: PrepareAppendBulkRequest,
739        options: CallOptions,
740    ) -> Result<PrepareAppendBulkResult, ClientError> {
741        match self.call(RequestBody::PrepareAppendBulk(request), options).await? {
742            ResultBody::PrepareAppendBulk(result) => Ok(result),
743            _ => Err(ClientError::ResponseCommandMismatch),
744        }
745    }
746
747    /// Calls the generated `submit_append_bulk` Lodestone API command.
748    pub async fn submit_append_bulk(
749        &self,
750        request: SubmitAppendBulkRequest,
751        options: CallOptions,
752    ) -> Result<SubmitAppendBulkResult, ClientError> {
753        match self.call(RequestBody::SubmitAppendBulk(request), options).await? {
754            ResultBody::SubmitAppendBulk(result) => Ok(result),
755            _ => Err(ClientError::ResponseCommandMismatch),
756        }
757    }
758
759    /// Calls the generated `resolve_append_bulk` Lodestone API command.
760    pub async fn resolve_append_bulk(
761        &self,
762        request: ResolveAppendBulkRequest,
763        options: CallOptions,
764    ) -> Result<ResolveAppendBulkResult, ClientError> {
765        match self.call(RequestBody::ResolveAppendBulk(request), options).await? {
766            ResultBody::ResolveAppendBulk(result) => Ok(result),
767            _ => Err(ClientError::ResponseCommandMismatch),
768        }
769    }
770
771    /// Calls the generated `observe_append_committed` Lodestone API command.
772    pub async fn observe_append_committed(
773        &self,
774        request: ObserveAppendCommittedRequest,
775        options: CallOptions,
776    ) -> Result<ObserveAppendCommittedResult, ClientError> {
777        match self.call(RequestBody::ObserveAppendCommitted(request), options).await? {
778            ResultBody::ObserveAppendCommitted(result) => Ok(result),
779            _ => Err(ClientError::ResponseCommandMismatch),
780        }
781    }
782
783    /// Calls the generated `resolve_document_mutation` Lodestone API command.
784    pub async fn resolve_document_mutation(
785        &self,
786        request: ResolveDocumentMutationRequest,
787        options: CallOptions,
788    ) -> Result<ResolveDocumentMutationResult, ClientError> {
789        match self
790            .call(RequestBody::ResolveDocumentMutation(request), options)
791            .await?
792        {
793            ResultBody::ResolveDocumentMutation(result) => Ok(result),
794            _ => Err(ClientError::ResponseCommandMismatch),
795        }
796    }
797
798    /// Calls the generated `get_document` Lodestone API command.
799    pub async fn get_document(
800        &self,
801        request: GetDocumentRequest,
802        options: CallOptions,
803    ) -> Result<GetDocumentResult, ClientError> {
804        match self.call(RequestBody::GetDocument(request), options).await? {
805            ResultBody::GetDocument(result) => Ok(result),
806            _ => Err(ClientError::ResponseCommandMismatch),
807        }
808    }
809
810    /// Calls the generated `search` Lodestone API command.
811    pub async fn search(&self, request: SearchRequest, options: CallOptions) -> Result<SearchResult, ClientError> {
812        match self.call(RequestBody::Search(request), options).await? {
813            ResultBody::Search(result) => Ok(result),
814            _ => Err(ClientError::ResponseCommandMismatch),
815        }
816    }
817
818    /// Calls the generated `open_pit` Lodestone API command.
819    pub async fn open_pit(&self, request: OpenPitRequest, options: CallOptions) -> Result<OpenPitResult, ClientError> {
820        match self.call(RequestBody::OpenPit(request), options).await? {
821            ResultBody::OpenPit(result) => Ok(result),
822            _ => Err(ClientError::ResponseCommandMismatch),
823        }
824    }
825
826    /// Calls the generated `renew_pit` Lodestone API command.
827    pub async fn renew_pit(
828        &self,
829        request: RenewPitRequest,
830        options: CallOptions,
831    ) -> Result<RenewPitResult, ClientError> {
832        match self.call(RequestBody::RenewPit(request), options).await? {
833            ResultBody::RenewPit(result) => Ok(result),
834            _ => Err(ClientError::ResponseCommandMismatch),
835        }
836    }
837
838    /// Calls the generated `close_pit` Lodestone API command.
839    pub async fn close_pit(
840        &self,
841        request: ClosePitRequest,
842        options: CallOptions,
843    ) -> Result<ClosePitResult, ClientError> {
844        match self.call(RequestBody::ClosePit(request), options).await? {
845            ResultBody::ClosePit(result) => Ok(result),
846            _ => Err(ClientError::ResponseCommandMismatch),
847        }
848    }
849
850    /// Calls the generated `list_operations` Lodestone API command.
851    pub async fn list_operations(
852        &self,
853        request: ListOperationsRequest,
854        options: CallOptions,
855    ) -> Result<ListOperationsResult, ClientError> {
856        match self.call(RequestBody::ListOperations(request), options).await? {
857            ResultBody::ListOperations(result) => Ok(result),
858            _ => Err(ClientError::ResponseCommandMismatch),
859        }
860    }
861
862    /// Calls the generated `get_operation` Lodestone API command.
863    pub async fn get_operation(
864        &self,
865        request: GetOperationRequest,
866        options: CallOptions,
867    ) -> Result<GetOperationResult, ClientError> {
868        match self.call(RequestBody::GetOperation(request), options).await? {
869            ResultBody::GetOperation(result) => Ok(result),
870            _ => Err(ClientError::ResponseCommandMismatch),
871        }
872    }
873
874    /// Calls the generated `cancel_operation` Lodestone API command.
875    pub async fn cancel_operation(
876        &self,
877        request: CancelOperationRequest,
878        options: CallOptions,
879    ) -> Result<CancelOperationResult, ClientError> {
880        match self.call(RequestBody::CancelOperation(request), options).await? {
881            ResultBody::CancelOperation(result) => Ok(result),
882            _ => Err(ClientError::ResponseCommandMismatch),
883        }
884    }
885
886    /// Calls the generated `list_audit_events` Lodestone API command.
887    pub async fn list_audit_events(
888        &self,
889        request: ListAuditEventsRequest,
890        options: CallOptions,
891    ) -> Result<ListAuditEventsResult, ClientError> {
892        match self.call(RequestBody::ListAuditEvents(request), options).await? {
893            ResultBody::ListAuditEvents(result) => Ok(result),
894            _ => Err(ClientError::ResponseCommandMismatch),
895        }
896    }
897
898    /// Calls the generated `export_audit_events` Lodestone API command.
899    pub async fn export_audit_events(
900        &self,
901        request: ExportAuditEventsRequest,
902        options: CallOptions,
903    ) -> Result<ExportAuditEventsResult, ClientError> {
904        match self.call(RequestBody::ExportAuditEvents(request), options).await? {
905            ResultBody::ExportAuditEvents(result) => Ok(result),
906            _ => Err(ClientError::ResponseCommandMismatch),
907        }
908    }
909
910    /// Calls the generated `reserve_service_credential` Lodestone API command.
911    pub async fn reserve_service_credential(
912        &self,
913        request: ReserveServiceCredentialRequest,
914        options: CallOptions,
915    ) -> Result<ReserveServiceCredentialResult, ClientError> {
916        match self
917            .call(RequestBody::ReserveServiceCredential(request), options)
918            .await?
919        {
920            ResultBody::ReserveServiceCredential(result) => Ok(result),
921            _ => Err(ClientError::ResponseCommandMismatch),
922        }
923    }
924
925    /// Calls the generated `reserve_service_credential_rotation` Lodestone API command.
926    pub async fn reserve_service_credential_rotation(
927        &self,
928        request: ReserveServiceCredentialRotationRequest,
929        options: CallOptions,
930    ) -> Result<ReserveServiceCredentialRotationResult, ClientError> {
931        match self
932            .call(RequestBody::ReserveServiceCredentialRotation(request), options)
933            .await?
934        {
935            ResultBody::ReserveServiceCredentialRotation(result) => Ok(result),
936            _ => Err(ClientError::ResponseCommandMismatch),
937        }
938    }
939
940    /// Calls the generated `activate_service_credential` Lodestone API command.
941    pub async fn activate_service_credential(
942        &self,
943        request: ActivateServiceCredentialRequest,
944        options: CallOptions,
945    ) -> Result<ActivateServiceCredentialResult, ClientError> {
946        match self
947            .call(RequestBody::ActivateServiceCredential(request), options)
948            .await?
949        {
950            ResultBody::ActivateServiceCredential(result) => Ok(result),
951            _ => Err(ClientError::ResponseCommandMismatch),
952        }
953    }
954
955    /// Calls the generated `resolve_service_credential_reservation` Lodestone API command.
956    pub async fn resolve_service_credential_reservation(
957        &self,
958        request: ResolveServiceCredentialReservationRequest,
959        options: CallOptions,
960    ) -> Result<ResolveServiceCredentialReservationResult, ClientError> {
961        match self
962            .call(RequestBody::ResolveServiceCredentialReservation(request), options)
963            .await?
964        {
965            ResultBody::ResolveServiceCredentialReservation(result) => Ok(result),
966            _ => Err(ClientError::ResponseCommandMismatch),
967        }
968    }
969
970    /// Calls the generated `prepare_revoke_service_credential` Lodestone API command.
971    pub async fn prepare_revoke_service_credential(
972        &self,
973        request: PrepareRevokeServiceCredentialRequest,
974        options: CallOptions,
975    ) -> Result<PrepareRevokeServiceCredentialResult, ClientError> {
976        match self
977            .call(RequestBody::PrepareRevokeServiceCredential(request), options)
978            .await?
979        {
980            ResultBody::PrepareRevokeServiceCredential(result) => Ok(result),
981            _ => Err(ClientError::ResponseCommandMismatch),
982        }
983    }
984
985    /// Calls the generated `revoke_service_credential` Lodestone API command.
986    pub async fn revoke_service_credential(
987        &self,
988        request: RevokeServiceCredentialRequest,
989        options: CallOptions,
990    ) -> Result<RevokeServiceCredentialResult, ClientError> {
991        match self
992            .call(RequestBody::RevokeServiceCredential(request), options)
993            .await?
994        {
995            ResultBody::RevokeServiceCredential(result) => Ok(result),
996            _ => Err(ClientError::ResponseCommandMismatch),
997        }
998    }
999
1000    /// Calls the generated `resolve_security_action` Lodestone API command.
1001    pub async fn resolve_security_action(
1002        &self,
1003        request: ResolveSecurityActionRequest,
1004        options: CallOptions,
1005    ) -> Result<ResolveSecurityActionResult, ClientError> {
1006        match self.call(RequestBody::ResolveSecurityAction(request), options).await? {
1007            ResultBody::ResolveSecurityAction(result) => Ok(result),
1008            _ => Err(ClientError::ResponseCommandMismatch),
1009        }
1010    }
1011
1012    /// Calls the generated `get_security_role` Lodestone API command.
1013    pub async fn get_security_role(
1014        &self,
1015        request: GetSecurityRoleRequest,
1016        options: CallOptions,
1017    ) -> Result<GetSecurityRoleResult, ClientError> {
1018        match self.call(RequestBody::GetSecurityRole(request), options).await? {
1019            ResultBody::GetSecurityRole(result) => Ok(result),
1020            _ => Err(ClientError::ResponseCommandMismatch),
1021        }
1022    }
1023
1024    /// Calls the generated `prepare_role_append_access_change` Lodestone API command.
1025    pub async fn prepare_role_append_access_change(
1026        &self,
1027        request: PrepareRoleAppendAccessChangeRequest,
1028        options: CallOptions,
1029    ) -> Result<PrepareRoleAppendAccessChangeResult, ClientError> {
1030        match self
1031            .call(RequestBody::PrepareRoleAppendAccessChange(request), options)
1032            .await?
1033        {
1034            ResultBody::PrepareRoleAppendAccessChange(result) => Ok(result),
1035            _ => Err(ClientError::ResponseCommandMismatch),
1036        }
1037    }
1038
1039    /// Calls the generated `submit_role_append_access_change` Lodestone API command.
1040    pub async fn submit_role_append_access_change(
1041        &self,
1042        request: SubmitRoleAppendAccessChangeRequest,
1043        options: CallOptions,
1044    ) -> Result<SubmitRoleAppendAccessChangeResult, ClientError> {
1045        match self
1046            .call(RequestBody::SubmitRoleAppendAccessChange(request), options)
1047            .await?
1048        {
1049            ResultBody::SubmitRoleAppendAccessChange(result) => Ok(result),
1050            _ => Err(ClientError::ResponseCommandMismatch),
1051        }
1052    }
1053
1054    /// Calls the generated `list_service_credentials` Lodestone API command.
1055    pub async fn list_service_credentials(
1056        &self,
1057        request: ListServiceCredentialsRequest,
1058        options: CallOptions,
1059    ) -> Result<ListServiceCredentialsResult, ClientError> {
1060        match self.call(RequestBody::ListServiceCredentials(request), options).await? {
1061            ResultBody::ListServiceCredentials(result) => Ok(result),
1062            _ => Err(ClientError::ResponseCommandMismatch),
1063        }
1064    }
1065
1066    /// Calls the generated `list_backups` Lodestone API command.
1067    pub async fn list_backups(
1068        &self,
1069        request: ListBackupsRequest,
1070        options: CallOptions,
1071    ) -> Result<ListBackupsResult, ClientError> {
1072        match self.call(RequestBody::ListBackups(request), options).await? {
1073            ResultBody::ListBackups(result) => Ok(result),
1074            _ => Err(ClientError::ResponseCommandMismatch),
1075        }
1076    }
1077
1078    /// Calls the generated `get_backup` Lodestone API command.
1079    pub async fn get_backup(
1080        &self,
1081        request: GetBackupRequest,
1082        options: CallOptions,
1083    ) -> Result<GetBackupResult, ClientError> {
1084        match self.call(RequestBody::GetBackup(request), options).await? {
1085            ResultBody::GetBackup(result) => Ok(result),
1086            _ => Err(ClientError::ResponseCommandMismatch),
1087        }
1088    }
1089
1090    /// Calls the generated `create_backup` Lodestone API command.
1091    pub async fn create_backup(
1092        &self,
1093        request: CreateBackupRequest,
1094        options: CallOptions,
1095    ) -> Result<CreateBackupResult, ClientError> {
1096        match self.call(RequestBody::CreateBackup(request), options).await? {
1097            ResultBody::CreateBackup(result) => Ok(result),
1098            _ => Err(ClientError::ResponseCommandMismatch),
1099        }
1100    }
1101
1102    /// Calls the generated `resolve_backup_action` Lodestone API command.
1103    pub async fn resolve_backup_action(
1104        &self,
1105        request: ResolveBackupActionRequest,
1106        options: CallOptions,
1107    ) -> Result<ResolveBackupActionResult, ClientError> {
1108        match self.call(RequestBody::ResolveBackupAction(request), options).await? {
1109            ResultBody::ResolveBackupAction(result) => Ok(result),
1110            _ => Err(ClientError::ResponseCommandMismatch),
1111        }
1112    }
1113
1114    /// Calls the generated `get_runtime_status` Lodestone API command.
1115    pub async fn get_runtime_status(
1116        &self,
1117        request: GetRuntimeStatusRequest,
1118        options: CallOptions,
1119    ) -> Result<GetRuntimeStatusResult, ClientError> {
1120        match self.call(RequestBody::GetRuntimeStatus(request), options).await? {
1121            ResultBody::GetRuntimeStatus(result) => Ok(result),
1122            _ => Err(ClientError::ResponseCommandMismatch),
1123        }
1124    }
1125
1126    /// Calls the generated `get_result_cache_status` Lodestone API command.
1127    pub async fn get_result_cache_status(
1128        &self,
1129        request: GetResultCacheStatusRequest,
1130        options: CallOptions,
1131    ) -> Result<GetResultCacheStatusResult, ClientError> {
1132        match self.call(RequestBody::GetResultCacheStatus(request), options).await? {
1133            ResultBody::GetResultCacheStatus(result) => Ok(result),
1134            _ => Err(ClientError::ResponseCommandMismatch),
1135        }
1136    }
1137
1138    /// Calls the generated `get_field_promotion_status` Lodestone API command.
1139    pub async fn get_field_promotion_status(
1140        &self,
1141        request: GetFieldPromotionStatusRequest,
1142        options: CallOptions,
1143    ) -> Result<GetFieldPromotionStatusResult, ClientError> {
1144        match self
1145            .call(RequestBody::GetFieldPromotionStatus(request), options)
1146            .await?
1147        {
1148            ResultBody::GetFieldPromotionStatus(result) => Ok(result),
1149            _ => Err(ClientError::ResponseCommandMismatch),
1150        }
1151    }
1152
1153    /// Calls the generated `get_overload_status` Lodestone API command.
1154    pub async fn get_overload_status(
1155        &self,
1156        request: GetOverloadStatusRequest,
1157        options: CallOptions,
1158    ) -> Result<GetOverloadStatusResult, ClientError> {
1159        match self.call(RequestBody::GetOverloadStatus(request), options).await? {
1160            ResultBody::GetOverloadStatus(result) => Ok(result),
1161            _ => Err(ClientError::ResponseCommandMismatch),
1162        }
1163    }
1164
1165    /// Calls the generated `configure_external_key` Lodestone API command.
1166    pub async fn configure_external_key(
1167        &self,
1168        request: ConfigureExternalKeyRequest,
1169        options: CallOptions,
1170    ) -> Result<ConfigureExternalKeyResult, ClientError> {
1171        match self.call(RequestBody::ConfigureExternalKey(request), options).await? {
1172            ResultBody::ConfigureExternalKey(result) => Ok(result),
1173            _ => Err(ClientError::ResponseCommandMismatch),
1174        }
1175    }
1176
1177    /// Calls the generated `rotate_external_key_binding` Lodestone API command.
1178    pub async fn rotate_external_key_binding(
1179        &self,
1180        request: RotateExternalKeyBindingRequest,
1181        options: CallOptions,
1182    ) -> Result<RotateExternalKeyBindingResult, ClientError> {
1183        match self
1184            .call(RequestBody::RotateExternalKeyBinding(request), options)
1185            .await?
1186        {
1187            ResultBody::RotateExternalKeyBinding(result) => Ok(result),
1188            _ => Err(ClientError::ResponseCommandMismatch),
1189        }
1190    }
1191
1192    /// Calls the generated `configure_aggregate_then_delete` Lodestone API command.
1193    pub async fn configure_aggregate_then_delete(
1194        &self,
1195        request: ConfigureAggregateThenDeleteRequest,
1196        options: CallOptions,
1197    ) -> Result<ConfigureAggregateThenDeleteResult, ClientError> {
1198        match self
1199            .call(RequestBody::ConfigureAggregateThenDelete(request), options)
1200            .await?
1201        {
1202            ResultBody::ConfigureAggregateThenDelete(result) => Ok(result),
1203            _ => Err(ClientError::ResponseCommandMismatch),
1204        }
1205    }
1206
1207    /// Calls the generated `get_lifecycle_status` Lodestone API command.
1208    pub async fn get_lifecycle_status(
1209        &self,
1210        request: GetLifecycleStatusRequest,
1211        options: CallOptions,
1212    ) -> Result<GetLifecycleStatusResult, ClientError> {
1213        match self.call(RequestBody::GetLifecycleStatus(request), options).await? {
1214            ResultBody::GetLifecycleStatus(result) => Ok(result),
1215            _ => Err(ClientError::ResponseCommandMismatch),
1216        }
1217    }
1218
1219    /// Calls the generated `get_quota` Lodestone API command.
1220    pub async fn get_quota(
1221        &self,
1222        request: GetQuotaRequest,
1223        options: CallOptions,
1224    ) -> Result<GetQuotaResult, ClientError> {
1225        match self.call(RequestBody::GetQuota(request), options).await? {
1226            ResultBody::GetQuota(result) => Ok(result),
1227            _ => Err(ClientError::ResponseCommandMismatch),
1228        }
1229    }
1230
1231    /// Calls the generated `update_quota` Lodestone API command.
1232    pub async fn update_quota(
1233        &self,
1234        request: UpdateQuotaRequest,
1235        options: CallOptions,
1236    ) -> Result<UpdateQuotaResult, ClientError> {
1237        match self.call(RequestBody::UpdateQuota(request), options).await? {
1238            ResultBody::UpdateQuota(result) => Ok(result),
1239            _ => Err(ClientError::ResponseCommandMismatch),
1240        }
1241    }
1242
1243    /// Calls the generated `get_binding` Lodestone API command.
1244    pub async fn get_binding(
1245        &self,
1246        request: GetBindingRequest,
1247        options: CallOptions,
1248    ) -> Result<GetBindingResult, ClientError> {
1249        match self.call(RequestBody::GetBinding(request), options).await? {
1250            ResultBody::GetBinding(result) => Ok(result),
1251            _ => Err(ClientError::ResponseCommandMismatch),
1252        }
1253    }
1254
1255    /// Calls the generated `get_admission_status` Lodestone API command.
1256    pub async fn get_admission_status(
1257        &self,
1258        request: GetAdmissionStatusRequest,
1259        options: CallOptions,
1260    ) -> Result<GetAdmissionStatusResult, ClientError> {
1261        match self.call(RequestBody::GetAdmissionStatus(request), options).await? {
1262            ResultBody::GetAdmissionStatus(result) => Ok(result),
1263            _ => Err(ClientError::ResponseCommandMismatch),
1264        }
1265    }
1266
1267    /// Calls the generated `set_admission` Lodestone API command.
1268    pub async fn set_admission(
1269        &self,
1270        request: SetAdmissionRequest,
1271        options: CallOptions,
1272    ) -> Result<SetAdmissionResult, ClientError> {
1273        match self.call(RequestBody::SetAdmission(request), options).await? {
1274            ResultBody::SetAdmission(result) => Ok(result),
1275            _ => Err(ClientError::ResponseCommandMismatch),
1276        }
1277    }
1278
1279    /// Calls the generated `get_quiesce_status` Lodestone API command.
1280    pub async fn get_quiesce_status(
1281        &self,
1282        request: GetQuiesceStatusRequest,
1283        options: CallOptions,
1284    ) -> Result<GetQuiesceStatusResult, ClientError> {
1285        match self.call(RequestBody::GetQuiesceStatus(request), options).await? {
1286            ResultBody::GetQuiesceStatus(result) => Ok(result),
1287            _ => Err(ClientError::ResponseCommandMismatch),
1288        }
1289    }
1290
1291    /// Calls the generated `get_decommission_readiness` Lodestone API command.
1292    pub async fn get_decommission_readiness(
1293        &self,
1294        request: GetDecommissionReadinessRequest,
1295        options: CallOptions,
1296    ) -> Result<GetDecommissionReadinessResult, ClientError> {
1297        match self
1298            .call(RequestBody::GetDecommissionReadiness(request), options)
1299            .await?
1300        {
1301            ResultBody::GetDecommissionReadiness(result) => Ok(result),
1302            _ => Err(ClientError::ResponseCommandMismatch),
1303        }
1304    }
1305
1306    /// Calls the generated `get_upgrade_readiness` Lodestone API command.
1307    pub async fn get_upgrade_readiness(
1308        &self,
1309        request: GetUpgradeReadinessRequest,
1310        options: CallOptions,
1311    ) -> Result<GetUpgradeReadinessResult, ClientError> {
1312        match self.call(RequestBody::GetUpgradeReadiness(request), options).await? {
1313            ResultBody::GetUpgradeReadiness(result) => Ok(result),
1314            _ => Err(ClientError::ResponseCommandMismatch),
1315        }
1316    }
1317
1318    /// Calls the generated `get_maintenance_status` Lodestone API command.
1319    pub async fn get_maintenance_status(
1320        &self,
1321        request: GetMaintenanceStatusRequest,
1322        options: CallOptions,
1323    ) -> Result<GetMaintenanceStatusResult, ClientError> {
1324        match self.call(RequestBody::GetMaintenanceStatus(request), options).await? {
1325            ResultBody::GetMaintenanceStatus(result) => Ok(result),
1326            _ => Err(ClientError::ResponseCommandMismatch),
1327        }
1328    }
1329
1330    /// Calls the generated `get_restore_readiness` Lodestone API command.
1331    pub async fn get_restore_readiness(
1332        &self,
1333        request: GetRestoreReadinessRequest,
1334        options: CallOptions,
1335    ) -> Result<GetRestoreReadinessResult, ClientError> {
1336        match self.call(RequestBody::GetRestoreReadiness(request), options).await? {
1337            ResultBody::GetRestoreReadiness(result) => Ok(result),
1338            _ => Err(ClientError::ResponseCommandMismatch),
1339        }
1340    }
1341
1342    /// Calls the generated `warm_vector_index` Lodestone API command.
1343    pub async fn warm_vector_index(
1344        &self,
1345        request: WarmVectorIndexRequest,
1346        options: CallOptions,
1347    ) -> Result<WarmVectorIndexResult, ClientError> {
1348        match self.call(RequestBody::WarmVectorIndex(request), options).await? {
1349            ResultBody::WarmVectorIndex(result) => Ok(result),
1350            _ => Err(ClientError::ResponseCommandMismatch),
1351        }
1352    }
1353
1354    /// Calls the generated `evaluate_vector_recall` Lodestone API command.
1355    pub async fn evaluate_vector_recall(
1356        &self,
1357        request: EvaluateVectorRecallRequest,
1358        options: CallOptions,
1359    ) -> Result<EvaluateVectorRecallResult, ClientError> {
1360        match self.call(RequestBody::EvaluateVectorRecall(request), options).await? {
1361            ResultBody::EvaluateVectorRecall(result) => Ok(result),
1362            _ => Err(ClientError::ResponseCommandMismatch),
1363        }
1364    }
1365
1366    /// Calls the generated `calibrate_vector_strategy` Lodestone API command.
1367    pub async fn calibrate_vector_strategy(
1368        &self,
1369        request: CalibrateVectorStrategyRequest,
1370        options: CallOptions,
1371    ) -> Result<CalibrateVectorStrategyResult, ClientError> {
1372        match self
1373            .call(RequestBody::CalibrateVectorStrategy(request), options)
1374            .await?
1375        {
1376            ResultBody::CalibrateVectorStrategy(result) => Ok(result),
1377            _ => Err(ClientError::ResponseCommandMismatch),
1378        }
1379    }
1380
1381    /// Calls the generated `get_vector_diagnostic` Lodestone API command.
1382    pub async fn get_vector_diagnostic(
1383        &self,
1384        request: GetVectorDiagnosticRequest,
1385        options: CallOptions,
1386    ) -> Result<GetVectorDiagnosticResult, ClientError> {
1387        match self.call(RequestBody::GetVectorDiagnostic(request), options).await? {
1388            ResultBody::GetVectorDiagnostic(result) => Ok(result),
1389            _ => Err(ClientError::ResponseCommandMismatch),
1390        }
1391    }
1392
1393    /// Calls the generated `create_diagnostic` Lodestone API command.
1394    pub async fn create_diagnostic(
1395        &self,
1396        request: CreateDiagnosticRequest,
1397        options: CallOptions,
1398    ) -> Result<CreateDiagnosticResult, ClientError> {
1399        match self.call(RequestBody::CreateDiagnostic(request), options).await? {
1400            ResultBody::CreateDiagnostic(result) => Ok(result),
1401            _ => Err(ClientError::ResponseCommandMismatch),
1402        }
1403    }
1404
1405    /// Calls the generated `get_diagnostic` Lodestone API command.
1406    pub async fn get_diagnostic(
1407        &self,
1408        request: GetDiagnosticRequest,
1409        options: CallOptions,
1410    ) -> Result<GetDiagnosticResult, ClientError> {
1411        match self.call(RequestBody::GetDiagnostic(request), options).await? {
1412            ResultBody::GetDiagnostic(result) => Ok(result),
1413            _ => Err(ClientError::ResponseCommandMismatch),
1414        }
1415    }
1416
1417    /// Calls the generated `read_artifact_chunk` Lodestone API command.
1418    pub async fn read_artifact_chunk(
1419        &self,
1420        request: ReadArtifactChunkRequest,
1421        options: CallOptions,
1422    ) -> Result<ReadArtifactChunkResult, ClientError> {
1423        match self.call(RequestBody::ReadArtifactChunk(request), options).await? {
1424            ResultBody::ReadArtifactChunk(result) => Ok(result),
1425            _ => Err(ClientError::ResponseCommandMismatch),
1426        }
1427    }
1428
1429    /// Calls the generated `export_usage` Lodestone API command.
1430    pub async fn export_usage(
1431        &self,
1432        request: ExportUsageRequest,
1433        options: CallOptions,
1434    ) -> Result<ExportUsageResult, ClientError> {
1435        match self.call(RequestBody::ExportUsage(request), options).await? {
1436            ResultBody::ExportUsage(result) => Ok(result),
1437            _ => Err(ClientError::ResponseCommandMismatch),
1438        }
1439    }
1440
1441    /// Calls the generated `execute_state_read` Lodestone API command.
1442    pub async fn execute_state_read(
1443        &self,
1444        request: ExecuteStateReadRequest,
1445        options: CallOptions,
1446    ) -> Result<ExecuteStateReadResult, ClientError> {
1447        match self.call(RequestBody::ExecuteStateRead(request), options).await? {
1448            ResultBody::ExecuteStateRead(result) => Ok(result),
1449            _ => Err(ClientError::ResponseCommandMismatch),
1450        }
1451    }
1452
1453    /// Calls the generated `prepare_state_write` Lodestone API command.
1454    pub async fn prepare_state_write(
1455        &self,
1456        request: PrepareStateWriteRequest,
1457        options: CallOptions,
1458    ) -> Result<PrepareStateWriteResult, ClientError> {
1459        match self.call(RequestBody::PrepareStateWrite(request), options).await? {
1460            ResultBody::PrepareStateWrite(result) => Ok(result),
1461            _ => Err(ClientError::ResponseCommandMismatch),
1462        }
1463    }
1464
1465    /// Calls the generated `submit_state_write` Lodestone API command.
1466    pub async fn submit_state_write(
1467        &self,
1468        request: SubmitStateWriteRequest,
1469        options: CallOptions,
1470    ) -> Result<SubmitStateWriteResult, ClientError> {
1471        match self.call(RequestBody::SubmitStateWrite(request), options).await? {
1472            ResultBody::SubmitStateWrite(result) => Ok(result),
1473            _ => Err(ClientError::ResponseCommandMismatch),
1474        }
1475    }
1476
1477    /// Calls the generated `resolve_state_write` Lodestone API command.
1478    pub async fn resolve_state_write(
1479        &self,
1480        request: ResolveStateWriteRequest,
1481        options: CallOptions,
1482    ) -> Result<ResolveStateWriteResult, ClientError> {
1483        match self.call(RequestBody::ResolveStateWrite(request), options).await? {
1484            ResultBody::ResolveStateWrite(result) => Ok(result),
1485            _ => Err(ClientError::ResponseCommandMismatch),
1486        }
1487    }
1488}
lodestone_client/generated.rs

lodestone_client/
generated.rs
