lodestone-client 0.0.4

//! @generated by scripts/proofs/native-api/generate-rust-client.py; do not edit by hand.

use lodestone_wire::*;

use crate::{CallOptions, Client, ClientError};

pub const RUST_CLIENT_METHOD_COUNT: usize = 99;
pub(crate) const MAX_NATIVE_REQUEST_BYTES: usize = 2097152;
pub(crate) const MAX_NATIVE_RESPONSE_BYTES: usize = 2097152;

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum GeneratedCollectionIndexRef {
    None,
    Caller,
    Exact(String),
}

pub const fn request_command(request: &RequestBody) -> Command {
    match request {
        RequestBody::Discover(_) => Command::Discover,
        RequestBody::ListIndexes(_) => Command::ListIndexes,
        RequestBody::GetIndex(_) => Command::GetIndex,
        RequestBody::ValidateIndexChange(_) => Command::ValidateIndexChange,
        RequestBody::ApplyIndexChange(_) => Command::ApplyIndexChange,
        RequestBody::ApplyAdministrationMutation(_) => Command::ApplyAdministrationMutation,
        RequestBody::ListAliases(_) => Command::ListAliases,
        RequestBody::GetAlias(_) => Command::GetAlias,
        RequestBody::ListDataStreams(_) => Command::ListDataStreams,
        RequestBody::GetDataStream(_) => Command::GetDataStream,
        RequestBody::ListComponentTemplates(_) => Command::ListComponentTemplates,
        RequestBody::GetComponentTemplate(_) => Command::GetComponentTemplate,
        RequestBody::ListIndexTemplates(_) => Command::ListIndexTemplates,
        RequestBody::GetIndexTemplate(_) => Command::GetIndexTemplate,
        RequestBody::ListIngestPipelines(_) => Command::ListIngestPipelines,
        RequestBody::GetIngestPipeline(_) => Command::GetIngestPipeline,
        RequestBody::SimulateIngestPipeline(_) => Command::SimulateIngestPipeline,
        RequestBody::ReprocessByQuery(_) => Command::ReprocessByQuery,
        RequestBody::ListLifecyclePolicies(_) => Command::ListLifecyclePolicies,
        RequestBody::GetLifecyclePolicy(_) => Command::GetLifecyclePolicy,
        RequestBody::PrepareCreateIndex(_) => Command::PrepareCreateIndex,
        RequestBody::PrepareDeleteIndex(_) => Command::PrepareDeleteIndex,
        RequestBody::SubmitCatalogAction(_) => Command::SubmitCatalogAction,
        RequestBody::ResolveCatalogAction(_) => Command::ResolveCatalogAction,
        RequestBody::PrepareReplayableSourceIndex(_) => Command::PrepareReplayableSourceIndex,
        RequestBody::SubmitReplayableSourceIndex(_) => Command::SubmitReplayableSourceIndex,
        RequestBody::GetReplayableSource(_) => Command::GetReplayableSource,
        RequestBody::ControlReplayableSource(_) => Command::ControlReplayableSource,
        RequestBody::CloneIndex(_) => Command::CloneIndex,
        RequestBody::ConfigureHistory(_) => Command::ConfigureHistory,
        RequestBody::GetHistory(_) => Command::GetHistory,
        RequestBody::ResolveHistory(_) => Command::ResolveHistory,
        RequestBody::PlaceHistoryHold(_) => Command::PlaceHistoryHold,
        RequestBody::ReleaseHistoryHold(_) => Command::ReleaseHistoryHold,
        RequestBody::PrepareDocumentMutation(_) => Command::PrepareDocumentMutation,
        RequestBody::SubmitDocumentMutation(_) => Command::SubmitDocumentMutation,
        RequestBody::PrepareDocumentBulk(_) => Command::PrepareDocumentBulk,
        RequestBody::SubmitDocumentBulk(_) => Command::SubmitDocumentBulk,
        RequestBody::ResolveDocumentBulk(_) => Command::ResolveDocumentBulk,
        RequestBody::PrepareAppendBulk(_) => Command::PrepareAppendBulk,
        RequestBody::SubmitAppendBulk(_) => Command::SubmitAppendBulk,
        RequestBody::ResolveAppendBulk(_) => Command::ResolveAppendBulk,
        RequestBody::ObserveAppendCommitted(_) => Command::ObserveAppendCommitted,
        RequestBody::ResolveDocumentMutation(_) => Command::ResolveDocumentMutation,
        RequestBody::GetDocument(_) => Command::GetDocument,
        RequestBody::Search(_) => Command::Search,
        RequestBody::OpenPit(_) => Command::OpenPit,
        RequestBody::RenewPit(_) => Command::RenewPit,
        RequestBody::ClosePit(_) => Command::ClosePit,
        RequestBody::ListOperations(_) => Command::ListOperations,
        RequestBody::GetOperation(_) => Command::GetOperation,
        RequestBody::CancelOperation(_) => Command::CancelOperation,
        RequestBody::ListAuditEvents(_) => Command::ListAuditEvents,
        RequestBody::ExportAuditEvents(_) => Command::ExportAuditEvents,
        RequestBody::ReserveServiceCredential(_) => Command::ReserveServiceCredential,
        RequestBody::ReserveServiceCredentialRotation(_) => Command::ReserveServiceCredentialRotation,
        RequestBody::ActivateServiceCredential(_) => Command::ActivateServiceCredential,
        RequestBody::ResolveServiceCredentialReservation(_) => Command::ResolveServiceCredentialReservation,
        RequestBody::PrepareRevokeServiceCredential(_) => Command::PrepareRevokeServiceCredential,
        RequestBody::RevokeServiceCredential(_) => Command::RevokeServiceCredential,
        RequestBody::ResolveSecurityAction(_) => Command::ResolveSecurityAction,
        RequestBody::GetSecurityRole(_) => Command::GetSecurityRole,
        RequestBody::PrepareRoleAppendAccessChange(_) => Command::PrepareRoleAppendAccessChange,
        RequestBody::SubmitRoleAppendAccessChange(_) => Command::SubmitRoleAppendAccessChange,
        RequestBody::ListServiceCredentials(_) => Command::ListServiceCredentials,
        RequestBody::ListBackups(_) => Command::ListBackups,
        RequestBody::GetBackup(_) => Command::GetBackup,
        RequestBody::CreateBackup(_) => Command::CreateBackup,
        RequestBody::ResolveBackupAction(_) => Command::ResolveBackupAction,
        RequestBody::GetRuntimeStatus(_) => Command::GetRuntimeStatus,
        RequestBody::GetResultCacheStatus(_) => Command::GetResultCacheStatus,
        RequestBody::GetFieldPromotionStatus(_) => Command::GetFieldPromotionStatus,
        RequestBody::GetOverloadStatus(_) => Command::GetOverloadStatus,
        RequestBody::ConfigureExternalKey(_) => Command::ConfigureExternalKey,
        RequestBody::RotateExternalKeyBinding(_) => Command::RotateExternalKeyBinding,
        RequestBody::ConfigureAggregateThenDelete(_) => Command::ConfigureAggregateThenDelete,
        RequestBody::GetLifecycleStatus(_) => Command::GetLifecycleStatus,
        RequestBody::GetQuota(_) => Command::GetQuota,
        RequestBody::UpdateQuota(_) => Command::UpdateQuota,
        RequestBody::GetBinding(_) => Command::GetBinding,
        RequestBody::GetAdmissionStatus(_) => Command::GetAdmissionStatus,
        RequestBody::SetAdmission(_) => Command::SetAdmission,
        RequestBody::GetQuiesceStatus(_) => Command::GetQuiesceStatus,
        RequestBody::GetDecommissionReadiness(_) => Command::GetDecommissionReadiness,
        RequestBody::GetUpgradeReadiness(_) => Command::GetUpgradeReadiness,
        RequestBody::GetMaintenanceStatus(_) => Command::GetMaintenanceStatus,
        RequestBody::GetRestoreReadiness(_) => Command::GetRestoreReadiness,
        RequestBody::WarmVectorIndex(_) => Command::WarmVectorIndex,
        RequestBody::EvaluateVectorRecall(_) => Command::EvaluateVectorRecall,
        RequestBody::CalibrateVectorStrategy(_) => Command::CalibrateVectorStrategy,
        RequestBody::GetVectorDiagnostic(_) => Command::GetVectorDiagnostic,
        RequestBody::CreateDiagnostic(_) => Command::CreateDiagnostic,
        RequestBody::GetDiagnostic(_) => Command::GetDiagnostic,
        RequestBody::ReadArtifactChunk(_) => Command::ReadArtifactChunk,
        RequestBody::ExportUsage(_) => Command::ExportUsage,
        RequestBody::ExecuteStateRead(_) => Command::ExecuteStateRead,
        RequestBody::PrepareStateWrite(_) => Command::PrepareStateWrite,
        RequestBody::SubmitStateWrite(_) => Command::SubmitStateWrite,
        RequestBody::ResolveStateWrite(_) => Command::ResolveStateWrite,
    }
}

pub(crate) fn request_collection_index_ref(request: &RequestBody) -> Result<GeneratedCollectionIndexRef, ClientError> {
    match request {
        RequestBody::Discover(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListIndexes(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetIndex(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ValidateIndexChange(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
        RequestBody::ApplyIndexChange(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::ApplyAdministrationMutation(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListAliases(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetAlias(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListDataStreams(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetDataStream(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListComponentTemplates(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetComponentTemplate(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListIndexTemplates(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetIndexTemplate(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListIngestPipelines(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetIngestPipeline(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::SimulateIngestPipeline(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ReprocessByQuery(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::ListLifecyclePolicies(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetLifecyclePolicy(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::PrepareCreateIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
        RequestBody::PrepareDeleteIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
        RequestBody::SubmitCatalogAction(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
        RequestBody::ResolveCatalogAction(_) => Ok(GeneratedCollectionIndexRef::Caller),
        RequestBody::PrepareReplayableSourceIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
        RequestBody::SubmitReplayableSourceIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.name.clone())),
        RequestBody::GetReplayableSource(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ControlReplayableSource(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::CloneIndex(_) => Ok(GeneratedCollectionIndexRef::Caller),
        RequestBody::ConfigureHistory(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::GetHistory(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ResolveHistory(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::PlaceHistoryHold(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::ReleaseHistoryHold(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::PrepareDocumentMutation(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::SubmitDocumentMutation(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::PrepareDocumentBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::SubmitDocumentBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::ResolveDocumentBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::PrepareAppendBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::SubmitAppendBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::ResolveAppendBulk(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::ObserveAppendCommitted(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::ResolveDocumentMutation(_) => Ok(GeneratedCollectionIndexRef::Caller),
        RequestBody::GetDocument(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::Search(value) => value.indexes.as_deref().map_or(
            Ok(GeneratedCollectionIndexRef::None),
            generated_uniform_collection_index_ref,
        ),
        RequestBody::OpenPit(value) => generated_uniform_collection_index_ref(&value.indexes),
        RequestBody::RenewPit(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ClosePit(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListOperations(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetOperation(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::CancelOperation(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListAuditEvents(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ExportAuditEvents(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ReserveServiceCredential(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ReserveServiceCredentialRotation(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ActivateServiceCredential(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ResolveServiceCredentialReservation(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::PrepareRevokeServiceCredential(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::RevokeServiceCredential(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ResolveSecurityAction(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetSecurityRole(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::PrepareRoleAppendAccessChange(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::SubmitRoleAppendAccessChange(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListServiceCredentials(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ListBackups(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetBackup(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::CreateBackup(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ResolveBackupAction(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetRuntimeStatus(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetResultCacheStatus(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetFieldPromotionStatus(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetOverloadStatus(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ConfigureExternalKey(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::RotateExternalKeyBinding(value) => {
            Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone()))
        }
        RequestBody::ConfigureAggregateThenDelete(value) => {
            Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone()))
        }
        RequestBody::GetLifecycleStatus(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetQuota(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::UpdateQuota(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetBinding(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetAdmissionStatus(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::SetAdmission(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetQuiesceStatus(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetDecommissionReadiness(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetUpgradeReadiness(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetMaintenanceStatus(value) => {
            Ok(value.index.as_ref().map_or(GeneratedCollectionIndexRef::None, |index| {
                GeneratedCollectionIndexRef::Exact(index.name.clone())
            }))
        }
        RequestBody::GetRestoreReadiness(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::WarmVectorIndex(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::EvaluateVectorRecall(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::CalibrateVectorStrategy(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::GetVectorDiagnostic(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::CreateDiagnostic(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::GetDiagnostic(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ReadArtifactChunk(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ExportUsage(_) => Ok(GeneratedCollectionIndexRef::None),
        RequestBody::ExecuteStateRead(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::PrepareStateWrite(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::SubmitStateWrite(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
        RequestBody::ResolveStateWrite(value) => Ok(GeneratedCollectionIndexRef::Exact(value.index.name.clone())),
    }
}

fn generated_uniform_collection_index_ref(indexes: &[Resource]) -> Result<GeneratedCollectionIndexRef, ClientError> {
    if indexes.is_empty() {
        return Err(ClientError::CollectionIndexRefRequired);
    }
    if indexes
        .iter()
        .enumerate()
        .any(|(position, index)| indexes[..position].contains(index))
    {
        return Err(ClientError::CollectionIndexRefMismatch);
    }
    Ok(GeneratedCollectionIndexRef::None)
}

impl Client {
    /// Calls the generated `discover` Lodestone API command.
    pub async fn discover(
        &self,
        request: DiscoverRequest,
        options: CallOptions,
    ) -> Result<DiscoverResult, ClientError> {
        match self.call(RequestBody::Discover(request), options).await? {
            ResultBody::Discover(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_indexes` Lodestone API command.
    pub async fn list_indexes(
        &self,
        request: ListIndexesRequest,
        options: CallOptions,
    ) -> Result<ListIndexesResult, ClientError> {
        match self.call(RequestBody::ListIndexes(request), options).await? {
            ResultBody::ListIndexes(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_index` Lodestone API command.
    pub async fn get_index(
        &self,
        request: GetIndexRequest,
        options: CallOptions,
    ) -> Result<GetIndexResult, ClientError> {
        match self.call(RequestBody::GetIndex(request), options).await? {
            ResultBody::GetIndex(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `validate_index_change` Lodestone API command.
    pub async fn validate_index_change(
        &self,
        request: ValidateIndexChangeRequest,
        options: CallOptions,
    ) -> Result<ValidateIndexChangeResult, ClientError> {
        match self.call(RequestBody::ValidateIndexChange(request), options).await? {
            ResultBody::ValidateIndexChange(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `apply_index_change` Lodestone API command.
    pub async fn apply_index_change(
        &self,
        request: ApplyIndexChangeRequest,
        options: CallOptions,
    ) -> Result<ApplyIndexChangeResult, ClientError> {
        match self.call(RequestBody::ApplyIndexChange(request), options).await? {
            ResultBody::ApplyIndexChange(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `apply_administration_mutation` Lodestone API command.
    pub async fn apply_administration_mutation(
        &self,
        request: ApplyAdministrationMutationRequest,
        options: CallOptions,
    ) -> Result<ApplyAdministrationMutationResult, ClientError> {
        match self
            .call(RequestBody::ApplyAdministrationMutation(request), options)
            .await?
        {
            ResultBody::ApplyAdministrationMutation(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_aliases` Lodestone API command.
    pub async fn list_aliases(
        &self,
        request: ListAliasesRequest,
        options: CallOptions,
    ) -> Result<ListAliasesResult, ClientError> {
        match self.call(RequestBody::ListAliases(request), options).await? {
            ResultBody::ListAliases(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_alias` Lodestone API command.
    pub async fn get_alias(
        &self,
        request: GetAliasRequest,
        options: CallOptions,
    ) -> Result<GetAliasResult, ClientError> {
        match self.call(RequestBody::GetAlias(request), options).await? {
            ResultBody::GetAlias(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_data_streams` Lodestone API command.
    pub async fn list_data_streams(
        &self,
        request: ListDataStreamsRequest,
        options: CallOptions,
    ) -> Result<ListDataStreamsResult, ClientError> {
        match self.call(RequestBody::ListDataStreams(request), options).await? {
            ResultBody::ListDataStreams(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_data_stream` Lodestone API command.
    pub async fn get_data_stream(
        &self,
        request: GetDataStreamRequest,
        options: CallOptions,
    ) -> Result<GetDataStreamResult, ClientError> {
        match self.call(RequestBody::GetDataStream(request), options).await? {
            ResultBody::GetDataStream(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_component_templates` Lodestone API command.
    pub async fn list_component_templates(
        &self,
        request: ListComponentTemplatesRequest,
        options: CallOptions,
    ) -> Result<ListComponentTemplatesResult, ClientError> {
        match self.call(RequestBody::ListComponentTemplates(request), options).await? {
            ResultBody::ListComponentTemplates(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_component_template` Lodestone API command.
    pub async fn get_component_template(
        &self,
        request: GetComponentTemplateRequest,
        options: CallOptions,
    ) -> Result<GetComponentTemplateResult, ClientError> {
        match self.call(RequestBody::GetComponentTemplate(request), options).await? {
            ResultBody::GetComponentTemplate(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_index_templates` Lodestone API command.
    pub async fn list_index_templates(
        &self,
        request: ListIndexTemplatesRequest,
        options: CallOptions,
    ) -> Result<ListIndexTemplatesResult, ClientError> {
        match self.call(RequestBody::ListIndexTemplates(request), options).await? {
            ResultBody::ListIndexTemplates(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_index_template` Lodestone API command.
    pub async fn get_index_template(
        &self,
        request: GetIndexTemplateRequest,
        options: CallOptions,
    ) -> Result<GetIndexTemplateResult, ClientError> {
        match self.call(RequestBody::GetIndexTemplate(request), options).await? {
            ResultBody::GetIndexTemplate(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_ingest_pipelines` Lodestone API command.
    pub async fn list_ingest_pipelines(
        &self,
        request: ListIngestPipelinesRequest,
        options: CallOptions,
    ) -> Result<ListIngestPipelinesResult, ClientError> {
        match self.call(RequestBody::ListIngestPipelines(request), options).await? {
            ResultBody::ListIngestPipelines(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_ingest_pipeline` Lodestone API command.
    pub async fn get_ingest_pipeline(
        &self,
        request: GetIngestPipelineRequest,
        options: CallOptions,
    ) -> Result<GetIngestPipelineResult, ClientError> {
        match self.call(RequestBody::GetIngestPipeline(request), options).await? {
            ResultBody::GetIngestPipeline(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `simulate_ingest_pipeline` Lodestone API command.
    pub async fn simulate_ingest_pipeline(
        &self,
        request: SimulateIngestPipelineRequest,
        options: CallOptions,
    ) -> Result<SimulateIngestPipelineResult, ClientError> {
        match self.call(RequestBody::SimulateIngestPipeline(request), options).await? {
            ResultBody::SimulateIngestPipeline(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `reprocess_by_query` Lodestone API command.
    pub async fn reprocess_by_query(
        &self,
        request: ReprocessByQueryRequest,
        options: CallOptions,
    ) -> Result<ReprocessByQueryResult, ClientError> {
        match self.call(RequestBody::ReprocessByQuery(request), options).await? {
            ResultBody::ReprocessByQuery(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_lifecycle_policies` Lodestone API command.
    pub async fn list_lifecycle_policies(
        &self,
        request: ListLifecyclePoliciesRequest,
        options: CallOptions,
    ) -> Result<ListLifecyclePoliciesResult, ClientError> {
        match self.call(RequestBody::ListLifecyclePolicies(request), options).await? {
            ResultBody::ListLifecyclePolicies(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_lifecycle_policy` Lodestone API command.
    pub async fn get_lifecycle_policy(
        &self,
        request: GetLifecyclePolicyRequest,
        options: CallOptions,
    ) -> Result<GetLifecyclePolicyResult, ClientError> {
        match self.call(RequestBody::GetLifecyclePolicy(request), options).await? {
            ResultBody::GetLifecyclePolicy(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_create_index` Lodestone API command.
    pub async fn prepare_create_index(
        &self,
        request: PrepareCreateIndexRequest,
        options: CallOptions,
    ) -> Result<PrepareCreateIndexResult, ClientError> {
        match self.call(RequestBody::PrepareCreateIndex(request), options).await? {
            ResultBody::PrepareCreateIndex(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_delete_index` Lodestone API command.
    pub async fn prepare_delete_index(
        &self,
        request: PrepareDeleteIndexRequest,
        options: CallOptions,
    ) -> Result<PrepareDeleteIndexResult, ClientError> {
        match self.call(RequestBody::PrepareDeleteIndex(request), options).await? {
            ResultBody::PrepareDeleteIndex(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `submit_catalog_action` Lodestone API command.
    pub async fn submit_catalog_action(
        &self,
        request: SubmitCatalogActionRequest,
        options: CallOptions,
    ) -> Result<SubmitCatalogActionResult, ClientError> {
        match self.call(RequestBody::SubmitCatalogAction(request), options).await? {
            ResultBody::SubmitCatalogAction(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_catalog_action` Lodestone API command.
    pub async fn resolve_catalog_action(
        &self,
        request: ResolveCatalogActionRequest,
        options: CallOptions,
    ) -> Result<ResolveCatalogActionResult, ClientError> {
        match self.call(RequestBody::ResolveCatalogAction(request), options).await? {
            ResultBody::ResolveCatalogAction(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_replayable_source_index` Lodestone API command.
    pub async fn prepare_replayable_source_index(
        &self,
        request: PrepareReplayableSourceIndexRequest,
        options: CallOptions,
    ) -> Result<PrepareReplayableSourceIndexResult, ClientError> {
        match self
            .call(RequestBody::PrepareReplayableSourceIndex(request), options)
            .await?
        {
            ResultBody::PrepareReplayableSourceIndex(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `submit_replayable_source_index` Lodestone API command.
    pub async fn submit_replayable_source_index(
        &self,
        request: SubmitReplayableSourceIndexRequest,
        options: CallOptions,
    ) -> Result<SubmitReplayableSourceIndexResult, ClientError> {
        match self
            .call(RequestBody::SubmitReplayableSourceIndex(request), options)
            .await?
        {
            ResultBody::SubmitReplayableSourceIndex(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_replayable_source` Lodestone API command.
    pub async fn get_replayable_source(
        &self,
        request: GetReplayableSourceRequest,
        options: CallOptions,
    ) -> Result<GetReplayableSourceResult, ClientError> {
        match self.call(RequestBody::GetReplayableSource(request), options).await? {
            ResultBody::GetReplayableSource(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `control_replayable_source` Lodestone API command.
    pub async fn control_replayable_source(
        &self,
        request: ControlReplayableSourceRequest,
        options: CallOptions,
    ) -> Result<ControlReplayableSourceResult, ClientError> {
        match self
            .call(RequestBody::ControlReplayableSource(request), options)
            .await?
        {
            ResultBody::ControlReplayableSource(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `clone_index` Lodestone API command.
    pub async fn clone_index(
        &self,
        request: CloneIndexRequest,
        options: CallOptions,
    ) -> Result<CloneIndexResult, ClientError> {
        match self.call(RequestBody::CloneIndex(request), options).await? {
            ResultBody::CloneIndex(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `configure_history` Lodestone API command.
    pub async fn configure_history(
        &self,
        request: ConfigureHistoryRequest,
        options: CallOptions,
    ) -> Result<ConfigureHistoryResult, ClientError> {
        match self.call(RequestBody::ConfigureHistory(request), options).await? {
            ResultBody::ConfigureHistory(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_history` Lodestone API command.
    pub async fn get_history(
        &self,
        request: GetHistoryRequest,
        options: CallOptions,
    ) -> Result<GetHistoryResult, ClientError> {
        match self.call(RequestBody::GetHistory(request), options).await? {
            ResultBody::GetHistory(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_history` Lodestone API command.
    pub async fn resolve_history(
        &self,
        request: ResolveHistoryRequest,
        options: CallOptions,
    ) -> Result<ResolveHistoryResult, ClientError> {
        match self.call(RequestBody::ResolveHistory(request), options).await? {
            ResultBody::ResolveHistory(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `place_history_hold` Lodestone API command.
    pub async fn place_history_hold(
        &self,
        request: PlaceHistoryHoldRequest,
        options: CallOptions,
    ) -> Result<PlaceHistoryHoldResult, ClientError> {
        match self.call(RequestBody::PlaceHistoryHold(request), options).await? {
            ResultBody::PlaceHistoryHold(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `release_history_hold` Lodestone API command.
    pub async fn release_history_hold(
        &self,
        request: ReleaseHistoryHoldRequest,
        options: CallOptions,
    ) -> Result<ReleaseHistoryHoldResult, ClientError> {
        match self.call(RequestBody::ReleaseHistoryHold(request), options).await? {
            ResultBody::ReleaseHistoryHold(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_document_mutation` Lodestone API command.
    pub async fn prepare_document_mutation(
        &self,
        request: PrepareDocumentMutationRequest,
        options: CallOptions,
    ) -> Result<PrepareDocumentMutationResult, ClientError> {
        match self
            .call(RequestBody::PrepareDocumentMutation(request), options)
            .await?
        {
            ResultBody::PrepareDocumentMutation(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `submit_document_mutation` Lodestone API command.
    pub async fn submit_document_mutation(
        &self,
        request: SubmitDocumentMutationRequest,
        options: CallOptions,
    ) -> Result<SubmitDocumentMutationResult, ClientError> {
        match self.call(RequestBody::SubmitDocumentMutation(request), options).await? {
            ResultBody::SubmitDocumentMutation(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_document_bulk` Lodestone API command.
    pub async fn prepare_document_bulk(
        &self,
        request: PrepareDocumentBulkRequest,
        options: CallOptions,
    ) -> Result<PrepareDocumentBulkResult, ClientError> {
        match self.call(RequestBody::PrepareDocumentBulk(request), options).await? {
            ResultBody::PrepareDocumentBulk(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `submit_document_bulk` Lodestone API command.
    pub async fn submit_document_bulk(
        &self,
        request: SubmitDocumentBulkRequest,
        options: CallOptions,
    ) -> Result<SubmitDocumentBulkResult, ClientError> {
        match self.call(RequestBody::SubmitDocumentBulk(request), options).await? {
            ResultBody::SubmitDocumentBulk(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_document_bulk` Lodestone API command.
    pub async fn resolve_document_bulk(
        &self,
        request: ResolveDocumentBulkRequest,
        options: CallOptions,
    ) -> Result<ResolveDocumentBulkResult, ClientError> {
        match self.call(RequestBody::ResolveDocumentBulk(request), options).await? {
            ResultBody::ResolveDocumentBulk(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_append_bulk` Lodestone API command.
    pub async fn prepare_append_bulk(
        &self,
        request: PrepareAppendBulkRequest,
        options: CallOptions,
    ) -> Result<PrepareAppendBulkResult, ClientError> {
        match self.call(RequestBody::PrepareAppendBulk(request), options).await? {
            ResultBody::PrepareAppendBulk(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `submit_append_bulk` Lodestone API command.
    pub async fn submit_append_bulk(
        &self,
        request: SubmitAppendBulkRequest,
        options: CallOptions,
    ) -> Result<SubmitAppendBulkResult, ClientError> {
        match self.call(RequestBody::SubmitAppendBulk(request), options).await? {
            ResultBody::SubmitAppendBulk(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_append_bulk` Lodestone API command.
    pub async fn resolve_append_bulk(
        &self,
        request: ResolveAppendBulkRequest,
        options: CallOptions,
    ) -> Result<ResolveAppendBulkResult, ClientError> {
        match self.call(RequestBody::ResolveAppendBulk(request), options).await? {
            ResultBody::ResolveAppendBulk(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `observe_append_committed` Lodestone API command.
    pub async fn observe_append_committed(
        &self,
        request: ObserveAppendCommittedRequest,
        options: CallOptions,
    ) -> Result<ObserveAppendCommittedResult, ClientError> {
        match self.call(RequestBody::ObserveAppendCommitted(request), options).await? {
            ResultBody::ObserveAppendCommitted(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_document_mutation` Lodestone API command.
    pub async fn resolve_document_mutation(
        &self,
        request: ResolveDocumentMutationRequest,
        options: CallOptions,
    ) -> Result<ResolveDocumentMutationResult, ClientError> {
        match self
            .call(RequestBody::ResolveDocumentMutation(request), options)
            .await?
        {
            ResultBody::ResolveDocumentMutation(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_document` Lodestone API command.
    pub async fn get_document(
        &self,
        request: GetDocumentRequest,
        options: CallOptions,
    ) -> Result<GetDocumentResult, ClientError> {
        match self.call(RequestBody::GetDocument(request), options).await? {
            ResultBody::GetDocument(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `search` Lodestone API command.
    pub async fn search(&self, request: SearchRequest, options: CallOptions) -> Result<SearchResult, ClientError> {
        match self.call(RequestBody::Search(request), options).await? {
            ResultBody::Search(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `open_pit` Lodestone API command.
    pub async fn open_pit(&self, request: OpenPitRequest, options: CallOptions) -> Result<OpenPitResult, ClientError> {
        match self.call(RequestBody::OpenPit(request), options).await? {
            ResultBody::OpenPit(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `renew_pit` Lodestone API command.
    pub async fn renew_pit(
        &self,
        request: RenewPitRequest,
        options: CallOptions,
    ) -> Result<RenewPitResult, ClientError> {
        match self.call(RequestBody::RenewPit(request), options).await? {
            ResultBody::RenewPit(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `close_pit` Lodestone API command.
    pub async fn close_pit(
        &self,
        request: ClosePitRequest,
        options: CallOptions,
    ) -> Result<ClosePitResult, ClientError> {
        match self.call(RequestBody::ClosePit(request), options).await? {
            ResultBody::ClosePit(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_operations` Lodestone API command.
    pub async fn list_operations(
        &self,
        request: ListOperationsRequest,
        options: CallOptions,
    ) -> Result<ListOperationsResult, ClientError> {
        match self.call(RequestBody::ListOperations(request), options).await? {
            ResultBody::ListOperations(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_operation` Lodestone API command.
    pub async fn get_operation(
        &self,
        request: GetOperationRequest,
        options: CallOptions,
    ) -> Result<GetOperationResult, ClientError> {
        match self.call(RequestBody::GetOperation(request), options).await? {
            ResultBody::GetOperation(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `cancel_operation` Lodestone API command.
    pub async fn cancel_operation(
        &self,
        request: CancelOperationRequest,
        options: CallOptions,
    ) -> Result<CancelOperationResult, ClientError> {
        match self.call(RequestBody::CancelOperation(request), options).await? {
            ResultBody::CancelOperation(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_audit_events` Lodestone API command.
    pub async fn list_audit_events(
        &self,
        request: ListAuditEventsRequest,
        options: CallOptions,
    ) -> Result<ListAuditEventsResult, ClientError> {
        match self.call(RequestBody::ListAuditEvents(request), options).await? {
            ResultBody::ListAuditEvents(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `export_audit_events` Lodestone API command.
    pub async fn export_audit_events(
        &self,
        request: ExportAuditEventsRequest,
        options: CallOptions,
    ) -> Result<ExportAuditEventsResult, ClientError> {
        match self.call(RequestBody::ExportAuditEvents(request), options).await? {
            ResultBody::ExportAuditEvents(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `reserve_service_credential` Lodestone API command.
    pub async fn reserve_service_credential(
        &self,
        request: ReserveServiceCredentialRequest,
        options: CallOptions,
    ) -> Result<ReserveServiceCredentialResult, ClientError> {
        match self
            .call(RequestBody::ReserveServiceCredential(request), options)
            .await?
        {
            ResultBody::ReserveServiceCredential(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `reserve_service_credential_rotation` Lodestone API command.
    pub async fn reserve_service_credential_rotation(
        &self,
        request: ReserveServiceCredentialRotationRequest,
        options: CallOptions,
    ) -> Result<ReserveServiceCredentialRotationResult, ClientError> {
        match self
            .call(RequestBody::ReserveServiceCredentialRotation(request), options)
            .await?
        {
            ResultBody::ReserveServiceCredentialRotation(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `activate_service_credential` Lodestone API command.
    pub async fn activate_service_credential(
        &self,
        request: ActivateServiceCredentialRequest,
        options: CallOptions,
    ) -> Result<ActivateServiceCredentialResult, ClientError> {
        match self
            .call(RequestBody::ActivateServiceCredential(request), options)
            .await?
        {
            ResultBody::ActivateServiceCredential(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_service_credential_reservation` Lodestone API command.
    pub async fn resolve_service_credential_reservation(
        &self,
        request: ResolveServiceCredentialReservationRequest,
        options: CallOptions,
    ) -> Result<ResolveServiceCredentialReservationResult, ClientError> {
        match self
            .call(RequestBody::ResolveServiceCredentialReservation(request), options)
            .await?
        {
            ResultBody::ResolveServiceCredentialReservation(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_revoke_service_credential` Lodestone API command.
    pub async fn prepare_revoke_service_credential(
        &self,
        request: PrepareRevokeServiceCredentialRequest,
        options: CallOptions,
    ) -> Result<PrepareRevokeServiceCredentialResult, ClientError> {
        match self
            .call(RequestBody::PrepareRevokeServiceCredential(request), options)
            .await?
        {
            ResultBody::PrepareRevokeServiceCredential(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `revoke_service_credential` Lodestone API command.
    pub async fn revoke_service_credential(
        &self,
        request: RevokeServiceCredentialRequest,
        options: CallOptions,
    ) -> Result<RevokeServiceCredentialResult, ClientError> {
        match self
            .call(RequestBody::RevokeServiceCredential(request), options)
            .await?
        {
            ResultBody::RevokeServiceCredential(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_security_action` Lodestone API command.
    pub async fn resolve_security_action(
        &self,
        request: ResolveSecurityActionRequest,
        options: CallOptions,
    ) -> Result<ResolveSecurityActionResult, ClientError> {
        match self.call(RequestBody::ResolveSecurityAction(request), options).await? {
            ResultBody::ResolveSecurityAction(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_security_role` Lodestone API command.
    pub async fn get_security_role(
        &self,
        request: GetSecurityRoleRequest,
        options: CallOptions,
    ) -> Result<GetSecurityRoleResult, ClientError> {
        match self.call(RequestBody::GetSecurityRole(request), options).await? {
            ResultBody::GetSecurityRole(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_role_append_access_change` Lodestone API command.
    pub async fn prepare_role_append_access_change(
        &self,
        request: PrepareRoleAppendAccessChangeRequest,
        options: CallOptions,
    ) -> Result<PrepareRoleAppendAccessChangeResult, ClientError> {
        match self
            .call(RequestBody::PrepareRoleAppendAccessChange(request), options)
            .await?
        {
            ResultBody::PrepareRoleAppendAccessChange(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `submit_role_append_access_change` Lodestone API command.
    pub async fn submit_role_append_access_change(
        &self,
        request: SubmitRoleAppendAccessChangeRequest,
        options: CallOptions,
    ) -> Result<SubmitRoleAppendAccessChangeResult, ClientError> {
        match self
            .call(RequestBody::SubmitRoleAppendAccessChange(request), options)
            .await?
        {
            ResultBody::SubmitRoleAppendAccessChange(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_service_credentials` Lodestone API command.
    pub async fn list_service_credentials(
        &self,
        request: ListServiceCredentialsRequest,
        options: CallOptions,
    ) -> Result<ListServiceCredentialsResult, ClientError> {
        match self.call(RequestBody::ListServiceCredentials(request), options).await? {
            ResultBody::ListServiceCredentials(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `list_backups` Lodestone API command.
    pub async fn list_backups(
        &self,
        request: ListBackupsRequest,
        options: CallOptions,
    ) -> Result<ListBackupsResult, ClientError> {
        match self.call(RequestBody::ListBackups(request), options).await? {
            ResultBody::ListBackups(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_backup` Lodestone API command.
    pub async fn get_backup(
        &self,
        request: GetBackupRequest,
        options: CallOptions,
    ) -> Result<GetBackupResult, ClientError> {
        match self.call(RequestBody::GetBackup(request), options).await? {
            ResultBody::GetBackup(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `create_backup` Lodestone API command.
    pub async fn create_backup(
        &self,
        request: CreateBackupRequest,
        options: CallOptions,
    ) -> Result<CreateBackupResult, ClientError> {
        match self.call(RequestBody::CreateBackup(request), options).await? {
            ResultBody::CreateBackup(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_backup_action` Lodestone API command.
    pub async fn resolve_backup_action(
        &self,
        request: ResolveBackupActionRequest,
        options: CallOptions,
    ) -> Result<ResolveBackupActionResult, ClientError> {
        match self.call(RequestBody::ResolveBackupAction(request), options).await? {
            ResultBody::ResolveBackupAction(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_runtime_status` Lodestone API command.
    pub async fn get_runtime_status(
        &self,
        request: GetRuntimeStatusRequest,
        options: CallOptions,
    ) -> Result<GetRuntimeStatusResult, ClientError> {
        match self.call(RequestBody::GetRuntimeStatus(request), options).await? {
            ResultBody::GetRuntimeStatus(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_result_cache_status` Lodestone API command.
    pub async fn get_result_cache_status(
        &self,
        request: GetResultCacheStatusRequest,
        options: CallOptions,
    ) -> Result<GetResultCacheStatusResult, ClientError> {
        match self.call(RequestBody::GetResultCacheStatus(request), options).await? {
            ResultBody::GetResultCacheStatus(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_field_promotion_status` Lodestone API command.
    pub async fn get_field_promotion_status(
        &self,
        request: GetFieldPromotionStatusRequest,
        options: CallOptions,
    ) -> Result<GetFieldPromotionStatusResult, ClientError> {
        match self
            .call(RequestBody::GetFieldPromotionStatus(request), options)
            .await?
        {
            ResultBody::GetFieldPromotionStatus(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_overload_status` Lodestone API command.
    pub async fn get_overload_status(
        &self,
        request: GetOverloadStatusRequest,
        options: CallOptions,
    ) -> Result<GetOverloadStatusResult, ClientError> {
        match self.call(RequestBody::GetOverloadStatus(request), options).await? {
            ResultBody::GetOverloadStatus(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `configure_external_key` Lodestone API command.
    pub async fn configure_external_key(
        &self,
        request: ConfigureExternalKeyRequest,
        options: CallOptions,
    ) -> Result<ConfigureExternalKeyResult, ClientError> {
        match self.call(RequestBody::ConfigureExternalKey(request), options).await? {
            ResultBody::ConfigureExternalKey(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `rotate_external_key_binding` Lodestone API command.
    pub async fn rotate_external_key_binding(
        &self,
        request: RotateExternalKeyBindingRequest,
        options: CallOptions,
    ) -> Result<RotateExternalKeyBindingResult, ClientError> {
        match self
            .call(RequestBody::RotateExternalKeyBinding(request), options)
            .await?
        {
            ResultBody::RotateExternalKeyBinding(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `configure_aggregate_then_delete` Lodestone API command.
    pub async fn configure_aggregate_then_delete(
        &self,
        request: ConfigureAggregateThenDeleteRequest,
        options: CallOptions,
    ) -> Result<ConfigureAggregateThenDeleteResult, ClientError> {
        match self
            .call(RequestBody::ConfigureAggregateThenDelete(request), options)
            .await?
        {
            ResultBody::ConfigureAggregateThenDelete(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_lifecycle_status` Lodestone API command.
    pub async fn get_lifecycle_status(
        &self,
        request: GetLifecycleStatusRequest,
        options: CallOptions,
    ) -> Result<GetLifecycleStatusResult, ClientError> {
        match self.call(RequestBody::GetLifecycleStatus(request), options).await? {
            ResultBody::GetLifecycleStatus(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_quota` Lodestone API command.
    pub async fn get_quota(
        &self,
        request: GetQuotaRequest,
        options: CallOptions,
    ) -> Result<GetQuotaResult, ClientError> {
        match self.call(RequestBody::GetQuota(request), options).await? {
            ResultBody::GetQuota(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `update_quota` Lodestone API command.
    pub async fn update_quota(
        &self,
        request: UpdateQuotaRequest,
        options: CallOptions,
    ) -> Result<UpdateQuotaResult, ClientError> {
        match self.call(RequestBody::UpdateQuota(request), options).await? {
            ResultBody::UpdateQuota(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_binding` Lodestone API command.
    pub async fn get_binding(
        &self,
        request: GetBindingRequest,
        options: CallOptions,
    ) -> Result<GetBindingResult, ClientError> {
        match self.call(RequestBody::GetBinding(request), options).await? {
            ResultBody::GetBinding(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_admission_status` Lodestone API command.
    pub async fn get_admission_status(
        &self,
        request: GetAdmissionStatusRequest,
        options: CallOptions,
    ) -> Result<GetAdmissionStatusResult, ClientError> {
        match self.call(RequestBody::GetAdmissionStatus(request), options).await? {
            ResultBody::GetAdmissionStatus(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `set_admission` Lodestone API command.
    pub async fn set_admission(
        &self,
        request: SetAdmissionRequest,
        options: CallOptions,
    ) -> Result<SetAdmissionResult, ClientError> {
        match self.call(RequestBody::SetAdmission(request), options).await? {
            ResultBody::SetAdmission(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_quiesce_status` Lodestone API command.
    pub async fn get_quiesce_status(
        &self,
        request: GetQuiesceStatusRequest,
        options: CallOptions,
    ) -> Result<GetQuiesceStatusResult, ClientError> {
        match self.call(RequestBody::GetQuiesceStatus(request), options).await? {
            ResultBody::GetQuiesceStatus(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_decommission_readiness` Lodestone API command.
    pub async fn get_decommission_readiness(
        &self,
        request: GetDecommissionReadinessRequest,
        options: CallOptions,
    ) -> Result<GetDecommissionReadinessResult, ClientError> {
        match self
            .call(RequestBody::GetDecommissionReadiness(request), options)
            .await?
        {
            ResultBody::GetDecommissionReadiness(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_upgrade_readiness` Lodestone API command.
    pub async fn get_upgrade_readiness(
        &self,
        request: GetUpgradeReadinessRequest,
        options: CallOptions,
    ) -> Result<GetUpgradeReadinessResult, ClientError> {
        match self.call(RequestBody::GetUpgradeReadiness(request), options).await? {
            ResultBody::GetUpgradeReadiness(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_maintenance_status` Lodestone API command.
    pub async fn get_maintenance_status(
        &self,
        request: GetMaintenanceStatusRequest,
        options: CallOptions,
    ) -> Result<GetMaintenanceStatusResult, ClientError> {
        match self.call(RequestBody::GetMaintenanceStatus(request), options).await? {
            ResultBody::GetMaintenanceStatus(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_restore_readiness` Lodestone API command.
    pub async fn get_restore_readiness(
        &self,
        request: GetRestoreReadinessRequest,
        options: CallOptions,
    ) -> Result<GetRestoreReadinessResult, ClientError> {
        match self.call(RequestBody::GetRestoreReadiness(request), options).await? {
            ResultBody::GetRestoreReadiness(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `warm_vector_index` Lodestone API command.
    pub async fn warm_vector_index(
        &self,
        request: WarmVectorIndexRequest,
        options: CallOptions,
    ) -> Result<WarmVectorIndexResult, ClientError> {
        match self.call(RequestBody::WarmVectorIndex(request), options).await? {
            ResultBody::WarmVectorIndex(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `evaluate_vector_recall` Lodestone API command.
    pub async fn evaluate_vector_recall(
        &self,
        request: EvaluateVectorRecallRequest,
        options: CallOptions,
    ) -> Result<EvaluateVectorRecallResult, ClientError> {
        match self.call(RequestBody::EvaluateVectorRecall(request), options).await? {
            ResultBody::EvaluateVectorRecall(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `calibrate_vector_strategy` Lodestone API command.
    pub async fn calibrate_vector_strategy(
        &self,
        request: CalibrateVectorStrategyRequest,
        options: CallOptions,
    ) -> Result<CalibrateVectorStrategyResult, ClientError> {
        match self
            .call(RequestBody::CalibrateVectorStrategy(request), options)
            .await?
        {
            ResultBody::CalibrateVectorStrategy(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_vector_diagnostic` Lodestone API command.
    pub async fn get_vector_diagnostic(
        &self,
        request: GetVectorDiagnosticRequest,
        options: CallOptions,
    ) -> Result<GetVectorDiagnosticResult, ClientError> {
        match self.call(RequestBody::GetVectorDiagnostic(request), options).await? {
            ResultBody::GetVectorDiagnostic(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `create_diagnostic` Lodestone API command.
    pub async fn create_diagnostic(
        &self,
        request: CreateDiagnosticRequest,
        options: CallOptions,
    ) -> Result<CreateDiagnosticResult, ClientError> {
        match self.call(RequestBody::CreateDiagnostic(request), options).await? {
            ResultBody::CreateDiagnostic(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `get_diagnostic` Lodestone API command.
    pub async fn get_diagnostic(
        &self,
        request: GetDiagnosticRequest,
        options: CallOptions,
    ) -> Result<GetDiagnosticResult, ClientError> {
        match self.call(RequestBody::GetDiagnostic(request), options).await? {
            ResultBody::GetDiagnostic(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `read_artifact_chunk` Lodestone API command.
    pub async fn read_artifact_chunk(
        &self,
        request: ReadArtifactChunkRequest,
        options: CallOptions,
    ) -> Result<ReadArtifactChunkResult, ClientError> {
        match self.call(RequestBody::ReadArtifactChunk(request), options).await? {
            ResultBody::ReadArtifactChunk(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `export_usage` Lodestone API command.
    pub async fn export_usage(
        &self,
        request: ExportUsageRequest,
        options: CallOptions,
    ) -> Result<ExportUsageResult, ClientError> {
        match self.call(RequestBody::ExportUsage(request), options).await? {
            ResultBody::ExportUsage(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `execute_state_read` Lodestone API command.
    pub async fn execute_state_read(
        &self,
        request: ExecuteStateReadRequest,
        options: CallOptions,
    ) -> Result<ExecuteStateReadResult, ClientError> {
        match self.call(RequestBody::ExecuteStateRead(request), options).await? {
            ResultBody::ExecuteStateRead(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `prepare_state_write` Lodestone API command.
    pub async fn prepare_state_write(
        &self,
        request: PrepareStateWriteRequest,
        options: CallOptions,
    ) -> Result<PrepareStateWriteResult, ClientError> {
        match self.call(RequestBody::PrepareStateWrite(request), options).await? {
            ResultBody::PrepareStateWrite(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `submit_state_write` Lodestone API command.
    pub async fn submit_state_write(
        &self,
        request: SubmitStateWriteRequest,
        options: CallOptions,
    ) -> Result<SubmitStateWriteResult, ClientError> {
        match self.call(RequestBody::SubmitStateWrite(request), options).await? {
            ResultBody::SubmitStateWrite(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }

    /// Calls the generated `resolve_state_write` Lodestone API command.
    pub async fn resolve_state_write(
        &self,
        request: ResolveStateWriteRequest,
        options: CallOptions,
    ) -> Result<ResolveStateWriteResult, ClientError> {
        match self.call(RequestBody::ResolveStateWrite(request), options).await? {
            ResultBody::ResolveStateWrite(result) => Ok(result),
            _ => Err(ClientError::ResponseCommandMismatch),
        }
    }
}