// This file is @generated by prost-build.
/// Request message for the GetNotificationSubscription method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetNotificationSubscriptionRequest {
    /// Required. The `name` of the notification subscription.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for the CreateNotificationSubscription method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateNotificationSubscriptionRequest {
    /// Required. The merchant account that owns the new notification subscription.
    /// Format: `accounts/{account}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The notification subscription to create.
    #[prost(message, optional, tag = "2")]
    pub notification_subscription: ::core::option::Option<NotificationSubscription>,
}
/// Request message for the UpdateNotificationSubscription method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateNotificationSubscriptionRequest {
    /// Required. The new version of the notification subscription that should be
    /// updated.
    #[prost(message, optional, tag = "1")]
    pub notification_subscription: ::core::option::Option<NotificationSubscription>,
    /// List of fields being updated.
    #[prost(message, optional, tag = "2")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
}
/// Request message for the DeleteNotificationSubscription method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteNotificationSubscriptionRequest {
    /// Required. The name of the notification subscription to be deleted.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request message for the ListNotificationSubscription method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListNotificationSubscriptionsRequest {
    /// Required. The merchant account who owns the notification subscriptions.
    /// Format: `accounts/{account}`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// The maximum number of notification subscriptions to return in a page.
    /// The default value for `page_size` is 100. The
    /// maximum value is `200`. Values above `200` will be coerced to `200`.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Token (if provided) to retrieve the subsequent page. All other parameters
    /// must match the original call that provided the page token.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
}
/// Response message for the ListNotificationSubscription method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListNotificationSubscriptionsResponse {
    /// The list of notification subscriptions requested by the merchant.
    #[prost(message, repeated, tag = "1")]
    pub notification_subscriptions: ::prost::alloc::vec::Vec<NotificationSubscription>,
    /// A token, which can be sent as `page_token` to retrieve the next page.
    /// If this field is omitted, there are no subsequent pages.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
}
/// Represents a notification subscription owned by a Merchant account.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NotificationSubscription {
    /// Output only. The `name` of the notification configuration. Generated by the
    /// Content API upon creation of a new `NotificationSubscription`. The
    /// `account` represents the merchant ID of the merchant that owns the
    /// configuration. Format:
    /// `accounts/{account}/notificationsubscriptions/{notification_subscription}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The event that the merchant wants to be notified about.
    #[prost(enumeration = "notification_subscription::NotificationEventType", tag = "2")]
    pub registered_event: i32,
    /// URL to be used to push the notification to the merchant.
    #[prost(string, tag = "5")]
    pub call_back_uri: ::prost::alloc::string::String,
    #[prost(oneof = "notification_subscription::InterestedIn", tags = "3, 4")]
    pub interested_in: ::core::option::Option<notification_subscription::InterestedIn>,
}
/// Nested message and enum types in `NotificationSubscription`.
pub mod notification_subscription {
    /// Represents the event type that the merchant is interested in receiving
    /// notifications for.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum NotificationEventType {
        /// Notifications event type is unspecified.
        Unspecified = 0,
        /// Notification of product status changes, for example when product becomes
        /// disapproved.
        ProductStatusChange = 1,
    }
    impl NotificationEventType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "NOTIFICATION_EVENT_TYPE_UNSPECIFIED",
                Self::ProductStatusChange => "PRODUCT_STATUS_CHANGE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NOTIFICATION_EVENT_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "PRODUCT_STATUS_CHANGE" => Some(Self::ProductStatusChange),
                _ => None,
            }
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum InterestedIn {
        /// If this value is true, the requesting account is notified of the
        /// specified event for all managed accounts (can be subaccounts or other
        /// linked accounts) including newly added accounts on a daily basis.
        #[prost(bool, tag = "3")]
        AllManagedAccounts(bool),
        /// The `name` of the account you want to receive notifications for.
        /// Format: `accounts/{account}`
        #[prost(string, tag = "4")]
        TargetAccount(::prost::alloc::string::String),
    }
}
/// The change that happened to the product including old value, new value,
/// country code as the region code and reporting context.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProductChange {
    /// The old value of the changed resource or attribute.
    #[prost(string, optional, tag = "1")]
    pub old_value: ::core::option::Option<::prost::alloc::string::String>,
    /// The new value of the changed resource or attribute.
    #[prost(string, optional, tag = "2")]
    pub new_value: ::core::option::Option<::prost::alloc::string::String>,
    /// Countries that have the change (if applicable)
    #[prost(string, optional, tag = "3")]
    pub region_code: ::core::option::Option<::prost::alloc::string::String>,
    /// Reporting contexts that have the change (if applicable)
    #[prost(
        enumeration = "super::super::super::r#type::reporting_context::ReportingContextEnum",
        optional,
        tag = "4"
    )]
    pub reporting_context: ::core::option::Option<i32>,
}
/// The message that the merchant will receive to notify about product status
/// change event
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProductStatusChangeMessage {
    /// The target account that owns the entity that changed.
    /// Format : `accounts/{merchant_id}`
    #[prost(string, optional, tag = "1")]
    pub account: ::core::option::Option<::prost::alloc::string::String>,
    /// The account that manages the merchant's account. can be the same as
    /// merchant id if it is standalone account. Format :
    /// `accounts/{service_provider_id}`
    #[prost(string, optional, tag = "2")]
    pub managing_account: ::core::option::Option<::prost::alloc::string::String>,
    /// The resource that changed, in this case it will always be `Product`.
    #[prost(enumeration = "Resource", optional, tag = "3")]
    pub resource_type: ::core::option::Option<i32>,
    /// The attribute in the resource that changed, in this case it will be always
    /// `Status`.
    #[prost(enumeration = "Attribute", optional, tag = "4")]
    pub attribute: ::core::option::Option<i32>,
    /// A message to describe the change that happened to the product
    #[prost(message, repeated, tag = "5")]
    pub changes: ::prost::alloc::vec::Vec<ProductChange>,
    /// The product id.
    #[prost(string, optional, tag = "6")]
    pub resource_id: ::core::option::Option<::prost::alloc::string::String>,
    /// The product name.
    /// Format: `{product.name=accounts/{account}/products/{product}}`
    #[prost(string, optional, tag = "7")]
    pub resource: ::core::option::Option<::prost::alloc::string::String>,
}
/// Enum to specify the resource that is being changed to notify the merchant
/// about.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Resource {
    /// Unspecified resource
    Unspecified = 0,
    /// Resource type : product
    Product = 1,
}
impl Resource {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "RESOURCE_UNSPECIFIED",
            Self::Product => "PRODUCT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "RESOURCE_UNSPECIFIED" => Some(Self::Unspecified),
            "PRODUCT" => Some(Self::Product),
            _ => None,
        }
    }
}
/// Enum to specify the attribute in the resource that is being changed to
/// notify the merchant about.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Attribute {
    /// Unspecified attribute
    Unspecified = 0,
    /// Status of the changed entity
    Status = 1,
}
impl Attribute {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "ATTRIBUTE_UNSPECIFIED",
            Self::Status => "STATUS",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ATTRIBUTE_UNSPECIFIED" => Some(Self::Unspecified),
            "STATUS" => Some(Self::Status),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod notifications_api_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service to manage notification subscriptions for merchants
    #[derive(Debug, Clone)]
    pub struct NotificationsApiServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl NotificationsApiServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> NotificationsApiServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> NotificationsApiServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            NotificationsApiServiceClient::new(
                InterceptedService::new(inner, interceptor),
            )
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Gets notification subscriptions for an account.
        pub async fn get_notification_subscription(
            &mut self,
            request: impl tonic::IntoRequest<super::GetNotificationSubscriptionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::NotificationSubscription>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.shopping.merchant.notifications.v1beta.NotificationsApiService/GetNotificationSubscription",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.shopping.merchant.notifications.v1beta.NotificationsApiService",
                        "GetNotificationSubscription",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a notification subscription for a merchant. We will allow the
        /// following types of notification subscriptions to exist together (per
        /// merchant as a subscriber per event type):
        ///
        /// 1. Subscription for all managed accounts + subscription for self
        /// 1. Multiple "partial" subscriptions for managed accounts + subscription
        ///   for self
        ///
        /// we will not allow (per merchant as a subscriber per event type):
        ///
        /// 1. multiple self subscriptions.
        /// 1. multiple "all managed accounts" subscriptions.
        /// 1. all and partial subscriptions at the same time.
        /// 1. multiple partial subscriptions for the same target account
        pub async fn create_notification_subscription(
            &mut self,
            request: impl tonic::IntoRequest<
                super::CreateNotificationSubscriptionRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::NotificationSubscription>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.shopping.merchant.notifications.v1beta.NotificationsApiService/CreateNotificationSubscription",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.shopping.merchant.notifications.v1beta.NotificationsApiService",
                        "CreateNotificationSubscription",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing notification subscription for a merchant.
        pub async fn update_notification_subscription(
            &mut self,
            request: impl tonic::IntoRequest<
                super::UpdateNotificationSubscriptionRequest,
            >,
        ) -> std::result::Result<
            tonic::Response<super::NotificationSubscription>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.shopping.merchant.notifications.v1beta.NotificationsApiService/UpdateNotificationSubscription",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.shopping.merchant.notifications.v1beta.NotificationsApiService",
                        "UpdateNotificationSubscription",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a notification subscription for a merchant.
        pub async fn delete_notification_subscription(
            &mut self,
            request: impl tonic::IntoRequest<
                super::DeleteNotificationSubscriptionRequest,
            >,
        ) -> std::result::Result<tonic::Response<()>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.shopping.merchant.notifications.v1beta.NotificationsApiService/DeleteNotificationSubscription",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.shopping.merchant.notifications.v1beta.NotificationsApiService",
                        "DeleteNotificationSubscription",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets all the notification subscriptions for a merchant.
        pub async fn list_notification_subscriptions(
            &mut self,
            request: impl tonic::IntoRequest<super::ListNotificationSubscriptionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListNotificationSubscriptionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.shopping.merchant.notifications.v1beta.NotificationsApiService/ListNotificationSubscriptions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.shopping.merchant.notifications.v1beta.NotificationsApiService",
                        "ListNotificationSubscriptions",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
