gcloud-sdk 0.19.15

/// The information required to auto-retrieve an SMS.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoRetrievalInfo {
    /// The Android app's signature hash for Google Play Service's
    /// SMS Retriever API.
    #[prost(string, tag = "1")]
    pub app_signature_hash: ::prost::alloc::string::String,
}
/// App Verification info for a StartMfa request.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartMfaPhoneRequestInfo {
    /// Required for enrollment. Phone number to be enrolled as MFA.
    #[prost(string, tag = "1")]
    pub phone_number: ::prost::alloc::string::String,
    /// iOS only. Receipt of successful app token validation with APNS.
    #[prost(string, tag = "2")]
    pub ios_receipt: ::prost::alloc::string::String,
    /// iOS only. Secret delivered to iOS app via APNS.
    #[prost(string, tag = "3")]
    pub ios_secret: ::prost::alloc::string::String,
    /// Web only. Recaptcha solution.
    #[prost(string, tag = "4")]
    pub recaptcha_token: ::prost::alloc::string::String,
    /// Android only. Used by Google Play Services to identify the app for
    /// auto-retrieval.
    #[prost(message, optional, tag = "5")]
    pub auto_retrieval_info: ::core::option::Option<AutoRetrievalInfo>,
    /// Android only. Used to assert application identity in place of a
    /// recaptcha token. A SafetyNet Token can be generated via the
    /// [SafetyNet Android Attestation
    /// API](<https://developer.android.com/training/safetynet/attestation.html>),
    /// with the Base64 encoding of the `phone_number` field as the nonce.
    #[prost(string, tag = "6")]
    pub safety_net_token: ::prost::alloc::string::String,
}
/// Phone Verification info for a StartMfa response.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartMfaPhoneResponseInfo {
    /// An opaque string that represents the enrollment session.
    #[prost(string, tag = "1")]
    pub session_info: ::prost::alloc::string::String,
}
/// Phone Verification info for a FinalizeMfa request.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FinalizeMfaPhoneRequestInfo {
    /// An opaque string that represents the enrollment session.
    #[prost(string, tag = "1")]
    pub session_info: ::prost::alloc::string::String,
    /// User-entered verification code.
    #[prost(string, tag = "2")]
    pub code: ::prost::alloc::string::String,
    /// Android only. Uses for "instant" phone number verification though GmsCore.
    #[prost(string, tag = "3")]
    pub android_verification_proof: ::prost::alloc::string::String,
    /// Required if Android verification proof is presented.
    #[prost(string, tag = "4")]
    pub phone_number: ::prost::alloc::string::String,
}
/// Phone Verification info for a FinalizeMfa response.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FinalizeMfaPhoneResponseInfo {
    /// Android only. Long-lived replacement for valid code tied to android device.
    #[prost(string, tag = "1")]
    pub android_verification_proof: ::prost::alloc::string::String,
    /// Android only. Expiration time of verification proof in seconds.
    #[prost(message, optional, tag = "2")]
    pub android_verification_proof_expire_time: ::core::option::Option<
        ::prost_types::Timestamp,
    >,
    /// For Android verification proof.
    #[prost(string, tag = "3")]
    pub phone_number: ::prost::alloc::string::String,
}
/// Finishes enrolling a second factor for the user.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FinalizeMfaEnrollmentRequest {
    /// Required. ID token.
    #[prost(string, tag = "1")]
    pub id_token: ::prost::alloc::string::String,
    /// Display name which is entered  by users to distinguish between different
    /// second factors with same type or different type.
    #[prost(string, tag = "3")]
    pub display_name: ::prost::alloc::string::String,
    /// The ID of the Identity Platform tenant that the user enrolling MFA belongs
    /// to. If not set, the user belongs to the default Identity Platform project.
    #[prost(string, tag = "5")]
    pub tenant_id: ::prost::alloc::string::String,
    /// MFA enrollment information to be verified.
    #[prost(oneof = "finalize_mfa_enrollment_request::VerificationInfo", tags = "4")]
    pub verification_info: ::core::option::Option<
        finalize_mfa_enrollment_request::VerificationInfo,
    >,
}
/// Nested message and enum types in `FinalizeMfaEnrollmentRequest`.
pub mod finalize_mfa_enrollment_request {
    /// MFA enrollment information to be verified.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum VerificationInfo {
        /// Verification info to authorize sending an SMS for phone verification.
        #[prost(message, tag = "4")]
        PhoneVerificationInfo(super::FinalizeMfaPhoneRequestInfo),
    }
}
/// FinalizeMfaEnrollment response.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FinalizeMfaEnrollmentResponse {
    /// ID token updated to reflect MFA enrollment.
    #[prost(string, tag = "1")]
    pub id_token: ::prost::alloc::string::String,
    /// Refresh token updated to reflect MFA enrollment.
    #[prost(string, tag = "2")]
    pub refresh_token: ::prost::alloc::string::String,
    /// MFA verified enrollment information.
    #[prost(oneof = "finalize_mfa_enrollment_response::AuxiliaryAuthInfo", tags = "3")]
    pub auxiliary_auth_info: ::core::option::Option<
        finalize_mfa_enrollment_response::AuxiliaryAuthInfo,
    >,
}
/// Nested message and enum types in `FinalizeMfaEnrollmentResponse`.
pub mod finalize_mfa_enrollment_response {
    /// MFA verified enrollment information.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AuxiliaryAuthInfo {
        /// Auxiliary auth info specific to phone auth.
        #[prost(message, tag = "3")]
        PhoneAuthInfo(super::FinalizeMfaPhoneResponseInfo),
    }
}
/// Sends MFA enrollment verification SMS for a user.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartMfaEnrollmentRequest {
    /// Required. User's ID token.
    #[prost(string, tag = "1")]
    pub id_token: ::prost::alloc::string::String,
    /// The ID of the Identity Platform tenant that the user enrolling MFA belongs
    /// to. If not set, the user belongs to the default Identity Platform project.
    #[prost(string, tag = "4")]
    pub tenant_id: ::prost::alloc::string::String,
    /// MFA information by type of 2nd factor.
    #[prost(oneof = "start_mfa_enrollment_request::EnrollmentInfo", tags = "3")]
    pub enrollment_info: ::core::option::Option<
        start_mfa_enrollment_request::EnrollmentInfo,
    >,
}
/// Nested message and enum types in `StartMfaEnrollmentRequest`.
pub mod start_mfa_enrollment_request {
    /// MFA information by type of 2nd factor.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum EnrollmentInfo {
        /// Verification info to authorize sending an SMS for phone verification.
        #[prost(message, tag = "3")]
        PhoneEnrollmentInfo(super::StartMfaPhoneRequestInfo),
    }
}
/// StartMfaEnrollment response.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartMfaEnrollmentResponse {
    /// MFA start enrollment response by 2nd factor type.
    #[prost(oneof = "start_mfa_enrollment_response::EnrollmentResponse", tags = "1")]
    pub enrollment_response: ::core::option::Option<
        start_mfa_enrollment_response::EnrollmentResponse,
    >,
}
/// Nested message and enum types in `StartMfaEnrollmentResponse`.
pub mod start_mfa_enrollment_response {
    /// MFA start enrollment response by 2nd factor type.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum EnrollmentResponse {
        /// Verification info to authorize sending an SMS for phone verification.
        #[prost(message, tag = "1")]
        PhoneSessionInfo(super::StartMfaPhoneResponseInfo),
    }
}
/// Withdraws MFA.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WithdrawMfaRequest {
    /// Required. User's ID token.
    #[prost(string, tag = "1")]
    pub id_token: ::prost::alloc::string::String,
    /// Required. MFA enrollment id from a current MFA enrollment.
    #[prost(string, tag = "2")]
    pub mfa_enrollment_id: ::prost::alloc::string::String,
    /// The ID of the Identity Platform tenant that the user unenrolling MFA
    /// belongs to. If not set, the user belongs to the default Identity Platform
    /// project.
    #[prost(string, tag = "3")]
    pub tenant_id: ::prost::alloc::string::String,
}
/// Withdraws MultiFactorAuth response.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WithdrawMfaResponse {
    /// ID token updated to reflect removal of the second factor.
    #[prost(string, tag = "1")]
    pub id_token: ::prost::alloc::string::String,
    /// Refresh token updated to reflect removal of the second factor.
    #[prost(string, tag = "2")]
    pub refresh_token: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod account_management_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Account management for Identity Toolkit
    #[derive(Debug, Clone)]
    pub struct AccountManagementServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AccountManagementServiceClient<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: std::convert::TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> AccountManagementServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> AccountManagementServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            AccountManagementServiceClient::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
        }
        /// Finishes enrolling a second factor for the user.
        pub async fn finalize_mfa_enrollment(
            &mut self,
            request: impl tonic::IntoRequest<super::FinalizeMfaEnrollmentRequest>,
        ) -> Result<
            tonic::Response<super::FinalizeMfaEnrollmentResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.identitytoolkit.v2.AccountManagementService/FinalizeMfaEnrollment",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        /// Step one of the MFA enrollment process. In SMS case, this sends an
        /// SMS verification code to the user.
        pub async fn start_mfa_enrollment(
            &mut self,
            request: impl tonic::IntoRequest<super::StartMfaEnrollmentRequest>,
        ) -> Result<tonic::Response<super::StartMfaEnrollmentResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.identitytoolkit.v2.AccountManagementService/StartMfaEnrollment",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        /// Revokes one second factor from the enrolled second factors for an account.
        pub async fn withdraw_mfa(
            &mut self,
            request: impl tonic::IntoRequest<super::WithdrawMfaRequest>,
        ) -> Result<tonic::Response<super::WithdrawMfaResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.identitytoolkit.v2.AccountManagementService/WithdrawMfa",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
    }
}
/// Finalizes sign-in by verifying MFA challenge.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FinalizeMfaSignInRequest {
    /// Required. Pending credential from first factor sign-in.
    #[prost(string, tag = "2")]
    pub mfa_pending_credential: ::prost::alloc::string::String,
    /// The ID of the Identity Platform tenant the user is signing in to. If not
    /// set, the user will sign in to the default Identity Platform project.
    #[prost(string, tag = "4")]
    pub tenant_id: ::prost::alloc::string::String,
    /// Proof of completion of the MFA challenge.
    #[prost(oneof = "finalize_mfa_sign_in_request::VerificationInfo", tags = "3")]
    pub verification_info: ::core::option::Option<
        finalize_mfa_sign_in_request::VerificationInfo,
    >,
}
/// Nested message and enum types in `FinalizeMfaSignInRequest`.
pub mod finalize_mfa_sign_in_request {
    /// Proof of completion of the MFA challenge.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum VerificationInfo {
        /// Proof of completion of the SMS based MFA challenge.
        #[prost(message, tag = "3")]
        PhoneVerificationInfo(super::FinalizeMfaPhoneRequestInfo),
    }
}
/// FinalizeMfaSignIn response.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FinalizeMfaSignInResponse {
    /// ID token for the authenticated user.
    #[prost(string, tag = "1")]
    pub id_token: ::prost::alloc::string::String,
    /// Refresh token for the authenticated user.
    #[prost(string, tag = "2")]
    pub refresh_token: ::prost::alloc::string::String,
    /// MFA verified sign-in information.
    #[prost(oneof = "finalize_mfa_sign_in_response::AuxiliaryAuthInfo", tags = "3")]
    pub auxiliary_auth_info: ::core::option::Option<
        finalize_mfa_sign_in_response::AuxiliaryAuthInfo,
    >,
}
/// Nested message and enum types in `FinalizeMfaSignInResponse`.
pub mod finalize_mfa_sign_in_response {
    /// MFA verified sign-in information.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum AuxiliaryAuthInfo {
        /// Extra phone auth info, including android verification proof.
        #[prost(message, tag = "3")]
        PhoneAuthInfo(super::FinalizeMfaPhoneResponseInfo),
    }
}
/// Starts multi-factor sign-in by sending the multi-factor auth challenge.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartMfaSignInRequest {
    /// Required. Pending credential from first factor sign-in.
    #[prost(string, tag = "2")]
    pub mfa_pending_credential: ::prost::alloc::string::String,
    /// Required. MFA enrollment id from the user's list of current MFA enrollments.
    #[prost(string, tag = "3")]
    pub mfa_enrollment_id: ::prost::alloc::string::String,
    /// The ID of the Identity Platform tenant the user is signing in to. If not
    /// set, the user will sign in to the default Identity Platform project.
    #[prost(string, tag = "5")]
    pub tenant_id: ::prost::alloc::string::String,
    /// MFA information by type of 2nd factor.
    #[prost(oneof = "start_mfa_sign_in_request::SignInInfo", tags = "4")]
    pub sign_in_info: ::core::option::Option<start_mfa_sign_in_request::SignInInfo>,
}
/// Nested message and enum types in `StartMfaSignInRequest`.
pub mod start_mfa_sign_in_request {
    /// MFA information by type of 2nd factor.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum SignInInfo {
        /// Verification info to authorize sending an SMS for phone verification.
        #[prost(message, tag = "4")]
        PhoneSignInInfo(super::StartMfaPhoneRequestInfo),
    }
}
/// StartMfaSignIn response.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartMfaSignInResponse {
    /// MultiFactor start sign-in response by 2nd factor type.
    #[prost(oneof = "start_mfa_sign_in_response::ResponseInfo", tags = "1")]
    pub response_info: ::core::option::Option<start_mfa_sign_in_response::ResponseInfo>,
}
/// Nested message and enum types in `StartMfaSignInResponse`.
pub mod start_mfa_sign_in_response {
    /// MultiFactor start sign-in response by 2nd factor type.
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum ResponseInfo {
        /// MultiFactor sign-in session information specific to SMS-type second
        /// factors. Along with the one-time code retrieved from the sent SMS, the
        /// contents of this session information should be passed to
        /// FinalizeMfaSignIn to complete the sign in.
        #[prost(message, tag = "1")]
        PhoneResponseInfo(super::StartMfaPhoneResponseInfo),
    }
}
/// Generated client implementations.
pub mod authentication_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Authentication for Identity Toolkit
    #[derive(Debug, Clone)]
    pub struct AuthenticationServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl AuthenticationServiceClient<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: std::convert::TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> AuthenticationServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + 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,
        ) -> AuthenticationServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            AuthenticationServiceClient::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
        }
        /// Verifies the MFA challenge and performs sign-in
        pub async fn finalize_mfa_sign_in(
            &mut self,
            request: impl tonic::IntoRequest<super::FinalizeMfaSignInRequest>,
        ) -> Result<tonic::Response<super::FinalizeMfaSignInResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.identitytoolkit.v2.AuthenticationService/FinalizeMfaSignIn",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
        /// Sends the MFA challenge
        pub async fn start_mfa_sign_in(
            &mut self,
            request: impl tonic::IntoRequest<super::StartMfaSignInRequest>,
        ) -> Result<tonic::Response<super::StartMfaSignInResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.identitytoolkit.v2.AuthenticationService/StartMfaSignIn",
            );
            self.inner.unary(request.into_request(), path, codec).await
        }
    }
}