google-cloud-dns-v1 2.0.0

// Copyright 2026 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.

/// A dyn-compatible, crate-private version of [super::Changes].
#[async_trait::async_trait]
pub trait Changes: std::fmt::Debug + Send + Sync {
    async fn create(
        &self,
        req: crate::model::changes::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Change>>;

    async fn get(
        &self,
        req: crate::model::changes::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Change>>;

    async fn list(
        &self,
        req: crate::model::changes::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ChangesListResponse>>;
}

/// All implementations of [super::Changes] also implement [Changes].
#[async_trait::async_trait]
impl<T: super::Changes> Changes for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn create(
        &self,
        req: crate::model::changes::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Change>> {
        T::create(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::changes::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Change>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::changes::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ChangesListResponse>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::DnsKeys].
#[async_trait::async_trait]
pub trait DnsKeys: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::dns_keys::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::DnsKey>>;

    async fn list(
        &self,
        req: crate::model::dns_keys::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::DnsKeysListResponse>>;
}

/// All implementations of [super::DnsKeys] also implement [DnsKeys].
#[async_trait::async_trait]
impl<T: super::DnsKeys> DnsKeys for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::dns_keys::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::DnsKey>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::dns_keys::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::DnsKeysListResponse>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::ManagedZoneOperations].
#[async_trait::async_trait]
pub trait ManagedZoneOperations: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::managed_zone_operations::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::managed_zone_operations::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ManagedZoneOperationsListResponse>>;
}

/// All implementations of [super::ManagedZoneOperations] also implement [ManagedZoneOperations].
#[async_trait::async_trait]
impl<T: super::ManagedZoneOperations> ManagedZoneOperations for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::managed_zone_operations::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::managed_zone_operations::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ManagedZoneOperationsListResponse>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::ManagedZones].
#[async_trait::async_trait]
pub trait ManagedZones: std::fmt::Debug + Send + Sync {
    async fn create(
        &self,
        req: crate::model::managed_zones::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ManagedZone>>;

    async fn delete(
        &self,
        req: crate::model::managed_zones::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>>;

    async fn get(
        &self,
        req: crate::model::managed_zones::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ManagedZone>>;

    async fn get_iam_policy(
        &self,
        req: crate::model::managed_zones::GetIamPolicyRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::GoogleIamV1Policy>>;

    async fn list(
        &self,
        req: crate::model::managed_zones::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ManagedZonesListResponse>>;

    async fn patch(
        &self,
        req: crate::model::managed_zones::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn set_iam_policy(
        &self,
        req: crate::model::managed_zones::SetIamPolicyRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::GoogleIamV1Policy>>;

    async fn test_iam_permissions(
        &self,
        req: crate::model::managed_zones::TestIamPermissionsRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::GoogleIamV1TestIamPermissionsResponse>>;

    async fn update(
        &self,
        req: crate::model::managed_zones::UpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get_operation(
        &self,
        req: crate::model::managed_zone_operations::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    fn get_polling_error_policy(
        &self,
        options: &crate::RequestOptions,
    ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy>;

    fn get_polling_backoff_policy(
        &self,
        options: &crate::RequestOptions,
    ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy>;

    fn get_poller_options(
        &self,
        options: &crate::RequestOptions,
    ) -> google_cloud_lro::PollerOptions;
}

/// All implementations of [super::ManagedZones] also implement [ManagedZones].
#[async_trait::async_trait]
impl<T: super::ManagedZones> ManagedZones for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn create(
        &self,
        req: crate::model::managed_zones::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ManagedZone>> {
        T::create(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::managed_zones::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::managed_zones::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ManagedZone>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_iam_policy(
        &self,
        req: crate::model::managed_zones::GetIamPolicyRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::GoogleIamV1Policy>> {
        T::get_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::managed_zones::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ManagedZonesListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::managed_zones::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn set_iam_policy(
        &self,
        req: crate::model::managed_zones::SetIamPolicyRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::GoogleIamV1Policy>> {
        T::set_iam_policy(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn test_iam_permissions(
        &self,
        req: crate::model::managed_zones::TestIamPermissionsRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::GoogleIamV1TestIamPermissionsResponse>> {
        T::test_iam_permissions(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::managed_zones::UpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_operation(
        &self,
        req: crate::model::managed_zone_operations::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::get_operation(self, req, options).await
    }

    fn get_polling_error_policy(
        &self,
        options: &crate::RequestOptions,
    ) -> std::sync::Arc<dyn google_cloud_gax::polling_error_policy::PollingErrorPolicy> {
        T::get_polling_error_policy(self, options)
    }

    fn get_polling_backoff_policy(
        &self,
        options: &crate::RequestOptions,
    ) -> std::sync::Arc<dyn google_cloud_gax::polling_backoff_policy::PollingBackoffPolicy> {
        T::get_polling_backoff_policy(self, options)
    }

    fn get_poller_options(
        &self,
        options: &crate::RequestOptions,
    ) -> google_cloud_lro::PollerOptions {
        T::get_poller_options(self, options)
    }
}

/// A dyn-compatible, crate-private version of [super::Policies].
#[async_trait::async_trait]
pub trait Policies: std::fmt::Debug + Send + Sync {
    async fn create(
        &self,
        req: crate::model::policies::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Policy>>;

    async fn delete(
        &self,
        req: crate::model::policies::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>>;

    async fn get(
        &self,
        req: crate::model::policies::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Policy>>;

    async fn list(
        &self,
        req: crate::model::policies::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::PoliciesListResponse>>;

    async fn patch(
        &self,
        req: crate::model::policies::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::PoliciesPatchResponse>>;

    async fn update(
        &self,
        req: crate::model::policies::UpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::PoliciesUpdateResponse>>;
}

/// All implementations of [super::Policies] also implement [Policies].
#[async_trait::async_trait]
impl<T: super::Policies> Policies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn create(
        &self,
        req: crate::model::policies::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Policy>> {
        T::create(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::policies::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::policies::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Policy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::policies::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::PoliciesListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::policies::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::PoliciesPatchResponse>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::policies::UpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::PoliciesUpdateResponse>> {
        T::update(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::Projects].
#[async_trait::async_trait]
pub trait Projects: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::projects::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Project>>;
}

/// All implementations of [super::Projects] also implement [Projects].
#[async_trait::async_trait]
impl<T: super::Projects> Projects for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::projects::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Project>> {
        T::get(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::ResourceRecordSets].
#[async_trait::async_trait]
pub trait ResourceRecordSets: std::fmt::Debug + Send + Sync {
    async fn create(
        &self,
        req: crate::model::resource_record_sets::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSet>>;

    async fn delete(
        &self,
        req: crate::model::resource_record_sets::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSetsDeleteResponse>>;

    async fn get(
        &self,
        req: crate::model::resource_record_sets::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSet>>;

    async fn list(
        &self,
        req: crate::model::resource_record_sets::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSetsListResponse>>;

    async fn patch(
        &self,
        req: crate::model::resource_record_sets::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSet>>;
}

/// All implementations of [super::ResourceRecordSets] also implement [ResourceRecordSets].
#[async_trait::async_trait]
impl<T: super::ResourceRecordSets> ResourceRecordSets for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn create(
        &self,
        req: crate::model::resource_record_sets::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSet>> {
        T::create(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::resource_record_sets::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSetsDeleteResponse>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::resource_record_sets::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSet>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::resource_record_sets::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSetsListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::resource_record_sets::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResourceRecordSet>> {
        T::patch(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::ResponsePolicies].
#[async_trait::async_trait]
pub trait ResponsePolicies: std::fmt::Debug + Send + Sync {
    async fn create(
        &self,
        req: crate::model::response_policies::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicy>>;

    async fn delete(
        &self,
        req: crate::model::response_policies::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>>;

    async fn get(
        &self,
        req: crate::model::response_policies::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicy>>;

    async fn list(
        &self,
        req: crate::model::response_policies::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePoliciesListResponse>>;

    async fn patch(
        &self,
        req: crate::model::response_policies::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePoliciesPatchResponse>>;

    async fn update(
        &self,
        req: crate::model::response_policies::UpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePoliciesUpdateResponse>>;
}

/// All implementations of [super::ResponsePolicies] also implement [ResponsePolicies].
#[async_trait::async_trait]
impl<T: super::ResponsePolicies> ResponsePolicies for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn create(
        &self,
        req: crate::model::response_policies::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicy>> {
        T::create(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::response_policies::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::response_policies::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicy>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::response_policies::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePoliciesListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::response_policies::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePoliciesPatchResponse>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::response_policies::UpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePoliciesUpdateResponse>> {
        T::update(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::ResponsePolicyRules].
#[async_trait::async_trait]
pub trait ResponsePolicyRules: std::fmt::Debug + Send + Sync {
    async fn create(
        &self,
        req: crate::model::response_policy_rules::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRule>>;

    async fn delete(
        &self,
        req: crate::model::response_policy_rules::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>>;

    async fn get(
        &self,
        req: crate::model::response_policy_rules::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRule>>;

    async fn list(
        &self,
        req: crate::model::response_policy_rules::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRulesListResponse>>;

    async fn patch(
        &self,
        req: crate::model::response_policy_rules::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRulesPatchResponse>>;

    async fn update(
        &self,
        req: crate::model::response_policy_rules::UpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRulesUpdateResponse>>;
}

/// All implementations of [super::ResponsePolicyRules] also implement [ResponsePolicyRules].
#[async_trait::async_trait]
impl<T: super::ResponsePolicyRules> ResponsePolicyRules for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn create(
        &self,
        req: crate::model::response_policy_rules::CreateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRule>> {
        T::create(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::response_policy_rules::DeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::response_policy_rules::GetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRule>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::response_policy_rules::ListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRulesListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::response_policy_rules::PatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRulesPatchResponse>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::response_policy_rules::UpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ResponsePolicyRulesUpdateResponse>> {
        T::update(self, req, options).await
    }
}