google-chat-v1 1.1.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.
use crate::Result;

/// Implements a [ChatService](super::stub::ChatService) decorator for logging and tracing.
#[derive(Clone, Debug)]
pub struct ChatService<T>
where
    T: super::stub::ChatService + std::fmt::Debug + Send + Sync,
{
    inner: T,
    duration: gaxi::observability::DurationMetric,
}

impl<T> ChatService<T>
where
    T: super::stub::ChatService + std::fmt::Debug + Send + Sync,
{
    pub fn new(inner: T) -> Self {
        Self {
            inner,
            duration: gaxi::observability::DurationMetric::new(&info::INSTRUMENTATION_CLIENT_INFO),
        }
    }
}

impl<T> super::stub::ChatService for ChatService<T>
where
    T: super::stub::ChatService + std::fmt::Debug + Send + Sync,
{
    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_message(
        &self,
        req: crate::model::CreateMessageRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Message>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::create_message",
            self.inner.create_message(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_messages(
        &self,
        req: crate::model::ListMessagesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListMessagesResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::list_messages",
            self.inner.list_messages(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_memberships(
        &self,
        req: crate::model::ListMembershipsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListMembershipsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::list_memberships",
            self.inner.list_memberships(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_membership(
        &self,
        req: crate::model::GetMembershipRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Membership>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_membership",
            self.inner.get_membership(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_message(
        &self,
        req: crate::model::GetMessageRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Message>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_message",
            self.inner.get_message(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_message(
        &self,
        req: crate::model::UpdateMessageRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Message>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::update_message",
            self.inner.update_message(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_message(
        &self,
        req: crate::model::DeleteMessageRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::delete_message",
            self.inner.delete_message(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_attachment(
        &self,
        req: crate::model::GetAttachmentRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Attachment>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_attachment",
            self.inner.get_attachment(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn upload_attachment(
        &self,
        req: crate::model::UploadAttachmentRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::UploadAttachmentResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::upload_attachment",
            self.inner.upload_attachment(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_spaces(
        &self,
        req: crate::model::ListSpacesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListSpacesResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::list_spaces",
            self.inner.list_spaces(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn search_spaces(
        &self,
        req: crate::model::SearchSpacesRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SearchSpacesResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::search_spaces",
            self.inner.search_spaces(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_space(
        &self,
        req: crate::model::GetSpaceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Space>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_space",
            self.inner.get_space(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_space(
        &self,
        req: crate::model::CreateSpaceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Space>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::create_space",
            self.inner.create_space(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn set_up_space(
        &self,
        req: crate::model::SetUpSpaceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Space>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::set_up_space",
            self.inner.set_up_space(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_space(
        &self,
        req: crate::model::UpdateSpaceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Space>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::update_space",
            self.inner.update_space(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_space(
        &self,
        req: crate::model::DeleteSpaceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::delete_space",
            self.inner.delete_space(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn complete_import_space(
        &self,
        req: crate::model::CompleteImportSpaceRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::CompleteImportSpaceResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::complete_import_space",
            self.inner.complete_import_space(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn find_direct_message(
        &self,
        req: crate::model::FindDirectMessageRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Space>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::find_direct_message",
            self.inner.find_direct_message(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn find_group_chats(
        &self,
        req: crate::model::FindGroupChatsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::FindGroupChatsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::find_group_chats",
            self.inner.find_group_chats(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_membership(
        &self,
        req: crate::model::CreateMembershipRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Membership>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::create_membership",
            self.inner.create_membership(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_membership(
        &self,
        req: crate::model::UpdateMembershipRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Membership>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::update_membership",
            self.inner.update_membership(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_membership(
        &self,
        req: crate::model::DeleteMembershipRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Membership>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::delete_membership",
            self.inner.delete_membership(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_reaction(
        &self,
        req: crate::model::CreateReactionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Reaction>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::create_reaction",
            self.inner.create_reaction(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_reactions(
        &self,
        req: crate::model::ListReactionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListReactionsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::list_reactions",
            self.inner.list_reactions(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_reaction(
        &self,
        req: crate::model::DeleteReactionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::delete_reaction",
            self.inner.delete_reaction(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_custom_emoji(
        &self,
        req: crate::model::CreateCustomEmojiRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::CustomEmoji>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::create_custom_emoji",
            self.inner.create_custom_emoji(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_custom_emoji(
        &self,
        req: crate::model::GetCustomEmojiRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::CustomEmoji>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_custom_emoji",
            self.inner.get_custom_emoji(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_custom_emojis(
        &self,
        req: crate::model::ListCustomEmojisRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListCustomEmojisResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::list_custom_emojis",
            self.inner.list_custom_emojis(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_custom_emoji(
        &self,
        req: crate::model::DeleteCustomEmojiRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::delete_custom_emoji",
            self.inner.delete_custom_emoji(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_space_read_state(
        &self,
        req: crate::model::GetSpaceReadStateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SpaceReadState>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_space_read_state",
            self.inner.get_space_read_state(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_space_read_state(
        &self,
        req: crate::model::UpdateSpaceReadStateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SpaceReadState>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::update_space_read_state",
            self.inner.update_space_read_state(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_thread_read_state(
        &self,
        req: crate::model::GetThreadReadStateRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ThreadReadState>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_thread_read_state",
            self.inner.get_thread_read_state(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_availability(
        &self,
        req: crate::model::GetAvailabilityRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Availability>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_availability",
            self.inner.get_availability(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn mark_as_active(
        &self,
        req: crate::model::MarkAsActiveRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Availability>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::mark_as_active",
            self.inner.mark_as_active(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn mark_as_away(
        &self,
        req: crate::model::MarkAsAwayRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Availability>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::mark_as_away",
            self.inner.mark_as_away(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn mark_as_do_not_disturb(
        &self,
        req: crate::model::MarkAsDoNotDisturbRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Availability>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::mark_as_do_not_disturb",
            self.inner.mark_as_do_not_disturb(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_availability(
        &self,
        req: crate::model::UpdateAvailabilityRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Availability>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::update_availability",
            self.inner.update_availability(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_space_event(
        &self,
        req: crate::model::GetSpaceEventRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SpaceEvent>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_space_event",
            self.inner.get_space_event(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_space_events(
        &self,
        req: crate::model::ListSpaceEventsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListSpaceEventsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::list_space_events",
            self.inner.list_space_events(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn get_space_notification_setting(
        &self,
        req: crate::model::GetSpaceNotificationSettingRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SpaceNotificationSetting>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::get_space_notification_setting",
            self.inner.get_space_notification_setting(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_space_notification_setting(
        &self,
        req: crate::model::UpdateSpaceNotificationSettingRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::SpaceNotificationSetting>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::update_space_notification_setting",
            self.inner.update_space_notification_setting(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn create_section(
        &self,
        req: crate::model::CreateSectionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Section>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::create_section",
            self.inner.create_section(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn delete_section(
        &self,
        req: crate::model::DeleteSectionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<()>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::delete_section",
            self.inner.delete_section(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn update_section(
        &self,
        req: crate::model::UpdateSectionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::Section>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::update_section",
            self.inner.update_section(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_sections(
        &self,
        req: crate::model::ListSectionsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListSectionsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::list_sections",
            self.inner.list_sections(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn position_section(
        &self,
        req: crate::model::PositionSectionRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::PositionSectionResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::position_section",
            self.inner.position_section(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn list_section_items(
        &self,
        req: crate::model::ListSectionItemsRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::ListSectionItemsResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::list_section_items",
            self.inner.list_section_items(req, options));
        pending.await
    }

    #[tracing::instrument(level = tracing::Level::DEBUG, ret)]
    async fn move_section_item(
        &self,
        req: crate::model::MoveSectionItemRequest,
        options: crate::RequestOptions,
    ) -> Result<crate::Response<crate::model::MoveSectionItemResponse>> {
        let (_span, pending) = gaxi::client_request_signals!(
            metric: self.duration.clone(),
            info: *info::INSTRUMENTATION_CLIENT_INFO,
            method: "client::ChatService::move_section_item",
            self.inner.move_section_item(req, options));
        pending.await
    }
}

pub(crate) mod info {
    const NAME: &str = env!("CARGO_PKG_NAME");
    const VERSION: &str = env!("CARGO_PKG_VERSION");
    pub(crate) static INSTRUMENTATION_CLIENT_INFO: std::sync::LazyLock<
        gaxi::options::InstrumentationClientInfo,
    > = std::sync::LazyLock::new(|| {
        let mut info = gaxi::options::InstrumentationClientInfo::default();
        info.service_name = "chat";
        info.client_version = VERSION;
        info.client_artifact = NAME;
        info.default_host = "chat";
        info
    });
}