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

lodestone_client/
generated.rs
