1#![allow(non_camel_case_types)]
5#![allow(unused)]
6
7use ::serde::{Deserialize, Serialize};
8
9use crate::model::*;
10
11pub mod model;
12pub mod request;
13mod serde;
14
15pub struct RenderClient {
16 pub client: httpclient::Client,
17 authentication: RenderAuthentication,
18}
19impl RenderClient {
20 pub fn from_env() -> Self {
21 Self {
22 client: httpclient::Client::new().base_url("https://api.render.com/v1"),
23 authentication: RenderAuthentication::from_env(),
24 }
25 }
26}
27impl RenderClient {
28 pub fn new(url: &str, authentication: RenderAuthentication) -> Self {
29 let client = httpclient::Client::new().base_url(url);
30 Self { client, authentication }
31 }
32 pub fn with_authentication(mut self, authentication: RenderAuthentication) -> Self {
33 self.authentication = authentication;
34 self
35 }
36 pub(crate) fn authenticate<'a>(
37 &self,
38 mut r: httpclient::RequestBuilder<'a>,
39 ) -> httpclient::RequestBuilder<'a> {
40 match &self.authentication {
41 RenderAuthentication::ApiKeyAuth { api_key_auth } => {
42 r = r.bearer_auth(api_key_auth);
43 }
44 }
45 r
46 }
47 pub fn with_middleware<M: httpclient::Middleware + 'static>(
48 mut self,
49 middleware: M,
50 ) -> Self {
51 self.client = self.client.with_middleware(middleware);
52 self
53 }
54 pub fn list_authorized_users_and_teams(
58 &self,
59 ) -> request::ListAuthorizedUsersAndTeamsRequest {
60 request::ListAuthorizedUsersAndTeamsRequest {
61 http_client: &self,
62 cursor: None,
63 email: None,
64 limit: None,
65 name: None,
66 }
67 }
68 pub fn retrieve_user_or_team(
72 &self,
73 owner_id: &str,
74 ) -> request::RetrieveUserOrTeamRequest {
75 request::RetrieveUserOrTeamRequest {
76 http_client: &self,
77 owner_id: owner_id.to_owned(),
78 }
79 }
80 pub fn list_services(&self) -> request::ListServicesRequest {
84 request::ListServicesRequest {
85 http_client: &self,
86 created_after: None,
87 created_before: None,
88 cursor: None,
89 env: None,
90 limit: None,
91 name: None,
92 owner_id: None,
93 region: None,
94 suspended: None,
95 type_: None,
96 updated_after: None,
97 updated_before: None,
98 }
99 }
100 pub fn create_service(&self) -> request::CreateServiceRequest {
104 request::CreateServiceRequest {
105 http_client: &self,
106 auto_deploy: None,
107 branch: None,
108 env_vars: None,
109 name: None,
110 owner_id: None,
111 repo: None,
112 secret_files: None,
113 service_details: None,
114 type_: None,
115 }
116 }
117 pub fn retrieve_service(&self, service_id: &str) -> request::RetrieveServiceRequest {
121 request::RetrieveServiceRequest {
122 http_client: &self,
123 service_id: service_id.to_owned(),
124 }
125 }
126 pub fn delete_service(&self, service_id: &str) -> request::DeleteServiceRequest {
130 request::DeleteServiceRequest {
131 http_client: &self,
132 service_id: service_id.to_owned(),
133 }
134 }
135 pub fn update_service(&self, service_id: &str) -> request::UpdateServiceRequest {
139 request::UpdateServiceRequest {
140 http_client: &self,
141 auto_deploy: None,
142 branch: None,
143 name: None,
144 service_details: None,
145 service_id: service_id.to_owned(),
146 }
147 }
148 pub fn retrieve_environment_variables(
152 &self,
153 service_id: &str,
154 ) -> request::RetrieveEnvironmentVariablesRequest {
155 request::RetrieveEnvironmentVariablesRequest {
156 http_client: &self,
157 cursor: None,
158 limit: None,
159 service_id: service_id.to_owned(),
160 }
161 }
162 pub fn update_environment_variables(
166 &self,
167 body: Vec<EnvVar>,
168 service_id: &str,
169 ) -> request::UpdateEnvironmentVariablesRequest {
170 request::UpdateEnvironmentVariablesRequest {
171 http_client: &self,
172 body,
173 service_id: service_id.to_owned(),
174 }
175 }
176 pub fn retrieve_headers(&self, service_id: &str) -> request::RetrieveHeadersRequest {
180 request::RetrieveHeadersRequest {
181 http_client: &self,
182 cursor: None,
183 limit: None,
184 name: None,
185 path: None,
186 service_id: service_id.to_owned(),
187 value: None,
188 }
189 }
190 pub fn retrieve_redirect_and_rewrite_rules(
194 &self,
195 service_id: &str,
196 ) -> request::RetrieveRedirectAndRewriteRulesRequest {
197 request::RetrieveRedirectAndRewriteRulesRequest {
198 http_client: &self,
199 cursor: None,
200 destination: None,
201 limit: None,
202 service_id: service_id.to_owned(),
203 source: None,
204 type_: None,
205 }
206 }
207 pub fn suspend_service(&self, service_id: &str) -> request::SuspendServiceRequest {
211 request::SuspendServiceRequest {
212 http_client: &self,
213 service_id: service_id.to_owned(),
214 }
215 }
216 pub fn resume_service(&self, service_id: &str) -> request::ResumeServiceRequest {
220 request::ResumeServiceRequest {
221 http_client: &self,
222 service_id: service_id.to_owned(),
223 }
224 }
225 pub fn scale_service_to_desired_number_of_instances(
229 &self,
230 service_id: &str,
231 ) -> request::ScaleServiceToDesiredNumberOfInstancesRequest {
232 request::ScaleServiceToDesiredNumberOfInstancesRequest {
233 http_client: &self,
234 num_instances: None,
235 service_id: service_id.to_owned(),
236 }
237 }
238 pub fn list_deploys(&self, service_id: &str) -> request::ListDeploysRequest {
242 request::ListDeploysRequest {
243 http_client: &self,
244 cursor: None,
245 end_time: None,
246 limit: None,
247 service_id: service_id.to_owned(),
248 start_time: None,
249 }
250 }
251 pub fn trigger_deploy(&self, service_id: &str) -> request::TriggerDeployRequest {
255 request::TriggerDeployRequest {
256 http_client: &self,
257 clear_cache: None,
258 service_id: service_id.to_owned(),
259 }
260 }
261 pub fn retrieve_deploy(
265 &self,
266 deploy_id: &str,
267 service_id: &str,
268 ) -> request::RetrieveDeployRequest {
269 request::RetrieveDeployRequest {
270 http_client: &self,
271 deploy_id: deploy_id.to_owned(),
272 service_id: service_id.to_owned(),
273 }
274 }
275 pub fn list_custom_domains(
279 &self,
280 service_id: &str,
281 ) -> request::ListCustomDomainsRequest {
282 request::ListCustomDomainsRequest {
283 http_client: &self,
284 created_after: None,
285 created_before: None,
286 cursor: None,
287 domain_type: None,
288 limit: None,
289 name: None,
290 service_id: service_id.to_owned(),
291 verification_status: None,
292 }
293 }
294 pub fn add_custom_domain(
298 &self,
299 service_id: &str,
300 ) -> request::AddCustomDomainRequest {
301 request::AddCustomDomainRequest {
302 http_client: &self,
303 name: None,
304 service_id: service_id.to_owned(),
305 }
306 }
307 pub fn retrieve_custom_domain(
311 &self,
312 custom_domain_id_or_name: &str,
313 service_id: &str,
314 ) -> request::RetrieveCustomDomainRequest {
315 request::RetrieveCustomDomainRequest {
316 http_client: &self,
317 custom_domain_id_or_name: custom_domain_id_or_name.to_owned(),
318 service_id: service_id.to_owned(),
319 }
320 }
321 pub fn delete_custom_domain(
325 &self,
326 custom_domain_id_or_name: &str,
327 service_id: &str,
328 ) -> request::DeleteCustomDomainRequest {
329 request::DeleteCustomDomainRequest {
330 http_client: &self,
331 custom_domain_id_or_name: custom_domain_id_or_name.to_owned(),
332 service_id: service_id.to_owned(),
333 }
334 }
335 pub fn verify_dns_configuration(
339 &self,
340 custom_domain_id_or_name: &str,
341 service_id: &str,
342 ) -> request::VerifyDnsConfigurationRequest {
343 request::VerifyDnsConfigurationRequest {
344 http_client: &self,
345 custom_domain_id_or_name: custom_domain_id_or_name.to_owned(),
346 service_id: service_id.to_owned(),
347 }
348 }
349 pub fn list_jobs(&self, service_id: &str) -> request::ListJobsRequest {
353 request::ListJobsRequest {
354 http_client: &self,
355 created_after: None,
356 created_before: None,
357 cursor: None,
358 finished_after: None,
359 finished_before: None,
360 limit: None,
361 service_id: service_id.to_owned(),
362 started_after: None,
363 started_before: None,
364 status: None,
365 }
366 }
367 pub fn create_job(&self, service_id: &str) -> request::CreateJobRequest {
371 request::CreateJobRequest {
372 http_client: &self,
373 plan_id: None,
374 service_id: service_id.to_owned(),
375 start_command: None,
376 }
377 }
378 pub fn retrieve_job(
382 &self,
383 job_id: &str,
384 service_id: &str,
385 ) -> request::RetrieveJobRequest {
386 request::RetrieveJobRequest {
387 http_client: &self,
388 job_id: job_id.to_owned(),
389 service_id: service_id.to_owned(),
390 }
391 }
392 pub fn list_env_groups(&self) -> request::ListEnvGroupsRequest {
396 request::ListEnvGroupsRequest {
397 http_client: &self,
398 }
399 }
400 pub fn retrieve_env_group(
404 &self,
405 env_group_id: &str,
406 ) -> request::RetrieveEnvGroupRequest {
407 request::RetrieveEnvGroupRequest {
408 http_client: &self,
409 env_group_id: env_group_id.to_owned(),
410 }
411 }
412}
413pub enum RenderAuthentication {
414 ApiKeyAuth { api_key_auth: String },
415}
416impl RenderAuthentication {
417 pub fn from_env() -> Self {
418 Self::ApiKeyAuth {
419 api_key_auth: std::env::var("RENDER_API_KEY_AUTH")
420 .expect("Environment variable RENDER_API_KEY_AUTH is not set."),
421 }
422 }
423}