tencent_sdk/api/
dns.rs

1use crate::{
2    Result,
3    client::RequestOptions,
4    types::dns::{
5        CreateTxtRecordRequest, CreateTxtRecordResponse, DeleteRecordRequest, DeleteRecordResponse,
6        ModifyTxtRecordRequest, ModifyTxtRecordResponse,
7    },
8};
9
10#[cfg(feature = "async")]
11use crate::client::Client;
12
13#[cfg(feature = "async")]
14#[derive(Clone)]
15pub struct DnsService {
16    client: Client,
17}
18
19#[cfg(feature = "async")]
20impl DnsService {
21    pub(crate) fn new(client: Client) -> Self {
22        Self { client }
23    }
24
25    pub async fn create_txt_record(
26        &self,
27        request: &CreateTxtRecordRequest,
28    ) -> Result<CreateTxtRecordResponse> {
29        self.client.execute(request, None).await
30    }
31
32    pub async fn create_txt_record_with_options(
33        &self,
34        request: &CreateTxtRecordRequest,
35        options: &RequestOptions,
36    ) -> Result<CreateTxtRecordResponse> {
37        self.client.execute(request, Some(options)).await
38    }
39
40    pub async fn modify_txt_record(
41        &self,
42        request: &ModifyTxtRecordRequest,
43    ) -> Result<ModifyTxtRecordResponse> {
44        self.client.execute(request, None).await
45    }
46
47    pub async fn modify_txt_record_with_options(
48        &self,
49        request: &ModifyTxtRecordRequest,
50        options: &RequestOptions,
51    ) -> Result<ModifyTxtRecordResponse> {
52        self.client.execute(request, Some(options)).await
53    }
54
55    pub async fn delete_record(
56        &self,
57        request: &DeleteRecordRequest,
58    ) -> Result<DeleteRecordResponse> {
59        self.client.execute(request, None).await
60    }
61
62    pub async fn delete_record_with_options(
63        &self,
64        request: &DeleteRecordRequest,
65        options: &RequestOptions,
66    ) -> Result<DeleteRecordResponse> {
67        self.client.execute(request, Some(options)).await
68    }
69}
70
71#[cfg(feature = "blocking")]
72use crate::client::BlockingClient;
73
74#[cfg(feature = "blocking")]
75#[derive(Clone)]
76pub struct BlockingDnsService {
77    client: BlockingClient,
78}
79
80#[cfg(feature = "blocking")]
81impl BlockingDnsService {
82    pub(crate) fn new(client: BlockingClient) -> Self {
83        Self { client }
84    }
85
86    pub fn create_txt_record(
87        &self,
88        request: &CreateTxtRecordRequest,
89    ) -> Result<CreateTxtRecordResponse> {
90        self.client.execute(request, None)
91    }
92
93    pub fn create_txt_record_with_options(
94        &self,
95        request: &CreateTxtRecordRequest,
96        options: &RequestOptions,
97    ) -> Result<CreateTxtRecordResponse> {
98        self.client.execute(request, Some(options))
99    }
100
101    pub fn modify_txt_record(
102        &self,
103        request: &ModifyTxtRecordRequest,
104    ) -> Result<ModifyTxtRecordResponse> {
105        self.client.execute(request, None)
106    }
107
108    pub fn modify_txt_record_with_options(
109        &self,
110        request: &ModifyTxtRecordRequest,
111        options: &RequestOptions,
112    ) -> Result<ModifyTxtRecordResponse> {
113        self.client.execute(request, Some(options))
114    }
115
116    pub fn delete_record(&self, request: &DeleteRecordRequest) -> Result<DeleteRecordResponse> {
117        self.client.execute(request, None)
118    }
119
120    pub fn delete_record_with_options(
121        &self,
122        request: &DeleteRecordRequest,
123        options: &RequestOptions,
124    ) -> Result<DeleteRecordResponse> {
125        self.client.execute(request, Some(options))
126    }
127}