apibrasil 1.0.0

//! Cliente síncrono da plataforma (`feature = "blocking"`).
//!
//! Espelha a API assíncrona sobre um runtime Tokio próprio — útil em CLIs,
//! scripts e código legado que não é `async`.
//!
//! ```no_run
//! use apibrasil::blocking::ApiBrasil;
//! use apibrasil::Config;
//! use serde_json::json;
//!
//! fn main() -> apibrasil::Result<()> {
//!     let api = ApiBrasil::new(Config::new().bearer_token("...").device_token("..."))?;
//!
//!     api.whatsapp()
//!         .send_text(json!({ "number": "5511999999999", "text": "Olá!" }))?;
//!
//!     let empresa = api.consulta().cnpj(json!({ "cnpj": "00000000000000" }))?;
//!     println!("{:?}", empresa.data());
//!
//!     Ok(())
//! }
//! ```
//!
//! Qualquer método assíncrono ainda alcançável pelo escape hatch
//! [`ApiBrasil::block_on`] — inclusive os que não têm espelho síncrono:
//!
//! ```no_run
//! # use apibrasil::blocking::ApiBrasil;
//! # fn exemplo(api: &ApiBrasil) -> apibrasil::Result<()> {
//! let status = api.block_on(api.asynchronous().catalog().status())?;
//! # let _ = status;
//! # Ok(())
//! # }
//! ```
//!
//! # Atenção
//!
//! Os métodos deste módulo bloqueiam a thread e **não podem** ser
//! chamados de dentro de um contexto assíncrono — use a API assíncrona
//! nesse caso.

use std::future::Future;
use std::sync::Arc;

use tokio::runtime::{Builder, Runtime};

use crate::core::{
    Config, CreditResponse, DeviceResponse, Error, ErrorKind, HttpClient, IntoBody, Json, Method,
    RequestOptions, ResponseData, Result,
};

/// Cliente síncrono da plataforma APIBrasil.
#[derive(Clone, Debug)]
pub struct ApiBrasil {
    runtime: Arc<Runtime>,
    api: crate::ApiBrasil,
}

impl ApiBrasil {
    /// Cria o cliente e o runtime que atende as chamadas.
    pub fn new(config: Config) -> Result<Self> {
        let runtime = Builder::new_current_thread()
            .enable_all()
            .build()
            .map_err(|error| {
                Error::new(
                    ErrorKind::Api,
                    format!("Não foi possível iniciar o runtime do cliente síncrono: {error}"),
                )
                .with_source(error)
            })?;

        Ok(Self {
            runtime: Arc::new(runtime),
            api: crate::ApiBrasil::new(config),
        })
    }

    /// Cria o cliente apenas com as credenciais do ambiente.
    pub fn from_env() -> Result<Self> {
        Self::new(Config::default())
    }

    /// Cliente assíncrono equivalente — use com
    /// [`block_on`](Self::block_on).
    pub fn asynchronous(&self) -> &crate::ApiBrasil {
        &self.api
    }

    /// Runtime que atende as chamadas síncronas.
    pub fn runtime(&self) -> &Arc<Runtime> {
        &self.runtime
    }

    /// Executa um future no runtime deste cliente.
    pub fn block_on<F: Future>(&self, future: F) -> F::Output {
        self.runtime.block_on(future)
    }

    /// Cliente HTTP interno.
    pub fn http(&self) -> &Arc<HttpClient> {
        self.api.http()
    }

    /// Configuração atual do cliente.
    pub fn config(&self) -> Config {
        self.api.config()
    }

    /// Define/atualiza o Bearer Token do cliente.
    pub fn set_bearer_token(&self, token: impl Into<String>) -> &Self {
        self.api.set_bearer_token(token);
        self
    }

    /// Remove o Bearer Token do cliente.
    pub fn clear_bearer_token(&self) -> &Self {
        self.api.clear_bearer_token();
        self
    }

    /// Define/atualiza o DeviceToken do cliente.
    pub fn set_device_token(&self, token: impl Into<String>) -> &Self {
        self.api.set_device_token(token);
        self
    }

    /// Remove o DeviceToken do cliente.
    pub fn clear_device_token(&self) -> &Self {
        self.api.clear_device_token();
        self
    }

    /// Devolve um cliente que usa `options` em todas as chamadas.
    pub fn with_options(&self, options: RequestOptions) -> Self {
        Self {
            runtime: self.runtime.clone(),
            api: self.api.with_options(options),
        }
    }

    /// Devolve um cliente apontando para outro device, compartilhando o
    /// mesmo runtime.
    pub fn with_device(&self, device_token: impl Into<String>) -> Self {
        Self {
            runtime: self.runtime.clone(),
            api: self.api.with_device(device_token),
        }
    }

    /// Porta de saída genérica: chama qualquer endpoint do gateway.
    pub fn request(&self, method: Method, path: &str, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.api.request(method, path, body))
    }

    /// Como [`request`](Self::request), sem normalizar a resposta em
    /// objeto JSON.
    pub fn execute(&self, method: Method, path: &str, body: impl IntoBody) -> Result<ResponseData> {
        self.block_on(self.api.execute(method, path, body))
    }

    /// Baixa os bytes crus de uma rota (PDF, imagens...).
    pub fn download(&self, path: &str) -> Result<Vec<u8>> {
        self.block_on(self.api.download(path))
    }
}

/// Autentica por email/senha e devolve um cliente síncrono já
/// autenticado, junto da sessão retornada pela plataforma.
pub fn login(credentials: impl IntoBody, config: Config) -> Result<(ApiBrasil, Json)> {
    let api = ApiBrasil::new(config)?;
    let session = api.block_on(crate::AuthService::login(
        &api.asynchronous().auth(),
        credentials,
    ))?;

    if crate::requires_2fa(&session) {
        return Err(Error::authentication(
            "Esta conta exige autenticação em dois fatores. Use auth().login() + auth().verify_2fa().",
        )
        .with_response(session));
    }

    Ok((api, session))
}

/// Declara o espelho síncrono de um serviço.
macro_rules! sync_service {
    (
        $(#[$meta:meta])*
        $name:ident = $accessor:ident : $async_ty:ident
    ) => {
        $(#[$meta])*
        #[derive(Clone, Debug)]
        pub struct $name {
            runtime: Arc<Runtime>,
            inner: crate::$async_ty,
        }

        impl $name {
            #[doc = concat!("Serviço assíncrono equivalente: [`", stringify!($async_ty), "`](crate::", stringify!($async_ty), ").")]
            pub fn asynchronous(&self) -> &crate::$async_ty {
                &self.inner
            }

            /// Executa um future no runtime deste cliente — use para os
            /// métodos assíncronos sem espelho síncrono.
            pub fn block_on<F: Future>(&self, future: F) -> F::Output {
                self.runtime.block_on(future)
            }

            /// Devolve uma cópia do serviço que usa `options` em todas as
            /// chamadas.
            pub fn with_options(&self, options: RequestOptions) -> Self {
                Self {
                    runtime: self.runtime.clone(),
                    inner: self.inner.with_options(options),
                }
            }
        }

        impl ApiBrasil {
            $(#[$meta])*
            pub fn $accessor(&self) -> $name {
                $name {
                    runtime: self.runtime.clone(),
                    inner: self.api.$accessor(),
                }
            }
        }
    };
}

/// Espelha os métodos device-based `(body) -> DeviceResponse`.
macro_rules! sync_device {
    ($name:ident : $async_ty:ident [ $($method:ident),* $(,)? ]) => {
        impl $name {
            /// Executa uma action do serviço: `POST /{servico}/{action}`.
            pub fn request(&self, action: &str, body: impl IntoBody) -> Result<DeviceResponse> {
                self.block_on(self.inner.request(action, body))
            }

            /// Executa a action de forma assíncrona via fila:
            /// `POST /{servico}/{action}/queue`.
            pub fn queue(&self, action: &str, body: impl IntoBody) -> Result<DeviceResponse> {
                self.block_on(self.inner.queue(action, body))
            }

            $(
                #[doc = concat!("Versão síncrona de [`", stringify!($async_ty), "::", stringify!($method), "`](crate::", stringify!($async_ty), "::", stringify!($method), ").")]
                pub fn $method(&self, body: impl IntoBody) -> Result<DeviceResponse> {
                    self.block_on(self.inner.$method(body))
                }
            )*
        }
    };
}

/// Espelha os métodos sem parâmetros que devolvem [`Json`].
macro_rules! sync_json {
    ($name:ident : $async_ty:ident [ $($method:ident),* $(,)? ]) => {
        impl $name {
            $(
                #[doc = concat!("Versão síncrona de [`", stringify!($async_ty), "::", stringify!($method), "`](crate::", stringify!($async_ty), "::", stringify!($method), ").")]
                pub fn $method(&self) -> Result<Json> {
                    self.block_on(self.inner.$method())
                }
            )*
        }
    };
}

/// Espelha os métodos `(body) -> Json`.
macro_rules! sync_json_body {
    ($name:ident : $async_ty:ident [ $($method:ident),* $(,)? ]) => {
        impl $name {
            $(
                #[doc = concat!("Versão síncrona de [`", stringify!($async_ty), "::", stringify!($method), "`](crate::", stringify!($async_ty), "::", stringify!($method), ").")]
                pub fn $method(&self, body: impl IntoBody) -> Result<Json> {
                    self.block_on(self.inner.$method(body))
                }
            )*
        }
    };
}

/// Espelha os métodos `(body) -> CreditResponse`.
macro_rules! sync_credit {
    ($name:ident : $async_ty:ident [ $($method:ident),* $(,)? ]) => {
        impl $name {
            $(
                #[doc = concat!("Versão síncrona de [`", stringify!($async_ty), "::", stringify!($method), "`](crate::", stringify!($async_ty), "::", stringify!($method), ").")]
                pub fn $method(&self, body: impl IntoBody) -> Result<CreditResponse> {
                    self.block_on(self.inner.$method(body))
                }
            )*
        }
    };
}

// ---------------------------------------------------------------- mensageria

sync_service! {
    /// WhatsApp device-based (`/whatsapp/{action}`).
    WhatsApp = whatsapp: WhatsAppService
}
sync_device!(WhatsApp: WhatsAppService [
    start, qrcode, logout, close, delete_session, restart_session, get_connection_status,
    send_text, send_file, send_file64, send_audio, send_video, send_gif, send_link, send_location,
    send_contact, send_sticker, send_list, send_buttons, send_poll_message, send_pix_key,
    send_text_to_storie, send_image_to_storie, send_video_to_storie, check_number_status,
    get_all_chats, get_all_contacts, get_all_groups, get_profile_pic,
]);

sync_service! {
    /// WhatsMeow (`/whatsmeow/{action}`).
    WhatsMeow = whatsmeow: WhatsMeowService
}
sync_device!(WhatsMeow: WhatsMeowService [
    send_text, send_media, instance_create, instance_connect, instance_qr,
]);

sync_service! {
    /// SMS (`/sms/{action}` e `/sms/send/credits`).
    Sms = sms: SmsService
}
sync_device!(Sms: SmsService [send]);

impl Sms {
    /// Versão síncrona de [`SmsService::send_with_credits`](crate::SmsService::send_with_credits).
    pub fn send_with_credits(&self, body: impl IntoBody) -> Result<CreditResponse> {
        self.block_on(self.inner.send_with_credits(body))
    }
}

sync_service! {
    /// Evolution API (`/evolution/{controller}/{action}`).
    Evolution = evolution: EvolutionService
}

impl Evolution {
    /// Versão síncrona de [`EvolutionService::request`](crate::EvolutionService::request).
    pub fn request(
        &self,
        controller: &str,
        action: &str,
        body: impl IntoBody,
    ) -> Result<DeviceResponse> {
        self.block_on(self.inner.request(controller, action, body))
    }

    /// Versão síncrona de [`EvolutionService::call`](crate::EvolutionService::call).
    pub fn call(&self, path: &str, body: impl IntoBody) -> Result<DeviceResponse> {
        self.block_on(self.inner.call(path, body))
    }

    /// Versão síncrona de [`EvolutionService::queue`](crate::EvolutionService::queue).
    pub fn queue(
        &self,
        controller: &str,
        action: &str,
        body: impl IntoBody,
    ) -> Result<DeviceResponse> {
        self.block_on(self.inner.queue(controller, action, body))
    }
}

// --------------------------------------------------------------------- dados

sync_service! {
    /// Dados cadastrais device-based (`/dados/{action}`).
    Dados = dados: DadosService
}
sync_device!(Dados: DadosService [
    cnpj, cpf, cep, lista_socios, lista_cnaes, capital_social, by_query,
]);

sync_service! {
    /// CEP + geolocalização (`/cep/{action}`).
    Cep = cep: CepService
}
sync_device!(Cep: CepService [
    cep, bairros, cidades, cidades_por_ddd, estados, calcular_distancia,
]);

sync_service! {
    /// Correios (`/correios/{action}`).
    Correios = correios: CorreiosService
}
sync_device!(Correios: CorreiosService [rastreio]);

sync_service! {
    /// Tabela FIPE (`/fipe/{action}`).
    Fipe = fipe: FipeService
}
sync_device!(Fipe: FipeService [
    consultar_tabela_de_referencia, consultar_marcas, consultar_modelos, consultar_ano_modelo,
    consultar_modelos_atraves_do_ano, consultar_valor_com_todos_parametros,
]);

sync_service! {
    /// Veículos por placa (`/vehicles/{action}`).
    Vehicles = vehicles: VehiclesService
}
sync_device!(Vehicles: VehiclesService [dados, fipe, base_dados, base_fipe]);

impl Vehicles {
    /// Versão síncrona de [`VehiclesService::consulta_fipe`](crate::VehiclesService::consulta_fipe).
    pub fn consulta_fipe(&self, placa: &str) -> Result<DeviceResponse> {
        self.block_on(self.inner.consulta_fipe(placa))
    }
}

sync_service! {
    /// Geolocalização (`/geolocation/{action}`).
    Geolocation = geolocation: GeolocationService
}
sync_device!(Geolocation: GeolocationService [geocode, forward_geocoding]);

sync_service! {
    /// Matriz de distâncias (`/geomatrix/{action}`).
    Geomatrix = geomatrix: GeomatrixService
}
sync_device!(Geomatrix: GeomatrixService [distance]);

sync_service! {
    /// OCR / Google Vision (`/recognize/{action}`).
    Recognize = recognize: RecognizeService
}
sync_device!(Recognize: RecognizeService [base64, uri]);

sync_service! {
    /// DDD (`/ddd/{action}`).
    Ddd = ddd: DddService
}
sync_device!(Ddd: DddService []);

sync_service! {
    /// Feriados (`/holidays/{action}`).
    Holidays = holidays: HolidaysService
}
sync_device!(Holidays: HolidaysService [feriados]);

sync_service! {
    /// Tradução (`/translate/{action}`).
    Translate = translate: TranslateService
}
sync_device!(Translate: TranslateService [identify, models]);

sync_service! {
    /// Clima (`/weather/{action}`).
    Weather = weather: WeatherService
}
sync_device!(Weather: WeatherService [city, coordenates]);

sync_service! {
    /// Loterias (`/loterias/{sorteio}/*`).
    Loterias = loterias: LoteriasService
}

impl Loterias {
    /// Versão síncrona de [`LoteriasService::resultado`](crate::LoteriasService::resultado).
    pub fn resultado(
        &self,
        sorteio: &str,
        concurso: u64,
        body: impl IntoBody,
    ) -> Result<DeviceResponse> {
        self.block_on(self.inner.resultado(sorteio, concurso, body))
    }

    /// Versão síncrona de [`LoteriasService::latest`](crate::LoteriasService::latest).
    pub fn latest(&self, sorteio: &str, body: impl IntoBody) -> Result<DeviceResponse> {
        self.block_on(self.inner.latest(sorteio, body))
    }
}

sync_service! {
    /// GeoIP (`/database/ip`).
    DatabaseIp = database_ip: DatabaseIpService
}

impl DatabaseIp {
    /// Versão síncrona de [`DatabaseIpService::ip`](crate::DatabaseIpService::ip).
    pub fn ip(&self, body: impl IntoBody) -> Result<DeviceResponse> {
        self.block_on(self.inner.ip(body))
    }
}

sync_service! {
    /// URA reversa / ligações (`/ura/call/*`).
    Ura = ura: UraService
}
sync_json_body!(Ura: UraService [dialler, status]);

sync_service! {
    /// Chip virtual (`/chip/virtual/*`).
    ChipVirtual = chip_virtual: ChipVirtualService
}
sync_json_body!(ChipVirtual: ChipVirtualService [operators, buy, activation, services]);

sync_service! {
    /// Execução em lote (`/bulk/*`).
    Bulk = bulk: BulkService
}

impl Bulk {
    /// Versão síncrona de [`BulkService::direct`](crate::BulkService::direct).
    pub fn direct(&self, action: &str, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.direct(action, body))
    }

    /// Versão síncrona de [`BulkService::queue`](crate::BulkService::queue).
    pub fn queue(&self, action: &str, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.queue(action, body))
    }
}

sync_service! {
    /// Consultas por crédito (`/consulta/{servico}/credits`).
    Consulta = consulta: ConsultaService
}
sync_credit!(Consulta: ConsultaService [
    cpf, cnpj, cnh, cep, veiculos, vehicles, telefone, ddd_anatel, geoip, rastreio, crm, crbm,
    cro, weather, emissao_notas, frete_antt, api_rntrc, quod, cep_distancia, proxy_seller,
]);

impl Consulta {
    /// Versão síncrona de [`ConsultaService::generic`](crate::ConsultaService::generic).
    pub fn generic(&self, service: &str, body: impl IntoBody) -> Result<CreditResponse> {
        self.block_on(self.inner.generic(service, body))
    }

    /// Versão síncrona de [`CreditService::credits`](crate::CreditService::credits).
    pub fn credits(&self, service: &str) -> Result<CreditResponse> {
        self.block_on(self.inner.credits(service))
    }

    /// Versão síncrona de [`ConsultaService::veiculos_base`](crate::ConsultaService::veiculos_base).
    pub fn veiculos_base(&self, base: &str, body: impl IntoBody) -> Result<CreditResponse> {
        self.block_on(self.inner.veiculos_base(base, body))
    }
}

// ----------------------------------------------------------------- plataforma

sync_service! {
    /// Login, 2FA, cadastro, recuperação de senha e perfil.
    Auth = auth: AuthService
}
sync_json!(Auth: AuthService [
    two_factor_methods, me, verify, profile, token_rotate, token_revoke,
]);
sync_json_body!(Auth: AuthService [
    send_2fa, register, register_simple, verification_send, verification_verify, password_forgot,
    password_verify_code, password_reset, password_resend, change_password, update_me,
]);

impl Auth {
    /// Versão síncrona de [`AuthService::login`](crate::AuthService::login).
    pub fn login(&self, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.login(body))
    }

    /// Versão síncrona de [`AuthService::verify_2fa`](crate::AuthService::verify_2fa).
    pub fn verify_2fa(&self, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.verify_2fa(body))
    }

    /// Versão síncrona de [`AuthService::refresh`](crate::AuthService::refresh).
    pub fn refresh(&self) -> Result<Json> {
        self.block_on(self.inner.refresh())
    }

    /// Versão síncrona de [`AuthService::logout`](crate::AuthService::logout).
    pub fn logout(&self) -> Result<Json> {
        self.block_on(self.inner.logout())
    }
}

sync_service! {
    /// CRUD de devices.
    Devices = devices: DevicesService
}
sync_json_body!(Devices: DevicesService [update, requests]);

impl Devices {
    /// Versão síncrona de [`DevicesService::list`](crate::DevicesService::list).
    pub fn list(&self, query: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.list(query))
    }

    /// Versão síncrona de [`DevicesService::store`](crate::DevicesService::store).
    pub fn store(&self, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.store(body))
    }

    /// Versão síncrona de [`DevicesService::show`](crate::DevicesService::show).
    pub fn show(&self, device_token: Option<&str>) -> Result<Json> {
        self.block_on(self.inner.show(device_token))
    }

    /// Versão síncrona de [`DevicesService::destroy`](crate::DevicesService::destroy).
    pub fn destroy(&self, device_token: Option<&str>) -> Result<Json> {
        self.block_on(self.inner.destroy(device_token))
    }
}

sync_service! {
    /// Catálogo de APIs, planos, documentações e servidores.
    Catalog = catalog: CatalogService
}
sync_json!(Catalog: CatalogService [
    api_categories, my_apis, plans, documentations, servers, status,
]);
sync_json_body!(Catalog: CatalogService [endpoint_url, endpoint_body]);

impl Catalog {
    /// Versão síncrona de [`CatalogService::apis`](crate::CatalogService::apis).
    pub fn apis(&self, search: Option<&str>) -> Result<Json> {
        self.block_on(self.inner.apis(search))
    }

    /// Versão síncrona de [`CatalogService::api`](crate::CatalogService::api).
    pub fn api(&self, identifier: &str) -> Result<Json> {
        self.block_on(self.inner.api(identifier))
    }

    /// Versão síncrona de [`CatalogService::api_by_name`](crate::CatalogService::api_by_name).
    pub fn api_by_name(&self, name: &str) -> Result<Json> {
        self.block_on(self.inner.api_by_name(name))
    }

    /// Versão síncrona de [`CatalogService::apis_by_device`](crate::CatalogService::apis_by_device).
    pub fn apis_by_device(&self, device_token: &str) -> Result<Json> {
        self.block_on(self.inner.apis_by_device(device_token))
    }

    /// Versão síncrona de
    /// [`CatalogService::documentations_by_server`](crate::CatalogService::documentations_by_server).
    pub fn documentations_by_server(&self, server_search: &str) -> Result<Json> {
        self.block_on(self.inner.documentations_by_server(server_search))
    }
}

sync_service! {
    /// Saldo, faturas, notificações e tickets.
    Account = account: AccountService
}
sync_json!(Account: AccountService [
    balance, plan, invoices, invoice_notes, jobs, credentials, indications, notifications, tickets,
    mark_all_notifications_read,
]);
sync_json_body!(Account: AccountService [
    pay_invoice, requests, api_requests, create_ticket,
]);

impl Account {
    /// Versão síncrona de
    /// [`AccountService::mark_notification_read`](crate::AccountService::mark_notification_read).
    pub fn mark_notification_read(&self, id: impl std::fmt::Display) -> Result<Json> {
        self.block_on(self.inner.mark_notification_read(id))
    }

    /// Versão síncrona de [`AccountService::update_ticket`](crate::AccountService::update_ticket).
    pub fn update_ticket(&self, id: impl std::fmt::Display, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.update_ticket(id, body))
    }

    /// Versão síncrona de
    /// [`AccountService::ticket_messages`](crate::AccountService::ticket_messages).
    pub fn ticket_messages(&self, id: impl std::fmt::Display) -> Result<Json> {
        self.block_on(self.inner.ticket_messages(id))
    }

    /// Versão síncrona de
    /// [`AccountService::add_ticket_message`](crate::AccountService::add_ticket_message).
    pub fn add_ticket_message(
        &self,
        id: impl std::fmt::Display,
        body: impl IntoBody,
    ) -> Result<Json> {
        self.block_on(self.inner.add_ticket_message(id, body))
    }
}

sync_service! {
    /// Recargas e pagamentos (PIX, boleto, cartão).
    Payments = payments: PaymentsService
}
sync_json!(Payments: PaymentsService [
    recharges, checkout_payment_methods, checkout_periods,
]);
sync_json_body!(Payments: PaymentsService [
    recharge, card_process, card_installments, validate_coupon, checkout_finalize,
]);

impl Payments {
    /// Versão síncrona de [`PaymentsService::recharge_show`](crate::PaymentsService::recharge_show).
    pub fn recharge_show(&self, identifier: &str) -> Result<Json> {
        self.block_on(self.inner.recharge_show(identifier))
    }

    /// Versão síncrona de [`PaymentsService::pix_generate`](crate::PaymentsService::pix_generate).
    pub fn pix_generate(&self, provider: &str, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.pix_generate(provider, body))
    }

    /// Versão síncrona de [`PaymentsService::pix_status`](crate::PaymentsService::pix_status).
    pub fn pix_status(&self, provider: &str, tx_id: &str) -> Result<Json> {
        self.block_on(self.inner.pix_status(provider, tx_id))
    }

    /// Versão síncrona de
    /// [`PaymentsService::boleto_generate`](crate::PaymentsService::boleto_generate).
    pub fn boleto_generate(&self, provider: &str, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.boleto_generate(provider, body))
    }

    /// Versão síncrona de [`PaymentsService::boleto_status`](crate::PaymentsService::boleto_status).
    pub fn boleto_status(&self, provider: &str, id: &str) -> Result<Json> {
        self.block_on(self.inner.boleto_status(provider, id))
    }

    /// Versão síncrona de [`PaymentsService::boleto_pdf`](crate::PaymentsService::boleto_pdf).
    pub fn boleto_pdf(&self, provider: &str, id: &str) -> Result<Vec<u8>> {
        self.block_on(self.inner.boleto_pdf(provider, id))
    }

    /// Versão síncrona de [`PaymentsService::card_status`](crate::PaymentsService::card_status).
    pub fn card_status(&self, id: &str) -> Result<Json> {
        self.block_on(self.inner.card_status(id))
    }
}

sync_service! {
    /// Whitelist de IPs da conta.
    IpWhitelist = ip_whitelist: IpWhitelistService
}
sync_json!(IpWhitelist: IpWhitelistService [add_current, reset]);

impl IpWhitelist {
    /// Versão síncrona de [`IpWhitelistService::get`](crate::IpWhitelistService::get).
    pub fn get(&self) -> Result<Json> {
        self.block_on(self.inner.get())
    }

    /// Versão síncrona de [`IpWhitelistService::set`](crate::IpWhitelistService::set).
    pub fn set<I, S>(&self, entries: I) -> Result<Json>
    where
        I: IntoIterator<Item = S>,
        S: Into<String>,
    {
        self.block_on(self.inner.set(entries))
    }

    /// Versão síncrona de [`IpWhitelistService::add`](crate::IpWhitelistService::add).
    pub fn add(&self, entry: &str) -> Result<Json> {
        self.block_on(self.inner.add(entry))
    }

    /// Versão síncrona de [`IpWhitelistService::remove`](crate::IpWhitelistService::remove).
    pub fn remove(&self, entry: &str) -> Result<Json> {
        self.block_on(self.inner.remove(entry))
    }

    /// Versão síncrona de [`IpWhitelistService::validate`](crate::IpWhitelistService::validate).
    pub fn validate(&self, entry: &str) -> Result<Json> {
        self.block_on(self.inner.validate(entry))
    }

    /// Versão síncrona de [`IpWhitelistService::current_ip`](crate::IpWhitelistService::current_ip).
    pub fn current_ip(&self) -> Result<Json> {
        self.block_on(self.inner.current_ip())
    }
}

sync_service! {
    /// Rate limit por Bearer Token.
    BearerRateLimit = bearer_rate_limit: BearerRateLimitService
}

impl BearerRateLimit {
    /// Versão síncrona de [`BearerRateLimitService::get`](crate::BearerRateLimitService::get).
    pub fn get(&self) -> Result<Json> {
        self.block_on(self.inner.get())
    }

    /// Versão síncrona de [`BearerRateLimitService::set`](crate::BearerRateLimitService::set).
    pub fn set(&self, body: impl IntoBody) -> Result<Json> {
        self.block_on(self.inner.set(body))
    }
}

sync_service! {
    /// Relatórios e dashboard de consumo.
    Reports = reports: ReportsService
}
sync_json!(Reports: ReportsService [
    dashboard_stats, consumption, extract, dashboard, summary, daily_usage, monthly_summary,
    error_analysis, device_analysis, recent_requests, quick_stats,
]);
sync_json_body!(Reports: ReportsService [generate_consumption_report]);