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

lodestone_client/
generated.rs
