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

lodestone_client/
generated.rs
