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

lodestone_client/
generated.rs
