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

lodestone_client/
generated.rs
