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

lodestone_client/
generated.rs
