google_cloud_aiplatform_v1/

stub.rs

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

//! Traits to mock the clients in this library.
//!
//! Application developers may need to mock the clients in this library to test
//! how their application works with different (and sometimes hard to trigger)
//! client and service behavior. Such test can define mocks implementing the
//! trait(s) defined in this module, initialize the client with an instance of
//! this mock in their tests, and verify their application responds as expected.

#![allow(rustdoc::broken_intra_doc_links)]

#[cfg(any(
    feature = "dataset-service",
    feature = "deployment-resource-pool-service",
    feature = "endpoint-service",
    feature = "evaluation-service",
    feature = "feature-online-store-admin-service",
    feature = "feature-online-store-service",
    feature = "feature-registry-service",
    feature = "featurestore-online-serving-service",
    feature = "featurestore-service",
    feature = "gen-ai-cache-service",
    feature = "gen-ai-tuning-service",
    feature = "index-endpoint-service",
    feature = "index-service",
    feature = "job-service",
    feature = "llm-utility-service",
    feature = "match-service",
    feature = "metadata-service",
    feature = "migration-service",
    feature = "model-garden-service",
    feature = "model-service",
    feature = "notebook-service",
    feature = "persistent-resource-service",
    feature = "pipeline-service",
    feature = "prediction-service",
    feature = "reasoning-engine-execution-service",
    feature = "reasoning-engine-service",
    feature = "schedule-service",
    feature = "specialist-pool-service",
    feature = "tensorboard-service",
    feature = "vertex-rag-data-service",
    feature = "vertex-rag-service",
    feature = "vizier-service",
))]
use gax::error::Error;

pub(crate) mod dynamic;

/// Defines the trait used to implement [super::client::DatasetService].
///
/// Application developers may need to implement this trait to mock
/// `client::DatasetService`.  In other use-cases, application developers only
/// use `client::DatasetService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "dataset-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "dataset-service")))]
pub trait DatasetService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::DatasetService::create_dataset].
    fn create_dataset(
        &self,
        _req: crate::model::CreateDatasetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::get_dataset].
    fn get_dataset(
        &self,
        _req: crate::model::GetDatasetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Dataset>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Dataset>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::DatasetService::update_dataset].
    fn update_dataset(
        &self,
        _req: crate::model::UpdateDatasetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Dataset>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Dataset>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::DatasetService::list_datasets].
    fn list_datasets(
        &self,
        _req: crate::model::ListDatasetsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListDatasetsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListDatasetsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::delete_dataset].
    fn delete_dataset(
        &self,
        _req: crate::model::DeleteDatasetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::import_data].
    fn import_data(
        &self,
        _req: crate::model::ImportDataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::export_data].
    fn export_data(
        &self,
        _req: crate::model::ExportDataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::create_dataset_version].
    fn create_dataset_version(
        &self,
        _req: crate::model::CreateDatasetVersionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::update_dataset_version].
    fn update_dataset_version(
        &self,
        _req: crate::model::UpdateDatasetVersionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DatasetVersion>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::DatasetVersion>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::delete_dataset_version].
    fn delete_dataset_version(
        &self,
        _req: crate::model::DeleteDatasetVersionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::get_dataset_version].
    fn get_dataset_version(
        &self,
        _req: crate::model::GetDatasetVersionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DatasetVersion>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::DatasetVersion>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::list_dataset_versions].
    fn list_dataset_versions(
        &self,
        _req: crate::model::ListDatasetVersionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListDatasetVersionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListDatasetVersionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::restore_dataset_version].
    fn restore_dataset_version(
        &self,
        _req: crate::model::RestoreDatasetVersionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::list_data_items].
    fn list_data_items(
        &self,
        _req: crate::model::ListDataItemsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListDataItemsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListDataItemsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::search_data_items].
    fn search_data_items(
        &self,
        _req: crate::model::SearchDataItemsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SearchDataItemsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::SearchDataItemsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::list_saved_queries].
    fn list_saved_queries(
        &self,
        _req: crate::model::ListSavedQueriesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListSavedQueriesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListSavedQueriesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::delete_saved_query].
    fn delete_saved_query(
        &self,
        _req: crate::model::DeleteSavedQueryRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::get_annotation_spec].
    fn get_annotation_spec(
        &self,
        _req: crate::model::GetAnnotationSpecRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AnnotationSpec>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::AnnotationSpec>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::list_annotations].
    fn list_annotations(
        &self,
        _req: crate::model::ListAnnotationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListAnnotationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListAnnotationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::DatasetService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::DatasetService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DatasetService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DatasetService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::DatasetService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::DatasetService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::DeploymentResourcePoolService].
///
/// Application developers may need to implement this trait to mock
/// `client::DeploymentResourcePoolService`.  In other use-cases, application developers only
/// use `client::DeploymentResourcePoolService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "deployment-resource-pool-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "deployment-resource-pool-service")))]
pub trait DeploymentResourcePoolService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::DeploymentResourcePoolService::create_deployment_resource_pool].
    fn create_deployment_resource_pool(
        &self,
        _req: crate::model::CreateDeploymentResourcePoolRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DeploymentResourcePoolService::get_deployment_resource_pool].
    fn get_deployment_resource_pool(
        &self,
        _req: crate::model::GetDeploymentResourcePoolRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DeploymentResourcePool>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::DeploymentResourcePool>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DeploymentResourcePoolService::list_deployment_resource_pools].
    fn list_deployment_resource_pools(
        &self,
        _req: crate::model::ListDeploymentResourcePoolsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListDeploymentResourcePoolsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::ListDeploymentResourcePoolsResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DeploymentResourcePoolService::update_deployment_resource_pool].
    fn update_deployment_resource_pool(
        &self,
        _req: crate::model::UpdateDeploymentResourcePoolRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DeploymentResourcePoolService::delete_deployment_resource_pool].
    fn delete_deployment_resource_pool(
        &self,
        _req: crate::model::DeleteDeploymentResourcePoolRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DeploymentResourcePoolService::query_deployed_models].
    fn query_deployed_models(
        &self,
        _req: crate::model::QueryDeployedModelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::QueryDeployedModelsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::QueryDeployedModelsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DeploymentResourcePoolService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DeploymentResourcePoolService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DeploymentResourcePoolService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::DeploymentResourcePoolService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::DeploymentResourcePoolService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DeploymentResourcePoolService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::DeploymentResourcePoolService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::DeploymentResourcePoolService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::DeploymentResourcePoolService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::DeploymentResourcePoolService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::EndpointService].
///
/// Application developers may need to implement this trait to mock
/// `client::EndpointService`.  In other use-cases, application developers only
/// use `client::EndpointService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "endpoint-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "endpoint-service")))]
pub trait EndpointService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::EndpointService::create_endpoint].
    fn create_endpoint(
        &self,
        _req: crate::model::CreateEndpointRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EndpointService::get_endpoint].
    fn get_endpoint(
        &self,
        _req: crate::model::GetEndpointRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Endpoint>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Endpoint>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::EndpointService::list_endpoints].
    fn list_endpoints(
        &self,
        _req: crate::model::ListEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListEndpointsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListEndpointsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::EndpointService::update_endpoint].
    fn update_endpoint(
        &self,
        _req: crate::model::UpdateEndpointRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Endpoint>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Endpoint>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::EndpointService::update_endpoint_long_running].
    fn update_endpoint_long_running(
        &self,
        _req: crate::model::UpdateEndpointLongRunningRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EndpointService::delete_endpoint].
    fn delete_endpoint(
        &self,
        _req: crate::model::DeleteEndpointRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EndpointService::deploy_model].
    fn deploy_model(
        &self,
        _req: crate::model::DeployModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EndpointService::undeploy_model].
    fn undeploy_model(
        &self,
        _req: crate::model::UndeployModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EndpointService::mutate_deployed_model].
    fn mutate_deployed_model(
        &self,
        _req: crate::model::MutateDeployedModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EndpointService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::EndpointService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EndpointService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::EndpointService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::EndpointService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::EndpointService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::EndpointService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EndpointService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::EndpointService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::EndpointService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::EvaluationService].
///
/// Application developers may need to implement this trait to mock
/// `client::EvaluationService`.  In other use-cases, application developers only
/// use `client::EvaluationService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "evaluation-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "evaluation-service")))]
pub trait EvaluationService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::EvaluationService::evaluate_instances].
    fn evaluate_instances(
        &self,
        _req: crate::model::EvaluateInstancesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::EvaluateInstancesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::EvaluateInstancesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::EvaluationService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::EvaluationService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EvaluationService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::EvaluationService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::EvaluationService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::EvaluationService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::EvaluationService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::EvaluationService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::EvaluationService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::EvaluationService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::FeatureOnlineStoreAdminService].
///
/// Application developers may need to implement this trait to mock
/// `client::FeatureOnlineStoreAdminService`.  In other use-cases, application developers only
/// use `client::FeatureOnlineStoreAdminService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "feature-online-store-admin-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "feature-online-store-admin-service")))]
pub trait FeatureOnlineStoreAdminService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::FeatureOnlineStoreAdminService::create_feature_online_store].
    fn create_feature_online_store(
        &self,
        _req: crate::model::CreateFeatureOnlineStoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::get_feature_online_store].
    fn get_feature_online_store(
        &self,
        _req: crate::model::GetFeatureOnlineStoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FeatureOnlineStore>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::FeatureOnlineStore>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::list_feature_online_stores].
    fn list_feature_online_stores(
        &self,
        _req: crate::model::ListFeatureOnlineStoresRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListFeatureOnlineStoresResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListFeatureOnlineStoresResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::update_feature_online_store].
    fn update_feature_online_store(
        &self,
        _req: crate::model::UpdateFeatureOnlineStoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::delete_feature_online_store].
    fn delete_feature_online_store(
        &self,
        _req: crate::model::DeleteFeatureOnlineStoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::create_feature_view].
    fn create_feature_view(
        &self,
        _req: crate::model::CreateFeatureViewRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::get_feature_view].
    fn get_feature_view(
        &self,
        _req: crate::model::GetFeatureViewRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FeatureView>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::FeatureView>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::list_feature_views].
    fn list_feature_views(
        &self,
        _req: crate::model::ListFeatureViewsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListFeatureViewsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListFeatureViewsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::update_feature_view].
    fn update_feature_view(
        &self,
        _req: crate::model::UpdateFeatureViewRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::delete_feature_view].
    fn delete_feature_view(
        &self,
        _req: crate::model::DeleteFeatureViewRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::sync_feature_view].
    fn sync_feature_view(
        &self,
        _req: crate::model::SyncFeatureViewRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SyncFeatureViewResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::SyncFeatureViewResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::get_feature_view_sync].
    fn get_feature_view_sync(
        &self,
        _req: crate::model::GetFeatureViewSyncRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FeatureViewSync>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::FeatureViewSync>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::list_feature_view_syncs].
    fn list_feature_view_syncs(
        &self,
        _req: crate::model::ListFeatureViewSyncsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListFeatureViewSyncsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListFeatureViewSyncsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeatureOnlineStoreAdminService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::FeatureOnlineStoreService].
///
/// Application developers may need to implement this trait to mock
/// `client::FeatureOnlineStoreService`.  In other use-cases, application developers only
/// use `client::FeatureOnlineStoreService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "feature-online-store-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "feature-online-store-service")))]
pub trait FeatureOnlineStoreService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::FeatureOnlineStoreService::fetch_feature_values].
    fn fetch_feature_values(
        &self,
        _req: crate::model::FetchFeatureValuesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FetchFeatureValuesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::FetchFeatureValuesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreService::search_nearest_entities].
    fn search_nearest_entities(
        &self,
        _req: crate::model::SearchNearestEntitiesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::SearchNearestEntitiesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::SearchNearestEntitiesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeatureOnlineStoreService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeatureOnlineStoreService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureOnlineStoreService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureOnlineStoreService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeatureOnlineStoreService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeatureOnlineStoreService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::FeatureRegistryService].
///
/// Application developers may need to implement this trait to mock
/// `client::FeatureRegistryService`.  In other use-cases, application developers only
/// use `client::FeatureRegistryService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "feature-registry-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "feature-registry-service")))]
pub trait FeatureRegistryService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::FeatureRegistryService::create_feature_group].
    fn create_feature_group(
        &self,
        _req: crate::model::CreateFeatureGroupRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::get_feature_group].
    fn get_feature_group(
        &self,
        _req: crate::model::GetFeatureGroupRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FeatureGroup>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::FeatureGroup>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::list_feature_groups].
    fn list_feature_groups(
        &self,
        _req: crate::model::ListFeatureGroupsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListFeatureGroupsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListFeatureGroupsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureRegistryService::update_feature_group].
    fn update_feature_group(
        &self,
        _req: crate::model::UpdateFeatureGroupRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::delete_feature_group].
    fn delete_feature_group(
        &self,
        _req: crate::model::DeleteFeatureGroupRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::create_feature].
    fn create_feature(
        &self,
        _req: crate::model::CreateFeatureRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::batch_create_features].
    fn batch_create_features(
        &self,
        _req: crate::model::BatchCreateFeaturesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::get_feature].
    fn get_feature(
        &self,
        _req: crate::model::GetFeatureRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Feature>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Feature>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeatureRegistryService::list_features].
    fn list_features(
        &self,
        _req: crate::model::ListFeaturesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListFeaturesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListFeaturesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureRegistryService::update_feature].
    fn update_feature(
        &self,
        _req: crate::model::UpdateFeatureRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::delete_feature].
    fn delete_feature(
        &self,
        _req: crate::model::DeleteFeatureRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureRegistryService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeatureRegistryService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeatureRegistryService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureRegistryService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeatureRegistryService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeatureRegistryService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeatureRegistryService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeatureRegistryService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::FeaturestoreOnlineServingService].
///
/// Application developers may need to implement this trait to mock
/// `client::FeaturestoreOnlineServingService`.  In other use-cases, application developers only
/// use `client::FeaturestoreOnlineServingService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "featurestore-online-serving-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "featurestore-online-serving-service")))]
pub trait FeaturestoreOnlineServingService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::FeaturestoreOnlineServingService::read_feature_values].
    fn read_feature_values(
        &self,
        _req: crate::model::ReadFeatureValuesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ReadFeatureValuesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ReadFeatureValuesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::write_feature_values].
    fn write_feature_values(
        &self,
        _req: crate::model::WriteFeatureValuesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::WriteFeatureValuesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::WriteFeatureValuesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeaturestoreOnlineServingService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::FeaturestoreService].
///
/// Application developers may need to implement this trait to mock
/// `client::FeaturestoreService`.  In other use-cases, application developers only
/// use `client::FeaturestoreService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "featurestore-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "featurestore-service")))]
pub trait FeaturestoreService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::FeaturestoreService::create_featurestore].
    fn create_featurestore(
        &self,
        _req: crate::model::CreateFeaturestoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::get_featurestore].
    fn get_featurestore(
        &self,
        _req: crate::model::GetFeaturestoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Featurestore>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Featurestore>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::list_featurestores].
    fn list_featurestores(
        &self,
        _req: crate::model::ListFeaturestoresRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListFeaturestoresResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListFeaturestoresResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreService::update_featurestore].
    fn update_featurestore(
        &self,
        _req: crate::model::UpdateFeaturestoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::delete_featurestore].
    fn delete_featurestore(
        &self,
        _req: crate::model::DeleteFeaturestoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::create_entity_type].
    fn create_entity_type(
        &self,
        _req: crate::model::CreateEntityTypeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::get_entity_type].
    fn get_entity_type(
        &self,
        _req: crate::model::GetEntityTypeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::EntityType>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::EntityType>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeaturestoreService::list_entity_types].
    fn list_entity_types(
        &self,
        _req: crate::model::ListEntityTypesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListEntityTypesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListEntityTypesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreService::update_entity_type].
    fn update_entity_type(
        &self,
        _req: crate::model::UpdateEntityTypeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::EntityType>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::EntityType>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeaturestoreService::delete_entity_type].
    fn delete_entity_type(
        &self,
        _req: crate::model::DeleteEntityTypeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::create_feature].
    fn create_feature(
        &self,
        _req: crate::model::CreateFeatureRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::batch_create_features].
    fn batch_create_features(
        &self,
        _req: crate::model::BatchCreateFeaturesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::get_feature].
    fn get_feature(
        &self,
        _req: crate::model::GetFeatureRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Feature>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Feature>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeaturestoreService::list_features].
    fn list_features(
        &self,
        _req: crate::model::ListFeaturesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListFeaturesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListFeaturesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreService::update_feature].
    fn update_feature(
        &self,
        _req: crate::model::UpdateFeatureRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Feature>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Feature>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeaturestoreService::delete_feature].
    fn delete_feature(
        &self,
        _req: crate::model::DeleteFeatureRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::import_feature_values].
    fn import_feature_values(
        &self,
        _req: crate::model::ImportFeatureValuesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::batch_read_feature_values].
    fn batch_read_feature_values(
        &self,
        _req: crate::model::BatchReadFeatureValuesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::export_feature_values].
    fn export_feature_values(
        &self,
        _req: crate::model::ExportFeatureValuesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::delete_feature_values].
    fn delete_feature_values(
        &self,
        _req: crate::model::DeleteFeatureValuesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::search_features].
    fn search_features(
        &self,
        _req: crate::model::SearchFeaturesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SearchFeaturesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::SearchFeaturesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeaturestoreService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::FeaturestoreService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::FeaturestoreService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::FeaturestoreService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeaturestoreService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::FeaturestoreService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::GenAiCacheService].
///
/// Application developers may need to implement this trait to mock
/// `client::GenAiCacheService`.  In other use-cases, application developers only
/// use `client::GenAiCacheService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "gen-ai-cache-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "gen-ai-cache-service")))]
pub trait GenAiCacheService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::GenAiCacheService::create_cached_content].
    fn create_cached_content(
        &self,
        _req: crate::model::CreateCachedContentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CachedContent>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::CachedContent>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::GenAiCacheService::get_cached_content].
    fn get_cached_content(
        &self,
        _req: crate::model::GetCachedContentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CachedContent>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::CachedContent>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::GenAiCacheService::update_cached_content].
    fn update_cached_content(
        &self,
        _req: crate::model::UpdateCachedContentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CachedContent>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::CachedContent>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::GenAiCacheService::delete_cached_content].
    fn delete_cached_content(
        &self,
        _req: crate::model::DeleteCachedContentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::GenAiCacheService::list_cached_contents].
    fn list_cached_contents(
        &self,
        _req: crate::model::ListCachedContentsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListCachedContentsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListCachedContentsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::GenAiCacheService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::GenAiCacheService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::GenAiCacheService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::GenAiCacheService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::GenAiCacheService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::GenAiCacheService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::GenAiCacheService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::GenAiCacheService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::GenAiCacheService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::GenAiCacheService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::GenAiTuningService].
///
/// Application developers may need to implement this trait to mock
/// `client::GenAiTuningService`.  In other use-cases, application developers only
/// use `client::GenAiTuningService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "gen-ai-tuning-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "gen-ai-tuning-service")))]
pub trait GenAiTuningService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::GenAiTuningService::create_tuning_job].
    fn create_tuning_job(
        &self,
        _req: crate::model::CreateTuningJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TuningJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::TuningJob>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::GenAiTuningService::get_tuning_job].
    fn get_tuning_job(
        &self,
        _req: crate::model::GetTuningJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TuningJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::TuningJob>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::GenAiTuningService::list_tuning_jobs].
    fn list_tuning_jobs(
        &self,
        _req: crate::model::ListTuningJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListTuningJobsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListTuningJobsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::GenAiTuningService::cancel_tuning_job].
    fn cancel_tuning_job(
        &self,
        _req: crate::model::CancelTuningJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::GenAiTuningService::rebase_tuned_model].
    fn rebase_tuned_model(
        &self,
        _req: crate::model::RebaseTunedModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::GenAiTuningService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::GenAiTuningService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::GenAiTuningService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::GenAiTuningService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::GenAiTuningService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::GenAiTuningService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::GenAiTuningService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::GenAiTuningService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::GenAiTuningService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::GenAiTuningService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::IndexEndpointService].
///
/// Application developers may need to implement this trait to mock
/// `client::IndexEndpointService`.  In other use-cases, application developers only
/// use `client::IndexEndpointService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "index-endpoint-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "index-endpoint-service")))]
pub trait IndexEndpointService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::IndexEndpointService::create_index_endpoint].
    fn create_index_endpoint(
        &self,
        _req: crate::model::CreateIndexEndpointRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::get_index_endpoint].
    fn get_index_endpoint(
        &self,
        _req: crate::model::GetIndexEndpointRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::IndexEndpoint>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::IndexEndpoint>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::list_index_endpoints].
    fn list_index_endpoints(
        &self,
        _req: crate::model::ListIndexEndpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListIndexEndpointsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListIndexEndpointsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexEndpointService::update_index_endpoint].
    fn update_index_endpoint(
        &self,
        _req: crate::model::UpdateIndexEndpointRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::IndexEndpoint>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::IndexEndpoint>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::delete_index_endpoint].
    fn delete_index_endpoint(
        &self,
        _req: crate::model::DeleteIndexEndpointRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::deploy_index].
    fn deploy_index(
        &self,
        _req: crate::model::DeployIndexRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::undeploy_index].
    fn undeploy_index(
        &self,
        _req: crate::model::UndeployIndexRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::mutate_deployed_index].
    fn mutate_deployed_index(
        &self,
        _req: crate::model::MutateDeployedIndexRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexEndpointService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::IndexEndpointService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::IndexEndpointService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexEndpointService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexEndpointService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexEndpointService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::IndexEndpointService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::IndexEndpointService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::IndexService].
///
/// Application developers may need to implement this trait to mock
/// `client::IndexService`.  In other use-cases, application developers only
/// use `client::IndexService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "index-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "index-service")))]
pub trait IndexService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::IndexService::create_index].
    fn create_index(
        &self,
        _req: crate::model::CreateIndexRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexService::get_index].
    fn get_index(
        &self,
        _req: crate::model::GetIndexRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Index>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Index>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::IndexService::list_indexes].
    fn list_indexes(
        &self,
        _req: crate::model::ListIndexesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListIndexesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListIndexesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexService::update_index].
    fn update_index(
        &self,
        _req: crate::model::UpdateIndexRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexService::delete_index].
    fn delete_index(
        &self,
        _req: crate::model::DeleteIndexRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexService::upsert_datapoints].
    fn upsert_datapoints(
        &self,
        _req: crate::model::UpsertDatapointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UpsertDatapointsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::UpsertDatapointsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexService::remove_datapoints].
    fn remove_datapoints(
        &self,
        _req: crate::model::RemoveDatapointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RemoveDatapointsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::RemoveDatapointsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::IndexService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::IndexService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::IndexService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::IndexService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::IndexService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::IndexService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::JobService].
///
/// Application developers may need to implement this trait to mock
/// `client::JobService`.  In other use-cases, application developers only
/// use `client::JobService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "job-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "job-service")))]
pub trait JobService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::JobService::create_custom_job].
    fn create_custom_job(
        &self,
        _req: crate::model::CreateCustomJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CustomJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::CustomJob>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::JobService::get_custom_job].
    fn get_custom_job(
        &self,
        _req: crate::model::GetCustomJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CustomJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::CustomJob>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::JobService::list_custom_jobs].
    fn list_custom_jobs(
        &self,
        _req: crate::model::ListCustomJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListCustomJobsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListCustomJobsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::delete_custom_job].
    fn delete_custom_job(
        &self,
        _req: crate::model::DeleteCustomJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::cancel_custom_job].
    fn cancel_custom_job(
        &self,
        _req: crate::model::CancelCustomJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::create_data_labeling_job].
    fn create_data_labeling_job(
        &self,
        _req: crate::model::CreateDataLabelingJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DataLabelingJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::DataLabelingJob>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::get_data_labeling_job].
    fn get_data_labeling_job(
        &self,
        _req: crate::model::GetDataLabelingJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DataLabelingJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::DataLabelingJob>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::list_data_labeling_jobs].
    fn list_data_labeling_jobs(
        &self,
        _req: crate::model::ListDataLabelingJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListDataLabelingJobsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListDataLabelingJobsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::delete_data_labeling_job].
    fn delete_data_labeling_job(
        &self,
        _req: crate::model::DeleteDataLabelingJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::cancel_data_labeling_job].
    fn cancel_data_labeling_job(
        &self,
        _req: crate::model::CancelDataLabelingJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::create_hyperparameter_tuning_job].
    fn create_hyperparameter_tuning_job(
        &self,
        _req: crate::model::CreateHyperparameterTuningJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HyperparameterTuningJob>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::HyperparameterTuningJob>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::get_hyperparameter_tuning_job].
    fn get_hyperparameter_tuning_job(
        &self,
        _req: crate::model::GetHyperparameterTuningJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::HyperparameterTuningJob>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::HyperparameterTuningJob>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::list_hyperparameter_tuning_jobs].
    fn list_hyperparameter_tuning_jobs(
        &self,
        _req: crate::model::ListHyperparameterTuningJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListHyperparameterTuningJobsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::ListHyperparameterTuningJobsResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::delete_hyperparameter_tuning_job].
    fn delete_hyperparameter_tuning_job(
        &self,
        _req: crate::model::DeleteHyperparameterTuningJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::cancel_hyperparameter_tuning_job].
    fn cancel_hyperparameter_tuning_job(
        &self,
        _req: crate::model::CancelHyperparameterTuningJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::create_nas_job].
    fn create_nas_job(
        &self,
        _req: crate::model::CreateNasJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NasJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::NasJob>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::JobService::get_nas_job].
    fn get_nas_job(
        &self,
        _req: crate::model::GetNasJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NasJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::NasJob>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::JobService::list_nas_jobs].
    fn list_nas_jobs(
        &self,
        _req: crate::model::ListNasJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListNasJobsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListNasJobsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::delete_nas_job].
    fn delete_nas_job(
        &self,
        _req: crate::model::DeleteNasJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::cancel_nas_job].
    fn cancel_nas_job(
        &self,
        _req: crate::model::CancelNasJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::get_nas_trial_detail].
    fn get_nas_trial_detail(
        &self,
        _req: crate::model::GetNasTrialDetailRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NasTrialDetail>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::NasTrialDetail>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::list_nas_trial_details].
    fn list_nas_trial_details(
        &self,
        _req: crate::model::ListNasTrialDetailsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListNasTrialDetailsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListNasTrialDetailsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::create_batch_prediction_job].
    fn create_batch_prediction_job(
        &self,
        _req: crate::model::CreateBatchPredictionJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BatchPredictionJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::BatchPredictionJob>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::get_batch_prediction_job].
    fn get_batch_prediction_job(
        &self,
        _req: crate::model::GetBatchPredictionJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::BatchPredictionJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::BatchPredictionJob>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::list_batch_prediction_jobs].
    fn list_batch_prediction_jobs(
        &self,
        _req: crate::model::ListBatchPredictionJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListBatchPredictionJobsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListBatchPredictionJobsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::delete_batch_prediction_job].
    fn delete_batch_prediction_job(
        &self,
        _req: crate::model::DeleteBatchPredictionJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::cancel_batch_prediction_job].
    fn cancel_batch_prediction_job(
        &self,
        _req: crate::model::CancelBatchPredictionJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::create_model_deployment_monitoring_job].
    fn create_model_deployment_monitoring_job(
        &self,
        _req: crate::model::CreateModelDeploymentMonitoringJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ModelDeploymentMonitoringJob>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ModelDeploymentMonitoringJob>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::search_model_deployment_monitoring_stats_anomalies].
    fn search_model_deployment_monitoring_stats_anomalies(
        &self,
        _req: crate::model::SearchModelDeploymentMonitoringStatsAnomaliesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<
                crate::model::SearchModelDeploymentMonitoringStatsAnomaliesResponse,
            >,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<
                    crate::model::SearchModelDeploymentMonitoringStatsAnomaliesResponse,
                >,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::get_model_deployment_monitoring_job].
    fn get_model_deployment_monitoring_job(
        &self,
        _req: crate::model::GetModelDeploymentMonitoringJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ModelDeploymentMonitoringJob>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ModelDeploymentMonitoringJob>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::list_model_deployment_monitoring_jobs].
    fn list_model_deployment_monitoring_jobs(
        &self,
        _req: crate::model::ListModelDeploymentMonitoringJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListModelDeploymentMonitoringJobsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::ListModelDeploymentMonitoringJobsResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::update_model_deployment_monitoring_job].
    fn update_model_deployment_monitoring_job(
        &self,
        _req: crate::model::UpdateModelDeploymentMonitoringJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::delete_model_deployment_monitoring_job].
    fn delete_model_deployment_monitoring_job(
        &self,
        _req: crate::model::DeleteModelDeploymentMonitoringJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::pause_model_deployment_monitoring_job].
    fn pause_model_deployment_monitoring_job(
        &self,
        _req: crate::model::PauseModelDeploymentMonitoringJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::resume_model_deployment_monitoring_job].
    fn resume_model_deployment_monitoring_job(
        &self,
        _req: crate::model::ResumeModelDeploymentMonitoringJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::JobService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::JobService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::JobService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::JobService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::JobService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::LlmUtilityService].
///
/// Application developers may need to implement this trait to mock
/// `client::LlmUtilityService`.  In other use-cases, application developers only
/// use `client::LlmUtilityService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "llm-utility-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "llm-utility-service")))]
pub trait LlmUtilityService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::LlmUtilityService::count_tokens].
    fn count_tokens(
        &self,
        _req: crate::model::CountTokensRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CountTokensResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::CountTokensResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::LlmUtilityService::compute_tokens].
    fn compute_tokens(
        &self,
        _req: crate::model::ComputeTokensRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ComputeTokensResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ComputeTokensResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::LlmUtilityService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::LlmUtilityService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::LlmUtilityService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::LlmUtilityService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::LlmUtilityService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::LlmUtilityService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::LlmUtilityService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::LlmUtilityService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::LlmUtilityService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::LlmUtilityService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::MatchService].
///
/// Application developers may need to implement this trait to mock
/// `client::MatchService`.  In other use-cases, application developers only
/// use `client::MatchService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "match-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "match-service")))]
pub trait MatchService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::MatchService::find_neighbors].
    fn find_neighbors(
        &self,
        _req: crate::model::FindNeighborsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::FindNeighborsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::FindNeighborsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MatchService::read_index_datapoints].
    fn read_index_datapoints(
        &self,
        _req: crate::model::ReadIndexDatapointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ReadIndexDatapointsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ReadIndexDatapointsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MatchService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MatchService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MatchService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MatchService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MatchService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MatchService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MatchService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MatchService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::MatchService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::MatchService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::MetadataService].
///
/// Application developers may need to implement this trait to mock
/// `client::MetadataService`.  In other use-cases, application developers only
/// use `client::MetadataService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "metadata-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "metadata-service")))]
pub trait MetadataService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::MetadataService::create_metadata_store].
    fn create_metadata_store(
        &self,
        _req: crate::model::CreateMetadataStoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::get_metadata_store].
    fn get_metadata_store(
        &self,
        _req: crate::model::GetMetadataStoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::MetadataStore>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::MetadataStore>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::list_metadata_stores].
    fn list_metadata_stores(
        &self,
        _req: crate::model::ListMetadataStoresRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListMetadataStoresResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListMetadataStoresResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::delete_metadata_store].
    fn delete_metadata_store(
        &self,
        _req: crate::model::DeleteMetadataStoreRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::create_artifact].
    fn create_artifact(
        &self,
        _req: crate::model::CreateArtifactRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Artifact>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Artifact>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::get_artifact].
    fn get_artifact(
        &self,
        _req: crate::model::GetArtifactRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Artifact>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Artifact>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::list_artifacts].
    fn list_artifacts(
        &self,
        _req: crate::model::ListArtifactsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListArtifactsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListArtifactsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::update_artifact].
    fn update_artifact(
        &self,
        _req: crate::model::UpdateArtifactRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Artifact>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Artifact>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::delete_artifact].
    fn delete_artifact(
        &self,
        _req: crate::model::DeleteArtifactRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::purge_artifacts].
    fn purge_artifacts(
        &self,
        _req: crate::model::PurgeArtifactsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::create_context].
    fn create_context(
        &self,
        _req: crate::model::CreateContextRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Context>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Context>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::get_context].
    fn get_context(
        &self,
        _req: crate::model::GetContextRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Context>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Context>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::list_contexts].
    fn list_contexts(
        &self,
        _req: crate::model::ListContextsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListContextsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListContextsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::update_context].
    fn update_context(
        &self,
        _req: crate::model::UpdateContextRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Context>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Context>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::delete_context].
    fn delete_context(
        &self,
        _req: crate::model::DeleteContextRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::purge_contexts].
    fn purge_contexts(
        &self,
        _req: crate::model::PurgeContextsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::add_context_artifacts_and_executions].
    fn add_context_artifacts_and_executions(
        &self,
        _req: crate::model::AddContextArtifactsAndExecutionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::AddContextArtifactsAndExecutionsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::AddContextArtifactsAndExecutionsResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::add_context_children].
    fn add_context_children(
        &self,
        _req: crate::model::AddContextChildrenRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AddContextChildrenResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::AddContextChildrenResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::remove_context_children].
    fn remove_context_children(
        &self,
        _req: crate::model::RemoveContextChildrenRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::RemoveContextChildrenResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::RemoveContextChildrenResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::query_context_lineage_subgraph].
    fn query_context_lineage_subgraph(
        &self,
        _req: crate::model::QueryContextLineageSubgraphRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::LineageSubgraph>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::LineageSubgraph>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::create_execution].
    fn create_execution(
        &self,
        _req: crate::model::CreateExecutionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Execution>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Execution>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::get_execution].
    fn get_execution(
        &self,
        _req: crate::model::GetExecutionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Execution>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Execution>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::list_executions].
    fn list_executions(
        &self,
        _req: crate::model::ListExecutionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListExecutionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListExecutionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::update_execution].
    fn update_execution(
        &self,
        _req: crate::model::UpdateExecutionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Execution>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Execution>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::delete_execution].
    fn delete_execution(
        &self,
        _req: crate::model::DeleteExecutionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::purge_executions].
    fn purge_executions(
        &self,
        _req: crate::model::PurgeExecutionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::add_execution_events].
    fn add_execution_events(
        &self,
        _req: crate::model::AddExecutionEventsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AddExecutionEventsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::AddExecutionEventsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::query_execution_inputs_and_outputs].
    fn query_execution_inputs_and_outputs(
        &self,
        _req: crate::model::QueryExecutionInputsAndOutputsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::LineageSubgraph>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::LineageSubgraph>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::create_metadata_schema].
    fn create_metadata_schema(
        &self,
        _req: crate::model::CreateMetadataSchemaRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::MetadataSchema>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::MetadataSchema>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::get_metadata_schema].
    fn get_metadata_schema(
        &self,
        _req: crate::model::GetMetadataSchemaRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::MetadataSchema>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::MetadataSchema>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::list_metadata_schemas].
    fn list_metadata_schemas(
        &self,
        _req: crate::model::ListMetadataSchemasRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListMetadataSchemasResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListMetadataSchemasResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::query_artifact_lineage_subgraph].
    fn query_artifact_lineage_subgraph(
        &self,
        _req: crate::model::QueryArtifactLineageSubgraphRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::LineageSubgraph>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::LineageSubgraph>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MetadataService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MetadataService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MetadataService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::MetadataService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::MetadataService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::MigrationService].
///
/// Application developers may need to implement this trait to mock
/// `client::MigrationService`.  In other use-cases, application developers only
/// use `client::MigrationService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "migration-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "migration-service")))]
pub trait MigrationService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::MigrationService::search_migratable_resources].
    fn search_migratable_resources(
        &self,
        _req: crate::model::SearchMigratableResourcesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::SearchMigratableResourcesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::SearchMigratableResourcesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MigrationService::batch_migrate_resources].
    fn batch_migrate_resources(
        &self,
        _req: crate::model::BatchMigrateResourcesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MigrationService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MigrationService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MigrationService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MigrationService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::MigrationService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MigrationService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::MigrationService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::MigrationService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::MigrationService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::MigrationService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ModelGardenService].
///
/// Application developers may need to implement this trait to mock
/// `client::ModelGardenService`.  In other use-cases, application developers only
/// use `client::ModelGardenService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "model-garden-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "model-garden-service")))]
pub trait ModelGardenService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ModelGardenService::get_publisher_model].
    fn get_publisher_model(
        &self,
        _req: crate::model::GetPublisherModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PublisherModel>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::PublisherModel>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelGardenService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelGardenService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelGardenService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ModelGardenService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ModelGardenService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelGardenService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelGardenService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelGardenService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ModelGardenService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ModelGardenService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::ModelService].
///
/// Application developers may need to implement this trait to mock
/// `client::ModelService`.  In other use-cases, application developers only
/// use `client::ModelService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "model-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "model-service")))]
pub trait ModelService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ModelService::upload_model].
    fn upload_model(
        &self,
        _req: crate::model::UploadModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::get_model].
    fn get_model(
        &self,
        _req: crate::model::GetModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Model>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Model>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ModelService::list_models].
    fn list_models(
        &self,
        _req: crate::model::ListModelsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListModelsResponse>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::ListModelsResponse>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::list_model_versions].
    fn list_model_versions(
        &self,
        _req: crate::model::ListModelVersionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListModelVersionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListModelVersionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::list_model_version_checkpoints].
    fn list_model_version_checkpoints(
        &self,
        _req: crate::model::ListModelVersionCheckpointsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListModelVersionCheckpointsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::ListModelVersionCheckpointsResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::update_model].
    fn update_model(
        &self,
        _req: crate::model::UpdateModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Model>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Model>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ModelService::update_explanation_dataset].
    fn update_explanation_dataset(
        &self,
        _req: crate::model::UpdateExplanationDatasetRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::delete_model].
    fn delete_model(
        &self,
        _req: crate::model::DeleteModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::delete_model_version].
    fn delete_model_version(
        &self,
        _req: crate::model::DeleteModelVersionRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::merge_version_aliases].
    fn merge_version_aliases(
        &self,
        _req: crate::model::MergeVersionAliasesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Model>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Model>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ModelService::export_model].
    fn export_model(
        &self,
        _req: crate::model::ExportModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::copy_model].
    fn copy_model(
        &self,
        _req: crate::model::CopyModelRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::import_model_evaluation].
    fn import_model_evaluation(
        &self,
        _req: crate::model::ImportModelEvaluationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ModelEvaluation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::ModelEvaluation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::batch_import_model_evaluation_slices].
    fn batch_import_model_evaluation_slices(
        &self,
        _req: crate::model::BatchImportModelEvaluationSlicesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::BatchImportModelEvaluationSlicesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::BatchImportModelEvaluationSlicesResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::batch_import_evaluated_annotations].
    fn batch_import_evaluated_annotations(
        &self,
        _req: crate::model::BatchImportEvaluatedAnnotationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::BatchImportEvaluatedAnnotationsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::BatchImportEvaluatedAnnotationsResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::get_model_evaluation].
    fn get_model_evaluation(
        &self,
        _req: crate::model::GetModelEvaluationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ModelEvaluation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::ModelEvaluation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::list_model_evaluations].
    fn list_model_evaluations(
        &self,
        _req: crate::model::ListModelEvaluationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListModelEvaluationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListModelEvaluationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::get_model_evaluation_slice].
    fn get_model_evaluation_slice(
        &self,
        _req: crate::model::GetModelEvaluationSliceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ModelEvaluationSlice>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ModelEvaluationSlice>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::list_model_evaluation_slices].
    fn list_model_evaluation_slices(
        &self,
        _req: crate::model::ListModelEvaluationSlicesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListModelEvaluationSlicesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListModelEvaluationSlicesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ModelService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ModelService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ModelService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ModelService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ModelService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ModelService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::NotebookService].
///
/// Application developers may need to implement this trait to mock
/// `client::NotebookService`.  In other use-cases, application developers only
/// use `client::NotebookService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "notebook-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "notebook-service")))]
pub trait NotebookService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::NotebookService::create_notebook_runtime_template].
    fn create_notebook_runtime_template(
        &self,
        _req: crate::model::CreateNotebookRuntimeTemplateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::get_notebook_runtime_template].
    fn get_notebook_runtime_template(
        &self,
        _req: crate::model::GetNotebookRuntimeTemplateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NotebookRuntimeTemplate>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::NotebookRuntimeTemplate>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::list_notebook_runtime_templates].
    fn list_notebook_runtime_templates(
        &self,
        _req: crate::model::ListNotebookRuntimeTemplatesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListNotebookRuntimeTemplatesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::ListNotebookRuntimeTemplatesResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::delete_notebook_runtime_template].
    fn delete_notebook_runtime_template(
        &self,
        _req: crate::model::DeleteNotebookRuntimeTemplateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::update_notebook_runtime_template].
    fn update_notebook_runtime_template(
        &self,
        _req: crate::model::UpdateNotebookRuntimeTemplateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NotebookRuntimeTemplate>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::NotebookRuntimeTemplate>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::assign_notebook_runtime].
    fn assign_notebook_runtime(
        &self,
        _req: crate::model::AssignNotebookRuntimeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::get_notebook_runtime].
    fn get_notebook_runtime(
        &self,
        _req: crate::model::GetNotebookRuntimeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NotebookRuntime>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::NotebookRuntime>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::list_notebook_runtimes].
    fn list_notebook_runtimes(
        &self,
        _req: crate::model::ListNotebookRuntimesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListNotebookRuntimesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListNotebookRuntimesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::delete_notebook_runtime].
    fn delete_notebook_runtime(
        &self,
        _req: crate::model::DeleteNotebookRuntimeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::upgrade_notebook_runtime].
    fn upgrade_notebook_runtime(
        &self,
        _req: crate::model::UpgradeNotebookRuntimeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::start_notebook_runtime].
    fn start_notebook_runtime(
        &self,
        _req: crate::model::StartNotebookRuntimeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::stop_notebook_runtime].
    fn stop_notebook_runtime(
        &self,
        _req: crate::model::StopNotebookRuntimeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::create_notebook_execution_job].
    fn create_notebook_execution_job(
        &self,
        _req: crate::model::CreateNotebookExecutionJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::get_notebook_execution_job].
    fn get_notebook_execution_job(
        &self,
        _req: crate::model::GetNotebookExecutionJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::NotebookExecutionJob>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::NotebookExecutionJob>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::list_notebook_execution_jobs].
    fn list_notebook_execution_jobs(
        &self,
        _req: crate::model::ListNotebookExecutionJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListNotebookExecutionJobsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListNotebookExecutionJobsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::delete_notebook_execution_job].
    fn delete_notebook_execution_job(
        &self,
        _req: crate::model::DeleteNotebookExecutionJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::NotebookService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::NotebookService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::NotebookService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::NotebookService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::NotebookService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::NotebookService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::PersistentResourceService].
///
/// Application developers may need to implement this trait to mock
/// `client::PersistentResourceService`.  In other use-cases, application developers only
/// use `client::PersistentResourceService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "persistent-resource-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "persistent-resource-service")))]
pub trait PersistentResourceService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::PersistentResourceService::create_persistent_resource].
    fn create_persistent_resource(
        &self,
        _req: crate::model::CreatePersistentResourceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PersistentResourceService::get_persistent_resource].
    fn get_persistent_resource(
        &self,
        _req: crate::model::GetPersistentResourceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PersistentResource>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::PersistentResource>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PersistentResourceService::list_persistent_resources].
    fn list_persistent_resources(
        &self,
        _req: crate::model::ListPersistentResourcesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListPersistentResourcesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListPersistentResourcesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PersistentResourceService::delete_persistent_resource].
    fn delete_persistent_resource(
        &self,
        _req: crate::model::DeletePersistentResourceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PersistentResourceService::update_persistent_resource].
    fn update_persistent_resource(
        &self,
        _req: crate::model::UpdatePersistentResourceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PersistentResourceService::reboot_persistent_resource].
    fn reboot_persistent_resource(
        &self,
        _req: crate::model::RebootPersistentResourceRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PersistentResourceService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PersistentResourceService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PersistentResourceService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::PersistentResourceService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::PersistentResourceService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PersistentResourceService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PersistentResourceService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PersistentResourceService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::PersistentResourceService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::PersistentResourceService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::PipelineService].
///
/// Application developers may need to implement this trait to mock
/// `client::PipelineService`.  In other use-cases, application developers only
/// use `client::PipelineService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "pipeline-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "pipeline-service")))]
pub trait PipelineService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::PipelineService::create_training_pipeline].
    fn create_training_pipeline(
        &self,
        _req: crate::model::CreateTrainingPipelineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TrainingPipeline>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::TrainingPipeline>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::get_training_pipeline].
    fn get_training_pipeline(
        &self,
        _req: crate::model::GetTrainingPipelineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TrainingPipeline>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::TrainingPipeline>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::list_training_pipelines].
    fn list_training_pipelines(
        &self,
        _req: crate::model::ListTrainingPipelinesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListTrainingPipelinesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListTrainingPipelinesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PipelineService::delete_training_pipeline].
    fn delete_training_pipeline(
        &self,
        _req: crate::model::DeleteTrainingPipelineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::cancel_training_pipeline].
    fn cancel_training_pipeline(
        &self,
        _req: crate::model::CancelTrainingPipelineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::PipelineService::create_pipeline_job].
    fn create_pipeline_job(
        &self,
        _req: crate::model::CreatePipelineJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PipelineJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::PipelineJob>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::get_pipeline_job].
    fn get_pipeline_job(
        &self,
        _req: crate::model::GetPipelineJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PipelineJob>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::PipelineJob>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::list_pipeline_jobs].
    fn list_pipeline_jobs(
        &self,
        _req: crate::model::ListPipelineJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListPipelineJobsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListPipelineJobsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PipelineService::delete_pipeline_job].
    fn delete_pipeline_job(
        &self,
        _req: crate::model::DeletePipelineJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::batch_delete_pipeline_jobs].
    fn batch_delete_pipeline_jobs(
        &self,
        _req: crate::model::BatchDeletePipelineJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::cancel_pipeline_job].
    fn cancel_pipeline_job(
        &self,
        _req: crate::model::CancelPipelineJobRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::PipelineService::batch_cancel_pipeline_jobs].
    fn batch_cancel_pipeline_jobs(
        &self,
        _req: crate::model::BatchCancelPipelineJobsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PipelineService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::PipelineService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::PipelineService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PipelineService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PipelineService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PipelineService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::PipelineService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::PipelineService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::PredictionService].
///
/// Application developers may need to implement this trait to mock
/// `client::PredictionService`.  In other use-cases, application developers only
/// use `client::PredictionService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "prediction-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "prediction-service")))]
pub trait PredictionService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::PredictionService::predict].
    fn predict(
        &self,
        _req: crate::model::PredictRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::PredictResponse>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::PredictResponse>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PredictionService::raw_predict].
    fn raw_predict(
        &self,
        _req: crate::model::RawPredictRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<api::model::HttpBody>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<api::model::HttpBody>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::PredictionService::direct_predict].
    fn direct_predict(
        &self,
        _req: crate::model::DirectPredictRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DirectPredictResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::DirectPredictResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PredictionService::direct_raw_predict].
    fn direct_raw_predict(
        &self,
        _req: crate::model::DirectRawPredictRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::DirectRawPredictResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::DirectRawPredictResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PredictionService::explain].
    fn explain(
        &self,
        _req: crate::model::ExplainRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ExplainResponse>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::ExplainResponse>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PredictionService::generate_content].
    fn generate_content(
        &self,
        _req: crate::model::GenerateContentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::GenerateContentResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::GenerateContentResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PredictionService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PredictionService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PredictionService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::PredictionService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::PredictionService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PredictionService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::PredictionService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::PredictionService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::PredictionService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::PredictionService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::ReasoningEngineExecutionService].
///
/// Application developers may need to implement this trait to mock
/// `client::ReasoningEngineExecutionService`.  In other use-cases, application developers only
/// use `client::ReasoningEngineExecutionService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "reasoning-engine-execution-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "reasoning-engine-execution-service")))]
pub trait ReasoningEngineExecutionService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ReasoningEngineExecutionService::query_reasoning_engine].
    fn query_reasoning_engine(
        &self,
        _req: crate::model::QueryReasoningEngineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::QueryReasoningEngineResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::QueryReasoningEngineResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ReasoningEngineExecutionService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ReasoningEngineExecutionService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ReasoningEngineExecutionService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ReasoningEngineExecutionService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ReasoningEngineExecutionService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ReasoningEngineExecutionService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ReasoningEngineExecutionService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ReasoningEngineExecutionService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ReasoningEngineExecutionService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ReasoningEngineExecutionService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::ReasoningEngineService].
///
/// Application developers may need to implement this trait to mock
/// `client::ReasoningEngineService`.  In other use-cases, application developers only
/// use `client::ReasoningEngineService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "reasoning-engine-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "reasoning-engine-service")))]
pub trait ReasoningEngineService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ReasoningEngineService::create_reasoning_engine].
    fn create_reasoning_engine(
        &self,
        _req: crate::model::CreateReasoningEngineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ReasoningEngineService::get_reasoning_engine].
    fn get_reasoning_engine(
        &self,
        _req: crate::model::GetReasoningEngineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ReasoningEngine>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::ReasoningEngine>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ReasoningEngineService::list_reasoning_engines].
    fn list_reasoning_engines(
        &self,
        _req: crate::model::ListReasoningEnginesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListReasoningEnginesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListReasoningEnginesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ReasoningEngineService::update_reasoning_engine].
    fn update_reasoning_engine(
        &self,
        _req: crate::model::UpdateReasoningEngineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ReasoningEngineService::delete_reasoning_engine].
    fn delete_reasoning_engine(
        &self,
        _req: crate::model::DeleteReasoningEngineRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ReasoningEngineService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ReasoningEngineService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ReasoningEngineService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ReasoningEngineService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ReasoningEngineService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ReasoningEngineService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ReasoningEngineService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ReasoningEngineService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ReasoningEngineService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ReasoningEngineService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::ScheduleService].
///
/// Application developers may need to implement this trait to mock
/// `client::ScheduleService`.  In other use-cases, application developers only
/// use `client::ScheduleService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "schedule-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "schedule-service")))]
pub trait ScheduleService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::ScheduleService::create_schedule].
    fn create_schedule(
        &self,
        _req: crate::model::CreateScheduleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Schedule>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Schedule>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ScheduleService::delete_schedule].
    fn delete_schedule(
        &self,
        _req: crate::model::DeleteScheduleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ScheduleService::get_schedule].
    fn get_schedule(
        &self,
        _req: crate::model::GetScheduleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Schedule>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Schedule>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ScheduleService::list_schedules].
    fn list_schedules(
        &self,
        _req: crate::model::ListSchedulesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListSchedulesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListSchedulesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ScheduleService::pause_schedule].
    fn pause_schedule(
        &self,
        _req: crate::model::PauseScheduleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ScheduleService::resume_schedule].
    fn resume_schedule(
        &self,
        _req: crate::model::ResumeScheduleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ScheduleService::update_schedule].
    fn update_schedule(
        &self,
        _req: crate::model::UpdateScheduleRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Schedule>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Schedule>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ScheduleService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ScheduleService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ScheduleService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ScheduleService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::ScheduleService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ScheduleService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::ScheduleService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::ScheduleService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ScheduleService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::ScheduleService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::SpecialistPoolService].
///
/// Application developers may need to implement this trait to mock
/// `client::SpecialistPoolService`.  In other use-cases, application developers only
/// use `client::SpecialistPoolService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "specialist-pool-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "specialist-pool-service")))]
pub trait SpecialistPoolService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::SpecialistPoolService::create_specialist_pool].
    fn create_specialist_pool(
        &self,
        _req: crate::model::CreateSpecialistPoolRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::SpecialistPoolService::get_specialist_pool].
    fn get_specialist_pool(
        &self,
        _req: crate::model::GetSpecialistPoolRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::SpecialistPool>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::SpecialistPool>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::SpecialistPoolService::list_specialist_pools].
    fn list_specialist_pools(
        &self,
        _req: crate::model::ListSpecialistPoolsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListSpecialistPoolsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListSpecialistPoolsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::SpecialistPoolService::delete_specialist_pool].
    fn delete_specialist_pool(
        &self,
        _req: crate::model::DeleteSpecialistPoolRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::SpecialistPoolService::update_specialist_pool].
    fn update_specialist_pool(
        &self,
        _req: crate::model::UpdateSpecialistPoolRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::SpecialistPoolService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::SpecialistPoolService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::SpecialistPoolService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::SpecialistPoolService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::SpecialistPoolService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::SpecialistPoolService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::SpecialistPoolService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::SpecialistPoolService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::SpecialistPoolService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::SpecialistPoolService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::TensorboardService].
///
/// Application developers may need to implement this trait to mock
/// `client::TensorboardService`.  In other use-cases, application developers only
/// use `client::TensorboardService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "tensorboard-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "tensorboard-service")))]
pub trait TensorboardService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::TensorboardService::create_tensorboard].
    fn create_tensorboard(
        &self,
        _req: crate::model::CreateTensorboardRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::get_tensorboard].
    fn get_tensorboard(
        &self,
        _req: crate::model::GetTensorboardRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Tensorboard>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Tensorboard>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::update_tensorboard].
    fn update_tensorboard(
        &self,
        _req: crate::model::UpdateTensorboardRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::list_tensorboards].
    fn list_tensorboards(
        &self,
        _req: crate::model::ListTensorboardsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListTensorboardsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListTensorboardsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::delete_tensorboard].
    fn delete_tensorboard(
        &self,
        _req: crate::model::DeleteTensorboardRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::read_tensorboard_usage].
    fn read_tensorboard_usage(
        &self,
        _req: crate::model::ReadTensorboardUsageRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ReadTensorboardUsageResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ReadTensorboardUsageResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::read_tensorboard_size].
    fn read_tensorboard_size(
        &self,
        _req: crate::model::ReadTensorboardSizeRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ReadTensorboardSizeResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ReadTensorboardSizeResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::create_tensorboard_experiment].
    fn create_tensorboard_experiment(
        &self,
        _req: crate::model::CreateTensorboardExperimentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardExperiment>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::TensorboardExperiment>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::get_tensorboard_experiment].
    fn get_tensorboard_experiment(
        &self,
        _req: crate::model::GetTensorboardExperimentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardExperiment>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::TensorboardExperiment>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::update_tensorboard_experiment].
    fn update_tensorboard_experiment(
        &self,
        _req: crate::model::UpdateTensorboardExperimentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardExperiment>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::TensorboardExperiment>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::list_tensorboard_experiments].
    fn list_tensorboard_experiments(
        &self,
        _req: crate::model::ListTensorboardExperimentsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListTensorboardExperimentsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::ListTensorboardExperimentsResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::delete_tensorboard_experiment].
    fn delete_tensorboard_experiment(
        &self,
        _req: crate::model::DeleteTensorboardExperimentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::create_tensorboard_run].
    fn create_tensorboard_run(
        &self,
        _req: crate::model::CreateTensorboardRunRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardRun>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::TensorboardRun>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::batch_create_tensorboard_runs].
    fn batch_create_tensorboard_runs(
        &self,
        _req: crate::model::BatchCreateTensorboardRunsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::BatchCreateTensorboardRunsResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::BatchCreateTensorboardRunsResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::get_tensorboard_run].
    fn get_tensorboard_run(
        &self,
        _req: crate::model::GetTensorboardRunRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardRun>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::TensorboardRun>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::update_tensorboard_run].
    fn update_tensorboard_run(
        &self,
        _req: crate::model::UpdateTensorboardRunRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardRun>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::TensorboardRun>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::list_tensorboard_runs].
    fn list_tensorboard_runs(
        &self,
        _req: crate::model::ListTensorboardRunsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListTensorboardRunsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListTensorboardRunsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::delete_tensorboard_run].
    fn delete_tensorboard_run(
        &self,
        _req: crate::model::DeleteTensorboardRunRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::batch_create_tensorboard_time_series].
    fn batch_create_tensorboard_time_series(
        &self,
        _req: crate::model::BatchCreateTensorboardTimeSeriesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::BatchCreateTensorboardTimeSeriesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::BatchCreateTensorboardTimeSeriesResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::create_tensorboard_time_series].
    fn create_tensorboard_time_series(
        &self,
        _req: crate::model::CreateTensorboardTimeSeriesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardTimeSeries>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::TensorboardTimeSeries>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::get_tensorboard_time_series].
    fn get_tensorboard_time_series(
        &self,
        _req: crate::model::GetTensorboardTimeSeriesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardTimeSeries>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::TensorboardTimeSeries>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::update_tensorboard_time_series].
    fn update_tensorboard_time_series(
        &self,
        _req: crate::model::UpdateTensorboardTimeSeriesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::TensorboardTimeSeries>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::TensorboardTimeSeries>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::list_tensorboard_time_series].
    fn list_tensorboard_time_series(
        &self,
        _req: crate::model::ListTensorboardTimeSeriesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ListTensorboardTimeSeriesResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListTensorboardTimeSeriesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::delete_tensorboard_time_series].
    fn delete_tensorboard_time_series(
        &self,
        _req: crate::model::DeleteTensorboardTimeSeriesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::batch_read_tensorboard_time_series_data].
    fn batch_read_tensorboard_time_series_data(
        &self,
        _req: crate::model::BatchReadTensorboardTimeSeriesDataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::BatchReadTensorboardTimeSeriesDataResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::BatchReadTensorboardTimeSeriesDataResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::read_tensorboard_time_series_data].
    fn read_tensorboard_time_series_data(
        &self,
        _req: crate::model::ReadTensorboardTimeSeriesDataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ReadTensorboardTimeSeriesDataResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::ReadTensorboardTimeSeriesDataResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::write_tensorboard_experiment_data].
    fn write_tensorboard_experiment_data(
        &self,
        _req: crate::model::WriteTensorboardExperimentDataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::WriteTensorboardExperimentDataResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::WriteTensorboardExperimentDataResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::write_tensorboard_run_data].
    fn write_tensorboard_run_data(
        &self,
        _req: crate::model::WriteTensorboardRunDataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::WriteTensorboardRunDataResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::WriteTensorboardRunDataResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::export_tensorboard_time_series_data].
    fn export_tensorboard_time_series_data(
        &self,
        _req: crate::model::ExportTensorboardTimeSeriesDataRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<
            gax::response::Response<crate::model::ExportTensorboardTimeSeriesDataResponse>,
        >,
    > + Send {
        std::future::ready::<
            crate::Result<
                gax::response::Response<crate::model::ExportTensorboardTimeSeriesDataResponse>,
            >,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::TensorboardService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::TensorboardService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::TensorboardService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::TensorboardService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::TensorboardService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::TensorboardService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::VertexRagDataService].
///
/// Application developers may need to implement this trait to mock
/// `client::VertexRagDataService`.  In other use-cases, application developers only
/// use `client::VertexRagDataService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "vertex-rag-data-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "vertex-rag-data-service")))]
pub trait VertexRagDataService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::VertexRagDataService::create_rag_corpus].
    fn create_rag_corpus(
        &self,
        _req: crate::model::CreateRagCorpusRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagDataService::update_rag_corpus].
    fn update_rag_corpus(
        &self,
        _req: crate::model::UpdateRagCorpusRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagDataService::get_rag_corpus].
    fn get_rag_corpus(
        &self,
        _req: crate::model::GetRagCorpusRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RagCorpus>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::RagCorpus>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VertexRagDataService::list_rag_corpora].
    fn list_rag_corpora(
        &self,
        _req: crate::model::ListRagCorporaRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListRagCorporaResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListRagCorporaResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagDataService::delete_rag_corpus].
    fn delete_rag_corpus(
        &self,
        _req: crate::model::DeleteRagCorpusRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagDataService::upload_rag_file].
    fn upload_rag_file(
        &self,
        _req: crate::model::UploadRagFileRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::UploadRagFileResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::UploadRagFileResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagDataService::import_rag_files].
    fn import_rag_files(
        &self,
        _req: crate::model::ImportRagFilesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagDataService::get_rag_file].
    fn get_rag_file(
        &self,
        _req: crate::model::GetRagFileRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RagFile>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::RagFile>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VertexRagDataService::list_rag_files].
    fn list_rag_files(
        &self,
        _req: crate::model::ListRagFilesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListRagFilesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListRagFilesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagDataService::delete_rag_file].
    fn delete_rag_file(
        &self,
        _req: crate::model::DeleteRagFileRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagDataService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagDataService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagDataService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VertexRagDataService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VertexRagDataService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagDataService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagDataService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagDataService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::VertexRagDataService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::VertexRagDataService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}

/// Defines the trait used to implement [super::client::VertexRagService].
///
/// Application developers may need to implement this trait to mock
/// `client::VertexRagService`.  In other use-cases, application developers only
/// use `client::VertexRagService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "vertex-rag-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "vertex-rag-service")))]
pub trait VertexRagService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::VertexRagService::retrieve_contexts].
    fn retrieve_contexts(
        &self,
        _req: crate::model::RetrieveContextsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::RetrieveContextsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::RetrieveContextsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagService::augment_prompt].
    fn augment_prompt(
        &self,
        _req: crate::model::AugmentPromptRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::AugmentPromptResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::AugmentPromptResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagService::corroborate_content].
    fn corroborate_content(
        &self,
        _req: crate::model::CorroborateContentRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::CorroborateContentResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::CorroborateContentResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VertexRagService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VertexRagService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VertexRagService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VertexRagService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::VertexRagService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::VertexRagService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }
}

/// Defines the trait used to implement [super::client::VizierService].
///
/// Application developers may need to implement this trait to mock
/// `client::VizierService`.  In other use-cases, application developers only
/// use `client::VizierService` and need not be concerned with this trait or
/// its implementations.
///
/// Services gain new RPCs routinely. Consequently, this trait gains new methods
/// too. To avoid breaking applications the trait provides a default
/// implementation of each method. Most of these implementations just return an
/// error.
#[cfg(feature = "vizier-service")]
#[cfg_attr(docsrs, doc(cfg(feature = "vizier-service")))]
pub trait VizierService: std::fmt::Debug + Send + Sync {
    /// Implements [super::client::VizierService::create_study].
    fn create_study(
        &self,
        _req: crate::model::CreateStudyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Study>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Study>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::get_study].
    fn get_study(
        &self,
        _req: crate::model::GetStudyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Study>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Study>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::list_studies].
    fn list_studies(
        &self,
        _req: crate::model::ListStudiesRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListStudiesResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListStudiesResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VizierService::delete_study].
    fn delete_study(
        &self,
        _req: crate::model::DeleteStudyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::VizierService::lookup_study].
    fn lookup_study(
        &self,
        _req: crate::model::LookupStudyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Study>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Study>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::suggest_trials].
    fn suggest_trials(
        &self,
        _req: crate::model::SuggestTrialsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VizierService::create_trial].
    fn create_trial(
        &self,
        _req: crate::model::CreateTrialRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Trial>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Trial>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::get_trial].
    fn get_trial(
        &self,
        _req: crate::model::GetTrialRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Trial>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Trial>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::list_trials].
    fn list_trials(
        &self,
        _req: crate::model::ListTrialsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListTrialsResponse>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::ListTrialsResponse>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VizierService::add_trial_measurement].
    fn add_trial_measurement(
        &self,
        _req: crate::model::AddTrialMeasurementRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Trial>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Trial>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::complete_trial].
    fn complete_trial(
        &self,
        _req: crate::model::CompleteTrialRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Trial>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Trial>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::delete_trial].
    fn delete_trial(
        &self,
        _req: crate::model::DeleteTrialRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::VizierService::check_trial_early_stopping_state].
    fn check_trial_early_stopping_state(
        &self,
        _req: crate::model::CheckTrialEarlyStoppingStateRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VizierService::stop_trial].
    fn stop_trial(
        &self,
        _req: crate::model::StopTrialRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::Trial>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<crate::model::Trial>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::list_optimal_trials].
    fn list_optimal_trials(
        &self,
        _req: crate::model::ListOptimalTrialsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<crate::model::ListOptimalTrialsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<crate::model::ListOptimalTrialsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VizierService::list_locations].
    fn list_locations(
        &self,
        _req: location::model::ListLocationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<location::model::ListLocationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VizierService::get_location].
    fn get_location(
        &self,
        _req: location::model::GetLocationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<location::model::Location>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<location::model::Location>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VizierService::set_iam_policy].
    fn set_iam_policy(
        &self,
        _req: iam_v1::model::SetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::get_iam_policy].
    fn get_iam_policy(
        &self,
        _req: iam_v1::model::GetIamPolicyRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::Policy>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<iam_v1::model::Policy>>>(Err(
            Error::other("unimplemented"),
        ))
    }

    /// Implements [super::client::VizierService::test_iam_permissions].
    fn test_iam_permissions(
        &self,
        _req: iam_v1::model::TestIamPermissionsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<iam_v1::model::TestIamPermissionsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VizierService::list_operations].
    fn list_operations(
        &self,
        _req: longrunning::model::ListOperationsRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
    > + Send {
        std::future::ready::<
            crate::Result<gax::response::Response<longrunning::model::ListOperationsResponse>>,
        >(Err(Error::other("unimplemented")))
    }

    /// Implements [super::client::VizierService::get_operation].
    fn get_operation(
        &self,
        _req: longrunning::model::GetOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Implements [super::client::VizierService::delete_operation].
    fn delete_operation(
        &self,
        _req: longrunning::model::DeleteOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::VizierService::cancel_operation].
    fn cancel_operation(
        &self,
        _req: longrunning::model::CancelOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<Output = crate::Result<gax::response::Response<()>>> + Send {
        std::future::ready::<crate::Result<gax::response::Response<()>>>(Err(Error::other(
            "unimplemented",
        )))
    }

    /// Implements [super::client::VizierService::wait_operation].
    fn wait_operation(
        &self,
        _req: longrunning::model::WaitOperationRequest,
        _options: gax::options::RequestOptions,
    ) -> impl std::future::Future<
        Output = crate::Result<gax::response::Response<longrunning::model::Operation>>,
    > + Send {
        std::future::ready::<crate::Result<gax::response::Response<longrunning::model::Operation>>>(
            Err(Error::other("unimplemented")),
        )
    }

    /// Returns the polling error policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_error_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_error_policy::PollingErrorPolicy> {
        std::sync::Arc::new(gax::polling_error_policy::Aip194Strict)
    }

    /// Returns the polling backoff policy.
    ///
    /// When mocking, this method is typically irrelevant. Do not try to verify
    /// it is called by your mocks.
    fn get_polling_backoff_policy(
        &self,
        _options: &gax::options::RequestOptions,
    ) -> std::sync::Arc<dyn gax::polling_backoff_policy::PollingBackoffPolicy> {
        std::sync::Arc::new(gax::exponential_backoff::ExponentialBackoff::default())
    }
}