sevk 1.0.0

Rust SDK for Sevk 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

//! Domains resource

use crate::client::Client;
use crate::error::Error;
use crate::types::{
    CreateDomainRequest, DnsRecordsResponse, Domain, DomainListParams, DomainsListResponse,
    EmptyResponse, ItemsList, UpdateDomainRequest,
};

/// Domains API resource
pub struct Domains<'a> {
    client: &'a Client,
}

impl<'a> Domains<'a> {
    /// Create a new Domains resource
    pub fn new(client: &'a Client) -> Self {
        Self { client }
    }

    /// List all domains
    pub async fn list(&self, params: Option<DomainListParams>) -> Result<DomainsListResponse, Error> {
        let params = params.unwrap_or_default();
        let query_params = params.to_query_params();
        self.client
            .get_with_params("/domains", &query_params)
            .await
    }

    /// Get a domain by ID
    pub async fn get(&self, id: &str) -> Result<Domain, Error> {
        self.client.get(&format!("/domains/{}", id)).await
    }

    /// Create a new domain
    pub async fn create(&self, params: CreateDomainRequest) -> Result<Domain, Error> {
        self.client.post("/domains", &params).await
    }

    /// Update a domain by ID
    pub async fn update(&self, id: &str, data: UpdateDomainRequest) -> Result<Domain, Error> {
        self.client
            .put(&format!("/domains/{}", id), &data)
            .await
    }

    /// Delete a domain by ID
    pub async fn delete(&self, id: &str) -> Result<EmptyResponse, Error> {
        self.client.delete(&format!("/domains/{}", id)).await
    }

    /// Trigger domain verification
    pub async fn verify(&self, id: &str) -> Result<Domain, Error> {
        self.client
            .post(&format!("/domains/{}/verify", id), &serde_json::json!({}))
            .await
    }

    /// Get DNS records for a domain
    pub async fn get_dns_records(&self, id: &str) -> Result<DnsRecordsResponse, Error> {
        self.client
            .get(&format!("/domains/{}/dns-records", id))
            .await
    }

    /// Get available regions
    pub async fn get_regions(&self) -> Result<ItemsList<String>, Error> {
        self.client.get("/domains/regions").await
    }
}