emailit 2.0.3

The official Rust SDK for the Emailit Email API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! Bulk email verification list service.

use std::sync::Arc;

use crate::client::{BaseClient, RawResponse};
use crate::collection::Collection;
use crate::error::Error;
use crate::types::{
    CreateEmailVerificationListParams, EmailVerificationList, EmailVerificationListResultsParams,
    ListEmailVerificationListsParams,
};

/// Service for bulk-verifying lists of email addresses.
///
/// Accessed via [`Emailit::email_verification_lists`](crate::Emailit::email_verification_lists).
pub struct EmailVerificationListService {
    pub(crate) client: Arc<BaseClient>,
}

impl EmailVerificationListService {
    /// Creates a new verification list and starts processing.
    ///
    /// `POST /v2/email-verification-lists`
    pub async fn create(
        &self,
        params: CreateEmailVerificationListParams,
    ) -> Result<EmailVerificationList, Error> {
        self.client
            .request(
                "POST",
                "/v2/email-verification-lists",
                serde_json::to_value(&params).ok(),
                None,
            )
            .await
    }

    /// Lists verification lists with optional pagination.
    ///
    /// `GET /v2/email-verification-lists`
    pub async fn list(
        &self,
        params: Option<ListEmailVerificationListsParams>,
    ) -> Result<Collection<EmailVerificationList>, Error> {
        let query = params.map(|p| {
            let mut q = Vec::new();
            if let Some(page) = p.page {
                q.push(("page", page.to_string()));
            }
            if let Some(limit) = p.limit {
                q.push(("limit", limit.to_string()));
            }
            q
        });
        self.client
            .request::<Collection<EmailVerificationList>>(
                "GET",
                "/v2/email-verification-lists",
                None,
                query.as_deref(),
            )
            .await
    }

    /// Retrieves a verification list by ID.
    ///
    /// `GET /v2/email-verification-lists/:id`
    pub async fn get(&self, id: &str) -> Result<EmailVerificationList, Error> {
        let path = format!("/v2/email-verification-lists/{}", urlencoding::encode(id));
        self.client.request("GET", &path, None, None).await
    }

    /// Retrieves the individual verification results for a list.
    ///
    /// `GET /v2/email-verification-lists/:id/results`
    pub async fn results(
        &self,
        id: &str,
        params: Option<EmailVerificationListResultsParams>,
    ) -> Result<Collection<serde_json::Value>, Error> {
        let path = format!(
            "/v2/email-verification-lists/{}/results",
            urlencoding::encode(id)
        );
        let query = params.map(|p| {
            let mut q = Vec::new();
            if let Some(page) = p.page {
                q.push(("page", page.to_string()));
            }
            if let Some(limit) = p.limit {
                q.push(("limit", limit.to_string()));
            }
            q
        });
        self.client
            .request::<Collection<serde_json::Value>>("GET", &path, None, query.as_deref())
            .await
    }

    /// Exports verification results as a raw file download (e.g. CSV).
    ///
    /// `GET /v2/email-verification-lists/:id/export`
    pub async fn export(&self, id: &str) -> Result<RawResponse, Error> {
        let path = format!(
            "/v2/email-verification-lists/{}/export",
            urlencoding::encode(id)
        );
        self.client.request_raw("GET", &path).await
    }
}