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

lodestone_client/
generated.rs
