onesignal_rust_api/apis/
default_api.rs

1/*
2 * OneSignal
3 *
4 * A powerful way to send personalized messages at scale and build effective customer engagement strategies. Learn more at onesignal.com
5 *
6 * Contact: devrel@onesignal.com
7 * Generated by: https://openapi-generator.tech
8 */
9
10
11use reqwest;
12
13use crate::apis::ResponseContent;
14use super::{Error, configuration};
15
16
17/// struct for typed errors of method [`cancel_notification`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum CancelNotificationError {
21    Status400(crate::models::GenericError),
22    Status404(crate::models::GenericError),
23    Status429(crate::models::RateLimitError),
24    DefaultResponse(crate::models::GenericError),
25    UnknownValue(serde_json::Value),
26}
27
28/// struct for typed errors of method [`copy_template_to_app`]
29#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum CopyTemplateToAppError {
32    Status400(crate::models::GenericError),
33    DefaultResponse(crate::models::GenericError),
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`create_alias`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum CreateAliasError {
41    Status400(crate::models::GenericError),
42    Status404(crate::models::GenericError),
43    Status409(crate::models::GenericError),
44    Status429(crate::models::RateLimitError),
45    DefaultResponse(crate::models::GenericError),
46    UnknownValue(serde_json::Value),
47}
48
49/// struct for typed errors of method [`create_alias_by_subscription`]
50#[derive(Debug, Clone, Serialize, Deserialize)]
51#[serde(untagged)]
52pub enum CreateAliasBySubscriptionError {
53    Status400(crate::models::GenericError),
54    Status404(crate::models::GenericError),
55    Status409(crate::models::GenericError),
56    Status429(crate::models::RateLimitError),
57    DefaultResponse(crate::models::GenericError),
58    UnknownValue(serde_json::Value),
59}
60
61/// struct for typed errors of method [`create_api_key`]
62#[derive(Debug, Clone, Serialize, Deserialize)]
63#[serde(untagged)]
64pub enum CreateApiKeyError {
65    Status400(crate::models::GenericError),
66    DefaultResponse(crate::models::GenericError),
67    UnknownValue(serde_json::Value),
68}
69
70/// struct for typed errors of method [`create_app`]
71#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum CreateAppError {
74    Status400(crate::models::GenericError),
75    Status429(crate::models::RateLimitError),
76    DefaultResponse(crate::models::GenericError),
77    UnknownValue(serde_json::Value),
78}
79
80/// struct for typed errors of method [`create_custom_events`]
81#[derive(Debug, Clone, Serialize, Deserialize)]
82#[serde(untagged)]
83pub enum CreateCustomEventsError {
84    Status400(crate::models::GenericError),
85    Status401(crate::models::GenericError),
86    Status429(crate::models::RateLimitError),
87    DefaultResponse(crate::models::GenericError),
88    UnknownValue(serde_json::Value),
89}
90
91/// struct for typed errors of method [`create_journey`]
92#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum CreateJourneyError {
95    Status400(crate::models::GenericError),
96    Status403(crate::models::GenericError),
97    Status429(crate::models::RateLimitError),
98    DefaultResponse(crate::models::GenericError),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`create_notification`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum CreateNotificationError {
106    Status400(crate::models::GenericError),
107    Status429(crate::models::RateLimitError),
108    DefaultResponse(crate::models::GenericError),
109    UnknownValue(serde_json::Value),
110}
111
112/// struct for typed errors of method [`create_segment`]
113#[derive(Debug, Clone, Serialize, Deserialize)]
114#[serde(untagged)]
115pub enum CreateSegmentError {
116    Status400(crate::models::GenericError),
117    Status409(crate::models::CreateSegmentConflictResponse),
118    Status429(crate::models::RateLimitError),
119    DefaultResponse(crate::models::GenericError),
120    UnknownValue(serde_json::Value),
121}
122
123/// struct for typed errors of method [`create_subscription`]
124#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum CreateSubscriptionError {
127    Status400(crate::models::GenericError),
128    Status404(crate::models::GenericError),
129    Status409(crate::models::GenericError),
130    Status429(crate::models::RateLimitError),
131    DefaultResponse(crate::models::GenericError),
132    UnknownValue(serde_json::Value),
133}
134
135/// struct for typed errors of method [`create_template`]
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum CreateTemplateError {
139    Status400(crate::models::GenericError),
140    Status422(crate::models::GenericError),
141    DefaultResponse(crate::models::GenericError),
142    UnknownValue(serde_json::Value),
143}
144
145/// struct for typed errors of method [`create_user`]
146#[derive(Debug, Clone, Serialize, Deserialize)]
147#[serde(untagged)]
148pub enum CreateUserError {
149    Status400(crate::models::GenericError),
150    Status409(crate::models::CreateUserConflictResponse),
151    Status429(crate::models::RateLimitError),
152    DefaultResponse(crate::models::GenericError),
153    UnknownValue(serde_json::Value),
154}
155
156/// struct for typed errors of method [`delete_alias`]
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(untagged)]
159pub enum DeleteAliasError {
160    Status400(crate::models::GenericError),
161    Status404(crate::models::GenericError),
162    Status409(crate::models::GenericError),
163    Status429(crate::models::RateLimitError),
164    DefaultResponse(crate::models::GenericError),
165    UnknownValue(serde_json::Value),
166}
167
168/// struct for typed errors of method [`delete_api_key`]
169#[derive(Debug, Clone, Serialize, Deserialize)]
170#[serde(untagged)]
171pub enum DeleteApiKeyError {
172    Status400(crate::models::GenericError),
173    DefaultResponse(crate::models::GenericError),
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed errors of method [`delete_journey`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum DeleteJourneyError {
181    Status403(crate::models::GenericError),
182    Status404(crate::models::GenericError),
183    Status429(crate::models::RateLimitError),
184    DefaultResponse(crate::models::GenericError),
185    UnknownValue(serde_json::Value),
186}
187
188/// struct for typed errors of method [`delete_segment`]
189#[derive(Debug, Clone, Serialize, Deserialize)]
190#[serde(untagged)]
191pub enum DeleteSegmentError {
192    Status400(crate::models::GenericError),
193    Status404(crate::models::GenericSuccessBoolResponse),
194    Status429(crate::models::RateLimitError),
195    DefaultResponse(crate::models::GenericError),
196    UnknownValue(serde_json::Value),
197}
198
199/// struct for typed errors of method [`delete_subscription`]
200#[derive(Debug, Clone, Serialize, Deserialize)]
201#[serde(untagged)]
202pub enum DeleteSubscriptionError {
203    Status400(crate::models::GenericError),
204    Status404(crate::models::GenericError),
205    Status409(crate::models::GenericError),
206    Status429(crate::models::RateLimitError),
207    DefaultResponse(crate::models::GenericError),
208    UnknownValue(serde_json::Value),
209}
210
211/// struct for typed errors of method [`delete_template`]
212#[derive(Debug, Clone, Serialize, Deserialize)]
213#[serde(untagged)]
214pub enum DeleteTemplateError {
215    Status400(crate::models::GenericError),
216    Status404(crate::models::GenericError),
217    DefaultResponse(crate::models::GenericError),
218    UnknownValue(serde_json::Value),
219}
220
221/// struct for typed errors of method [`delete_user`]
222#[derive(Debug, Clone, Serialize, Deserialize)]
223#[serde(untagged)]
224pub enum DeleteUserError {
225    Status400(crate::models::GenericError),
226    Status409(crate::models::GenericError),
227    Status429(crate::models::RateLimitError),
228    DefaultResponse(crate::models::GenericError),
229    UnknownValue(serde_json::Value),
230}
231
232/// struct for typed errors of method [`export_events`]
233#[derive(Debug, Clone, Serialize, Deserialize)]
234#[serde(untagged)]
235pub enum ExportEventsError {
236    Status400(crate::models::GenericError),
237    Status404(crate::models::GenericError),
238    Status429(crate::models::RateLimitError),
239    DefaultResponse(crate::models::GenericError),
240    UnknownValue(serde_json::Value),
241}
242
243/// struct for typed errors of method [`export_subscriptions`]
244#[derive(Debug, Clone, Serialize, Deserialize)]
245#[serde(untagged)]
246pub enum ExportSubscriptionsError {
247    Status400(crate::models::GenericError),
248    Status429(crate::models::RateLimitError),
249    DefaultResponse(crate::models::GenericError),
250    UnknownValue(serde_json::Value),
251}
252
253/// struct for typed errors of method [`get_aliases`]
254#[derive(Debug, Clone, Serialize, Deserialize)]
255#[serde(untagged)]
256pub enum GetAliasesError {
257    Status400(crate::models::GenericError),
258    Status404(crate::models::GenericError),
259    Status429(crate::models::RateLimitError),
260    DefaultResponse(crate::models::GenericError),
261    UnknownValue(serde_json::Value),
262}
263
264/// struct for typed errors of method [`get_aliases_by_subscription`]
265#[derive(Debug, Clone, Serialize, Deserialize)]
266#[serde(untagged)]
267pub enum GetAliasesBySubscriptionError {
268    Status400(crate::models::GenericError),
269    Status404(crate::models::GenericError),
270    DefaultResponse(crate::models::GenericError),
271    UnknownValue(serde_json::Value),
272}
273
274/// struct for typed errors of method [`get_app`]
275#[derive(Debug, Clone, Serialize, Deserialize)]
276#[serde(untagged)]
277pub enum GetAppError {
278    Status400(crate::models::GenericError),
279    Status429(crate::models::RateLimitError),
280    DefaultResponse(crate::models::GenericError),
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`get_apps`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum GetAppsError {
288    Status400(crate::models::GenericError),
289    Status429(crate::models::RateLimitError),
290    DefaultResponse(crate::models::GenericError),
291    UnknownValue(serde_json::Value),
292}
293
294/// struct for typed errors of method [`get_notification`]
295#[derive(Debug, Clone, Serialize, Deserialize)]
296#[serde(untagged)]
297pub enum GetNotificationError {
298    Status400(crate::models::GenericError),
299    Status404(crate::models::GenericError),
300    Status429(crate::models::RateLimitError),
301    DefaultResponse(crate::models::GenericError),
302    UnknownValue(serde_json::Value),
303}
304
305/// struct for typed errors of method [`get_notification_history`]
306#[derive(Debug, Clone, Serialize, Deserialize)]
307#[serde(untagged)]
308pub enum GetNotificationHistoryError {
309    Status400(crate::models::GenericError),
310    Status404(crate::models::GenericError),
311    Status429(crate::models::RateLimitError),
312    DefaultResponse(crate::models::GenericError),
313    UnknownValue(serde_json::Value),
314}
315
316/// struct for typed errors of method [`get_notifications`]
317#[derive(Debug, Clone, Serialize, Deserialize)]
318#[serde(untagged)]
319pub enum GetNotificationsError {
320    Status400(crate::models::GenericError),
321    Status429(crate::models::RateLimitError),
322    DefaultResponse(crate::models::GenericError),
323    UnknownValue(serde_json::Value),
324}
325
326/// struct for typed errors of method [`get_outcomes`]
327#[derive(Debug, Clone, Serialize, Deserialize)]
328#[serde(untagged)]
329pub enum GetOutcomesError {
330    Status400(crate::models::GenericError),
331    Status429(crate::models::RateLimitError),
332    DefaultResponse(crate::models::GenericError),
333    UnknownValue(serde_json::Value),
334}
335
336/// struct for typed errors of method [`get_segment`]
337#[derive(Debug, Clone, Serialize, Deserialize)]
338#[serde(untagged)]
339pub enum GetSegmentError {
340    Status400(crate::models::GenericError),
341    Status404(crate::models::GenericError),
342    Status429(crate::models::RateLimitError),
343    DefaultResponse(crate::models::GenericError),
344    UnknownValue(serde_json::Value),
345}
346
347/// struct for typed errors of method [`get_segments`]
348#[derive(Debug, Clone, Serialize, Deserialize)]
349#[serde(untagged)]
350pub enum GetSegmentsError {
351    Status400(crate::models::GenericError),
352    Status429(crate::models::RateLimitError),
353    DefaultResponse(crate::models::GenericError),
354    UnknownValue(serde_json::Value),
355}
356
357/// struct for typed errors of method [`get_user`]
358#[derive(Debug, Clone, Serialize, Deserialize)]
359#[serde(untagged)]
360pub enum GetUserError {
361    Status400(crate::models::GenericError),
362    Status404(crate::models::GenericError),
363    Status429(crate::models::RateLimitError),
364    DefaultResponse(crate::models::GenericError),
365    UnknownValue(serde_json::Value),
366}
367
368/// struct for typed errors of method [`list_audit_logs`]
369#[derive(Debug, Clone, Serialize, Deserialize)]
370#[serde(untagged)]
371pub enum ListAuditLogsError {
372    Status400(crate::models::GenericError),
373    Status403(crate::models::GenericError),
374    Status404(crate::models::GenericError),
375    Status429(crate::models::RateLimitError),
376    DefaultResponse(crate::models::GenericError),
377    UnknownValue(serde_json::Value),
378}
379
380/// struct for typed errors of method [`rotate_api_key`]
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(untagged)]
383pub enum RotateApiKeyError {
384    Status400(crate::models::GenericError),
385    DefaultResponse(crate::models::GenericError),
386    UnknownValue(serde_json::Value),
387}
388
389/// struct for typed errors of method [`start_live_activity`]
390#[derive(Debug, Clone, Serialize, Deserialize)]
391#[serde(untagged)]
392pub enum StartLiveActivityError {
393    Status400(crate::models::GenericError),
394    Status429(crate::models::RateLimitError),
395    DefaultResponse(crate::models::GenericError),
396    UnknownValue(serde_json::Value),
397}
398
399/// struct for typed errors of method [`transfer_subscription`]
400#[derive(Debug, Clone, Serialize, Deserialize)]
401#[serde(untagged)]
402pub enum TransferSubscriptionError {
403    Status400(crate::models::GenericError),
404    Status404(crate::models::GenericError),
405    Status409(crate::models::GenericError),
406    Status429(crate::models::RateLimitError),
407    DefaultResponse(crate::models::GenericError),
408    UnknownValue(serde_json::Value),
409}
410
411/// struct for typed errors of method [`unsubscribe_email_with_token`]
412#[derive(Debug, Clone, Serialize, Deserialize)]
413#[serde(untagged)]
414pub enum UnsubscribeEmailWithTokenError {
415    Status400(crate::models::GenericError),
416    Status429(crate::models::RateLimitError),
417    DefaultResponse(crate::models::GenericError),
418    UnknownValue(serde_json::Value),
419}
420
421/// struct for typed errors of method [`update_api_key`]
422#[derive(Debug, Clone, Serialize, Deserialize)]
423#[serde(untagged)]
424pub enum UpdateApiKeyError {
425    Status400(crate::models::GenericError),
426    DefaultResponse(crate::models::GenericError),
427    UnknownValue(serde_json::Value),
428}
429
430/// struct for typed errors of method [`update_app`]
431#[derive(Debug, Clone, Serialize, Deserialize)]
432#[serde(untagged)]
433pub enum UpdateAppError {
434    Status400(crate::models::GenericError),
435    Status429(crate::models::RateLimitError),
436    DefaultResponse(crate::models::GenericError),
437    UnknownValue(serde_json::Value),
438}
439
440/// struct for typed errors of method [`update_journey`]
441#[derive(Debug, Clone, Serialize, Deserialize)]
442#[serde(untagged)]
443pub enum UpdateJourneyError {
444    Status400(crate::models::GenericError),
445    Status403(crate::models::GenericError),
446    Status404(crate::models::GenericError),
447    Status409(crate::models::GenericError),
448    Status422(crate::models::GenericError),
449    Status429(crate::models::RateLimitError),
450    DefaultResponse(crate::models::GenericError),
451    UnknownValue(serde_json::Value),
452}
453
454/// struct for typed errors of method [`update_journey_node`]
455#[derive(Debug, Clone, Serialize, Deserialize)]
456#[serde(untagged)]
457pub enum UpdateJourneyNodeError {
458    Status400(crate::models::GenericError),
459    Status403(crate::models::GenericError),
460    Status404(crate::models::GenericError),
461    Status409(crate::models::GenericError),
462    Status422(crate::models::GenericError),
463    Status429(crate::models::RateLimitError),
464    DefaultResponse(crate::models::GenericError),
465    UnknownValue(serde_json::Value),
466}
467
468/// struct for typed errors of method [`update_live_activity`]
469#[derive(Debug, Clone, Serialize, Deserialize)]
470#[serde(untagged)]
471pub enum UpdateLiveActivityError {
472    Status400(crate::models::GenericError),
473    Status429(crate::models::RateLimitError),
474    DefaultResponse(crate::models::GenericError),
475    UnknownValue(serde_json::Value),
476}
477
478/// struct for typed errors of method [`update_segment`]
479#[derive(Debug, Clone, Serialize, Deserialize)]
480#[serde(untagged)]
481pub enum UpdateSegmentError {
482    Status400(crate::models::GenericError),
483    Status403(crate::models::GenericError),
484    Status404(crate::models::GenericError),
485    Status429(crate::models::RateLimitError),
486    DefaultResponse(crate::models::GenericError),
487    UnknownValue(serde_json::Value),
488}
489
490/// struct for typed errors of method [`update_subscription`]
491#[derive(Debug, Clone, Serialize, Deserialize)]
492#[serde(untagged)]
493pub enum UpdateSubscriptionError {
494    Status400(crate::models::GenericError),
495    Status404(crate::models::GenericError),
496    Status409(crate::models::GenericError),
497    Status429(crate::models::RateLimitError),
498    DefaultResponse(crate::models::GenericError),
499    UnknownValue(serde_json::Value),
500}
501
502/// struct for typed errors of method [`update_subscription_by_token`]
503#[derive(Debug, Clone, Serialize, Deserialize)]
504#[serde(untagged)]
505pub enum UpdateSubscriptionByTokenError {
506    Status400(crate::models::GenericError),
507    Status404(crate::models::GenericError),
508    DefaultResponse(crate::models::GenericError),
509    UnknownValue(serde_json::Value),
510}
511
512/// struct for typed errors of method [`update_template`]
513#[derive(Debug, Clone, Serialize, Deserialize)]
514#[serde(untagged)]
515pub enum UpdateTemplateError {
516    Status400(crate::models::GenericError),
517    DefaultResponse(crate::models::GenericError),
518    UnknownValue(serde_json::Value),
519}
520
521/// struct for typed errors of method [`update_user`]
522#[derive(Debug, Clone, Serialize, Deserialize)]
523#[serde(untagged)]
524pub enum UpdateUserError {
525    Status400(crate::models::GenericError),
526    Status409(crate::models::GenericError),
527    Status429(crate::models::RateLimitError),
528    DefaultResponse(crate::models::GenericError),
529    UnknownValue(serde_json::Value),
530}
531
532/// struct for typed errors of method [`view_api_keys`]
533#[derive(Debug, Clone, Serialize, Deserialize)]
534#[serde(untagged)]
535pub enum ViewApiKeysError {
536    Status400(crate::models::GenericError),
537    DefaultResponse(crate::models::GenericError),
538    UnknownValue(serde_json::Value),
539}
540
541/// struct for typed errors of method [`view_journey`]
542#[derive(Debug, Clone, Serialize, Deserialize)]
543#[serde(untagged)]
544pub enum ViewJourneyError {
545    Status404(crate::models::GenericError),
546    Status429(crate::models::RateLimitError),
547    DefaultResponse(crate::models::GenericError),
548    UnknownValue(serde_json::Value),
549}
550
551/// struct for typed errors of method [`view_journey_stats`]
552#[derive(Debug, Clone, Serialize, Deserialize)]
553#[serde(untagged)]
554pub enum ViewJourneyStatsError {
555    Status404(crate::models::GenericError),
556    Status429(crate::models::RateLimitError),
557    DefaultResponse(crate::models::GenericError),
558    UnknownValue(serde_json::Value),
559}
560
561/// struct for typed errors of method [`view_journeys`]
562#[derive(Debug, Clone, Serialize, Deserialize)]
563#[serde(untagged)]
564pub enum ViewJourneysError {
565    Status400(crate::models::GenericError),
566    Status403(crate::models::GenericError),
567    Status429(crate::models::RateLimitError),
568    DefaultResponse(crate::models::GenericError),
569    UnknownValue(serde_json::Value),
570}
571
572/// struct for typed errors of method [`view_template`]
573#[derive(Debug, Clone, Serialize, Deserialize)]
574#[serde(untagged)]
575pub enum ViewTemplateError {
576    Status400(crate::models::GenericError),
577    Status404(crate::models::GenericError),
578    DefaultResponse(crate::models::GenericError),
579    UnknownValue(serde_json::Value),
580}
581
582/// struct for typed errors of method [`view_templates`]
583#[derive(Debug, Clone, Serialize, Deserialize)]
584#[serde(untagged)]
585pub enum ViewTemplatesError {
586    Status400(crate::models::GenericError),
587    Status429(crate::models::RateLimitError),
588    DefaultResponse(crate::models::GenericError),
589    UnknownValue(serde_json::Value),
590}
591
592
593/// Used to stop a scheduled or currently outgoing notification
594pub async fn cancel_notification(configuration: &configuration::Configuration, app_id: &str, notification_id: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<CancelNotificationError>> {
595    let configuration = configuration;
596
597    let client = &configuration.client;
598
599    let uri_str = format!("{}/notifications/{notification_id}", configuration.base_path, notification_id=crate::apis::urlencode(notification_id));
600    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
601
602    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
603    if let Some(ref user_agent) = configuration.user_agent {
604        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
605    }
606
607    // Adds a telemetry header
608    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
609
610    if let Some(ref token) = configuration.rest_api_key_token {
611        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
612    }
613
614    let req = req_builder.build()?;
615    let resp = client.execute(req).await?;
616
617    let status = resp.status();
618    let content = resp.text().await?;
619
620    if !status.is_client_error() && !status.is_server_error() {
621        serde_json::from_str(&content).map_err(Error::from)
622    } else {
623        let entity: Option<CancelNotificationError> = serde_json::from_str(&content).ok();
624        let error = ResponseContent { status: status, content: content, entity: entity };
625        Err(Error::ResponseError(error))
626    }
627}
628
629/// Copy a template to a destination app.
630pub async fn copy_template_to_app(configuration: &configuration::Configuration, template_id: &str, app_id: &str, copy_template_request: crate::models::CopyTemplateRequest) -> Result<crate::models::TemplateResource, Error<CopyTemplateToAppError>> {
631    let configuration = configuration;
632
633    let client = &configuration.client;
634
635    let uri_str = format!("{}/templates/{template_id}/copy_to_app", configuration.base_path, template_id=crate::apis::urlencode(template_id));
636    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
637
638    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
639    if let Some(ref user_agent) = configuration.user_agent {
640        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
641    }
642
643    // Adds a telemetry header
644    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
645
646    if let Some(ref token) = configuration.organization_api_key_token {
647        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
648    }
649    req_builder = req_builder.json(&copy_template_request);
650
651    let req = req_builder.build()?;
652    let resp = client.execute(req).await?;
653
654    let status = resp.status();
655    let content = resp.text().await?;
656
657    if !status.is_client_error() && !status.is_server_error() {
658        serde_json::from_str(&content).map_err(Error::from)
659    } else {
660        let entity: Option<CopyTemplateToAppError> = serde_json::from_str(&content).ok();
661        let error = ResponseContent { status: status, content: content, entity: entity };
662        Err(Error::ResponseError(error))
663    }
664}
665
666/// Upserts one or more Aliases to an existing User identified by (:alias_label, :alias_id).
667pub async fn create_alias(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str, user_identity_body: crate::models::UserIdentityBody) -> Result<crate::models::UserIdentityBody, Error<CreateAliasError>> {
668    let configuration = configuration;
669
670    let client = &configuration.client;
671
672    let uri_str = format!("{}/apps/{app_id}/users/by/{alias_label}/{alias_id}/identity", configuration.base_path, app_id=crate::apis::urlencode(app_id), alias_label=crate::apis::urlencode(alias_label), alias_id=crate::apis::urlencode(alias_id));
673    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
674
675    if let Some(ref user_agent) = configuration.user_agent {
676        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
677    }
678
679    // Adds a telemetry header
680    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
681
682    if let Some(ref token) = configuration.rest_api_key_token {
683        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
684    }
685    req_builder = req_builder.json(&user_identity_body);
686
687    let req = req_builder.build()?;
688    let resp = client.execute(req).await?;
689
690    let status = resp.status();
691    let content = resp.text().await?;
692
693    if !status.is_client_error() && !status.is_server_error() {
694        serde_json::from_str(&content).map_err(Error::from)
695    } else {
696        let entity: Option<CreateAliasError> = serde_json::from_str(&content).ok();
697        let error = ResponseContent { status: status, content: content, entity: entity };
698        Err(Error::ResponseError(error))
699    }
700}
701
702/// Upserts one or more Aliases for the User identified by :subscription_id.
703pub async fn create_alias_by_subscription(configuration: &configuration::Configuration, app_id: &str, subscription_id: &str, user_identity_body: crate::models::UserIdentityBody) -> Result<crate::models::UserIdentityBody, Error<CreateAliasBySubscriptionError>> {
704    let configuration = configuration;
705
706    let client = &configuration.client;
707
708    let uri_str = format!("{}/apps/{app_id}/subscriptions/{subscription_id}/user/identity", configuration.base_path, app_id=crate::apis::urlencode(app_id), subscription_id=crate::apis::urlencode(subscription_id));
709    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
710
711    if let Some(ref user_agent) = configuration.user_agent {
712        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
713    }
714
715    // Adds a telemetry header
716    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
717
718    if let Some(ref token) = configuration.rest_api_key_token {
719        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
720    }
721    req_builder = req_builder.json(&user_identity_body);
722
723    let req = req_builder.build()?;
724    let resp = client.execute(req).await?;
725
726    let status = resp.status();
727    let content = resp.text().await?;
728
729    if !status.is_client_error() && !status.is_server_error() {
730        serde_json::from_str(&content).map_err(Error::from)
731    } else {
732        let entity: Option<CreateAliasBySubscriptionError> = serde_json::from_str(&content).ok();
733        let error = ResponseContent { status: status, content: content, entity: entity };
734        Err(Error::ResponseError(error))
735    }
736}
737
738/// Use this API to create a new App API Key (also called a Rich Authentication Token) for a specific OneSignal app. These keys are used to authenticate API requests at the app level and offer enhanced security features, including optional IP allowlisting.
739pub async fn create_api_key(configuration: &configuration::Configuration, app_id: &str, create_api_key_request: crate::models::CreateApiKeyRequest) -> Result<crate::models::CreateApiKeyResponse, Error<CreateApiKeyError>> {
740    let configuration = configuration;
741
742    let client = &configuration.client;
743
744    let uri_str = format!("{}/apps/{app_id}/auth/tokens", configuration.base_path, app_id=crate::apis::urlencode(app_id));
745    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
746
747    if let Some(ref user_agent) = configuration.user_agent {
748        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
749    }
750
751    // Adds a telemetry header
752    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
753
754    if let Some(ref token) = configuration.organization_api_key_token {
755        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
756    }
757    req_builder = req_builder.json(&create_api_key_request);
758
759    let req = req_builder.build()?;
760    let resp = client.execute(req).await?;
761
762    let status = resp.status();
763    let content = resp.text().await?;
764
765    if !status.is_client_error() && !status.is_server_error() {
766        serde_json::from_str(&content).map_err(Error::from)
767    } else {
768        let entity: Option<CreateApiKeyError> = serde_json::from_str(&content).ok();
769        let error = ResponseContent { status: status, content: content, entity: entity };
770        Err(Error::ResponseError(error))
771    }
772}
773
774/// Creates a new OneSignal app
775pub async fn create_app(configuration: &configuration::Configuration, app: crate::models::App) -> Result<crate::models::App, Error<CreateAppError>> {
776    let configuration = configuration;
777
778    let client = &configuration.client;
779
780    let uri_str = format!("{}/apps", configuration.base_path);
781    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
782
783    if let Some(ref user_agent) = configuration.user_agent {
784        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
785    }
786
787    // Adds a telemetry header
788    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
789
790    if let Some(ref token) = configuration.organization_api_key_token {
791        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
792    }
793    req_builder = req_builder.json(&app);
794
795    let req = req_builder.build()?;
796    let resp = client.execute(req).await?;
797
798    let status = resp.status();
799    let content = resp.text().await?;
800
801    if !status.is_client_error() && !status.is_server_error() {
802        serde_json::from_str(&content).map_err(Error::from)
803    } else {
804        let entity: Option<CreateAppError> = serde_json::from_str(&content).ok();
805        let error = ResponseContent { status: status, content: content, entity: entity };
806        Err(Error::ResponseError(error))
807    }
808}
809
810/// The Custom Events API allows you to record user events. Custom events can represent any action users take in your application, such as completing a purchase, viewing content, or achieving milestones.
811pub async fn create_custom_events(configuration: &configuration::Configuration, app_id: &str, custom_events_request: crate::models::CustomEventsRequest) -> Result<serde_json::Value, Error<CreateCustomEventsError>> {
812    let configuration = configuration;
813
814    let client = &configuration.client;
815
816    let uri_str = format!("{}/apps/{app_id}/custom_events", configuration.base_path, app_id=crate::apis::urlencode(app_id));
817    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
818
819    if let Some(ref user_agent) = configuration.user_agent {
820        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
821    }
822
823    // Adds a telemetry header
824    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
825
826    if let Some(ref token) = configuration.rest_api_key_token {
827        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
828    }
829    req_builder = req_builder.json(&custom_events_request);
830
831    let req = req_builder.build()?;
832    let resp = client.execute(req).await?;
833
834    let status = resp.status();
835    let content = resp.text().await?;
836
837    if !status.is_client_error() && !status.is_server_error() {
838        serde_json::from_str(&content).map_err(Error::from)
839    } else {
840        let entity: Option<CreateCustomEventsError> = serde_json::from_str(&content).ok();
841        let error = ResponseContent { status: status, content: content, entity: entity };
842        Err(Error::ResponseError(error))
843    }
844}
845
846/// The Journeys API is in beta. Endpoints and response fields can still change. Create a new journey with an audience and a node graph. Journeys are always created in the draft state. The authenticated App API key must have permission to create journeys.
847pub async fn create_journey(configuration: &configuration::Configuration, app_id: &str, create_journey_request: crate::models::CreateJourneyRequest) -> Result<crate::models::Journey, Error<CreateJourneyError>> {
848    let configuration = configuration;
849
850    let client = &configuration.client;
851
852    let uri_str = format!("{}/apps/{app_id}/journeys", configuration.base_path, app_id=crate::apis::urlencode(app_id));
853    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
854
855    if let Some(ref user_agent) = configuration.user_agent {
856        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
857    }
858
859    // Adds a telemetry header
860    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
861
862    if let Some(ref token) = configuration.rest_api_key_token {
863        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
864    }
865    req_builder = req_builder.json(&create_journey_request);
866
867    let req = req_builder.build()?;
868    let resp = client.execute(req).await?;
869
870    let status = resp.status();
871    let content = resp.text().await?;
872
873    if !status.is_client_error() && !status.is_server_error() {
874        serde_json::from_str(&content).map_err(Error::from)
875    } else {
876        let entity: Option<CreateJourneyError> = serde_json::from_str(&content).ok();
877        let error = ResponseContent { status: status, content: content, entity: entity };
878        Err(Error::ResponseError(error))
879    }
880}
881
882/// Sends notifications to your users.  **Target by External ID (push example):** set `include_aliases` to `{ \"external_id\": [\"your-user-id\"] }` and set `target_channel` to `push` (or `email` / `sms` for those channels). Alias object keys must match API labels exactly (for example `external_id`, not camelCase).  **Do not confuse** the notification-level `external_id` field with External ID targeting: top-level `external_id` / `idempotency_key` are for idempotent notification requests only, not for selecting recipients.  **Targeting compatibility:** `include_aliases` must not be combined with other targeting modes (segments, filters, subscription IDs, legacy player IDs, etc.). Clients should send only one targeting strategy per request. 
883pub async fn create_notification(configuration: &configuration::Configuration, notification: crate::models::Notification) -> Result<crate::models::CreateNotificationSuccessResponse, Error<CreateNotificationError>> {
884    let configuration = configuration;
885
886    let client = &configuration.client;
887
888    let uri_str = format!("{}/notifications", configuration.base_path);
889    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
890
891    if let Some(ref user_agent) = configuration.user_agent {
892        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
893    }
894
895    // Adds a telemetry header
896    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
897
898    if let Some(ref token) = configuration.rest_api_key_token {
899        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
900    }
901    req_builder = req_builder.json(&notification);
902
903    let req = req_builder.build()?;
904    let resp = client.execute(req).await?;
905
906    let status = resp.status();
907    let content = resp.text().await?;
908
909    if !status.is_client_error() && !status.is_server_error() {
910        serde_json::from_str(&content).map_err(Error::from)
911    } else {
912        let entity: Option<CreateNotificationError> = serde_json::from_str(&content).ok();
913        let error = ResponseContent { status: status, content: content, entity: entity };
914        Err(Error::ResponseError(error))
915    }
916}
917
918/// Create a segment visible and usable in the dashboard and API - Required: OneSignal Paid Plan The Create Segment method is used when you want your server to programmatically create a segment instead of using the OneSignal Dashboard UI. Just like creating Segments from the dashboard you can pass in filters with multiple \"AND\" or \"OR\" operator's. &#x1F6A7; Does Not Update Segments This endpoint will only create segments, it does not edit or update currently created Segments. You will need to use the Delete Segment endpoint and re-create it with this endpoint to edit. 
919pub async fn create_segment(configuration: &configuration::Configuration, app_id: &str, segment: Option<crate::models::Segment>) -> Result<crate::models::CreateSegmentSuccessResponse, Error<CreateSegmentError>> {
920    let configuration = configuration;
921
922    let client = &configuration.client;
923
924    let uri_str = format!("{}/apps/{app_id}/segments", configuration.base_path, app_id=crate::apis::urlencode(app_id));
925    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
926
927    if let Some(ref user_agent) = configuration.user_agent {
928        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
929    }
930
931    // Adds a telemetry header
932    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
933
934    if let Some(ref token) = configuration.rest_api_key_token {
935        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
936    }
937    req_builder = req_builder.json(&segment);
938
939    let req = req_builder.build()?;
940    let resp = client.execute(req).await?;
941
942    let status = resp.status();
943    let content = resp.text().await?;
944
945    if !status.is_client_error() && !status.is_server_error() {
946        serde_json::from_str(&content).map_err(Error::from)
947    } else {
948        let entity: Option<CreateSegmentError> = serde_json::from_str(&content).ok();
949        let error = ResponseContent { status: status, content: content, entity: entity };
950        Err(Error::ResponseError(error))
951    }
952}
953
954/// Creates a new Subscription under the User provided. Useful to add email addresses and SMS numbers to the User.
955pub async fn create_subscription(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str, subscription_body: crate::models::SubscriptionBody) -> Result<crate::models::SubscriptionBody, Error<CreateSubscriptionError>> {
956    let configuration = configuration;
957
958    let client = &configuration.client;
959
960    let uri_str = format!("{}/apps/{app_id}/users/by/{alias_label}/{alias_id}/subscriptions", configuration.base_path, app_id=crate::apis::urlencode(app_id), alias_label=crate::apis::urlencode(alias_label), alias_id=crate::apis::urlencode(alias_id));
961    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
962
963    if let Some(ref user_agent) = configuration.user_agent {
964        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
965    }
966
967    // Adds a telemetry header
968    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
969
970    if let Some(ref token) = configuration.rest_api_key_token {
971        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
972    }
973    req_builder = req_builder.json(&subscription_body);
974
975    let req = req_builder.build()?;
976    let resp = client.execute(req).await?;
977
978    let status = resp.status();
979    let content = resp.text().await?;
980
981    if !status.is_client_error() && !status.is_server_error() {
982        serde_json::from_str(&content).map_err(Error::from)
983    } else {
984        let entity: Option<CreateSubscriptionError> = serde_json::from_str(&content).ok();
985        let error = ResponseContent { status: status, content: content, entity: entity };
986        Err(Error::ResponseError(error))
987    }
988}
989
990/// Create reusable message templates for push, email, and SMS channels.
991pub async fn create_template(configuration: &configuration::Configuration, create_template_request: crate::models::CreateTemplateRequest) -> Result<crate::models::TemplateResource, Error<CreateTemplateError>> {
992    let configuration = configuration;
993
994    let client = &configuration.client;
995
996    let uri_str = format!("{}/templates", configuration.base_path);
997    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
998
999    if let Some(ref user_agent) = configuration.user_agent {
1000        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1001    }
1002
1003    // Adds a telemetry header
1004    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1005
1006    if let Some(ref token) = configuration.rest_api_key_token {
1007        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1008    }
1009    req_builder = req_builder.json(&create_template_request);
1010
1011    let req = req_builder.build()?;
1012    let resp = client.execute(req).await?;
1013
1014    let status = resp.status();
1015    let content = resp.text().await?;
1016
1017    if !status.is_client_error() && !status.is_server_error() {
1018        serde_json::from_str(&content).map_err(Error::from)
1019    } else {
1020        let entity: Option<CreateTemplateError> = serde_json::from_str(&content).ok();
1021        let error = ResponseContent { status: status, content: content, entity: entity };
1022        Err(Error::ResponseError(error))
1023    }
1024}
1025
1026/// Creates a User, optionally Subscriptions owned by the User as well as Aliases. Aliases provided in the payload will be used to look up an existing User.
1027pub async fn create_user(configuration: &configuration::Configuration, app_id: &str, user: crate::models::User) -> Result<crate::models::User, Error<CreateUserError>> {
1028    let configuration = configuration;
1029
1030    let client = &configuration.client;
1031
1032    let uri_str = format!("{}/apps/{app_id}/users", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1033    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1034
1035    if let Some(ref user_agent) = configuration.user_agent {
1036        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1037    }
1038
1039    // Adds a telemetry header
1040    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1041
1042    if let Some(ref token) = configuration.rest_api_key_token {
1043        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1044    }
1045    req_builder = req_builder.json(&user);
1046
1047    let req = req_builder.build()?;
1048    let resp = client.execute(req).await?;
1049
1050    let status = resp.status();
1051    let content = resp.text().await?;
1052
1053    if !status.is_client_error() && !status.is_server_error() {
1054        serde_json::from_str(&content).map_err(Error::from)
1055    } else {
1056        let entity: Option<CreateUserError> = serde_json::from_str(&content).ok();
1057        let error = ResponseContent { status: status, content: content, entity: entity };
1058        Err(Error::ResponseError(error))
1059    }
1060}
1061
1062/// Deletes an alias by alias label
1063pub async fn delete_alias(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str, alias_label_to_delete: &str) -> Result<crate::models::UserIdentityBody, Error<DeleteAliasError>> {
1064    let configuration = configuration;
1065
1066    let client = &configuration.client;
1067
1068    let uri_str = format!("{}/apps/{app_id}/users/by/{alias_label}/{alias_id}/identity/{alias_label_to_delete}", configuration.base_path, app_id=crate::apis::urlencode(app_id), alias_label=crate::apis::urlencode(alias_label), alias_id=crate::apis::urlencode(alias_id), alias_label_to_delete=crate::apis::urlencode(alias_label_to_delete));
1069    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1070
1071    if let Some(ref user_agent) = configuration.user_agent {
1072        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1073    }
1074
1075    // Adds a telemetry header
1076    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1077
1078    if let Some(ref token) = configuration.rest_api_key_token {
1079        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1080    }
1081
1082    let req = req_builder.build()?;
1083    let resp = client.execute(req).await?;
1084
1085    let status = resp.status();
1086    let content = resp.text().await?;
1087
1088    if !status.is_client_error() && !status.is_server_error() {
1089        serde_json::from_str(&content).map_err(Error::from)
1090    } else {
1091        let entity: Option<DeleteAliasError> = serde_json::from_str(&content).ok();
1092        let error = ResponseContent { status: status, content: content, entity: entity };
1093        Err(Error::ResponseError(error))
1094    }
1095}
1096
1097/// Delete a specific Rich Authentication Token (App API Key) for a OneSignal app. Requires your Organization API Key and the token’s unique ID, not the token value itself.
1098pub async fn delete_api_key(configuration: &configuration::Configuration, app_id: &str, token_id: &str) -> Result<serde_json::Value, Error<DeleteApiKeyError>> {
1099    let configuration = configuration;
1100
1101    let client = &configuration.client;
1102
1103    let uri_str = format!("{}/apps/{app_id}/auth/tokens/{token_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), token_id=crate::apis::urlencode(token_id));
1104    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1105
1106    if let Some(ref user_agent) = configuration.user_agent {
1107        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1108    }
1109
1110    // Adds a telemetry header
1111    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1112
1113    if let Some(ref token) = configuration.organization_api_key_token {
1114        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1115    }
1116
1117    let req = req_builder.build()?;
1118    let resp = client.execute(req).await?;
1119
1120    let status = resp.status();
1121    let content = resp.text().await?;
1122
1123    if !status.is_client_error() && !status.is_server_error() {
1124        serde_json::from_str(&content).map_err(Error::from)
1125    } else {
1126        let entity: Option<DeleteApiKeyError> = serde_json::from_str(&content).ok();
1127        let error = ResponseContent { status: status, content: content, entity: entity };
1128        Err(Error::ResponseError(error))
1129    }
1130}
1131
1132/// The Journeys API is in beta. Endpoints and response fields can still change. Permanently delete a journey by its UUID. Returns { \"success\": true } on success. The authenticated App API key must have permission to delete journeys. Deleting a journey stops any in-flight users and cannot be undone. Archive a running journey instead if you need to keep its data.
1133pub async fn delete_journey(configuration: &configuration::Configuration, app_id: &str, journey_id: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<DeleteJourneyError>> {
1134    let configuration = configuration;
1135
1136    let client = &configuration.client;
1137
1138    let uri_str = format!("{}/apps/{app_id}/journeys/{journey_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), journey_id=crate::apis::urlencode(journey_id));
1139    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1140
1141    if let Some(ref user_agent) = configuration.user_agent {
1142        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1143    }
1144
1145    // Adds a telemetry header
1146    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1147
1148    if let Some(ref token) = configuration.rest_api_key_token {
1149        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1150    }
1151
1152    let req = req_builder.build()?;
1153    let resp = client.execute(req).await?;
1154
1155    let status = resp.status();
1156    let content = resp.text().await?;
1157
1158    if !status.is_client_error() && !status.is_server_error() {
1159        serde_json::from_str(&content).map_err(Error::from)
1160    } else {
1161        let entity: Option<DeleteJourneyError> = serde_json::from_str(&content).ok();
1162        let error = ResponseContent { status: status, content: content, entity: entity };
1163        Err(Error::ResponseError(error))
1164    }
1165}
1166
1167/// Delete a segment (not user devices) - Required: OneSignal Paid Plan You can delete a segment under your app by calling this API. You must provide an API key in the Authorization header that has admin access on the app. The segment_id can be found in the URL of the segment when viewing it in the dashboard. 
1168pub async fn delete_segment(configuration: &configuration::Configuration, app_id: &str, segment_id: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<DeleteSegmentError>> {
1169    let configuration = configuration;
1170
1171    let client = &configuration.client;
1172
1173    let uri_str = format!("{}/apps/{app_id}/segments/{segment_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), segment_id=crate::apis::urlencode(segment_id));
1174    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1175
1176    if let Some(ref user_agent) = configuration.user_agent {
1177        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1178    }
1179
1180    // Adds a telemetry header
1181    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1182
1183    if let Some(ref token) = configuration.rest_api_key_token {
1184        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1185    }
1186
1187    let req = req_builder.build()?;
1188    let resp = client.execute(req).await?;
1189
1190    let status = resp.status();
1191    let content = resp.text().await?;
1192
1193    if !status.is_client_error() && !status.is_server_error() {
1194        serde_json::from_str(&content).map_err(Error::from)
1195    } else {
1196        let entity: Option<DeleteSegmentError> = serde_json::from_str(&content).ok();
1197        let error = ResponseContent { status: status, content: content, entity: entity };
1198        Err(Error::ResponseError(error))
1199    }
1200}
1201
1202/// Deletes the Subscription.
1203pub async fn delete_subscription(configuration: &configuration::Configuration, app_id: &str, subscription_id: &str) -> Result<(), Error<DeleteSubscriptionError>> {
1204    let configuration = configuration;
1205
1206    let client = &configuration.client;
1207
1208    let uri_str = format!("{}/apps/{app_id}/subscriptions/{subscription_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), subscription_id=crate::apis::urlencode(subscription_id));
1209    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1210
1211    if let Some(ref user_agent) = configuration.user_agent {
1212        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1213    }
1214
1215    // Adds a telemetry header
1216    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1217
1218    if let Some(ref token) = configuration.rest_api_key_token {
1219        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1220    }
1221
1222    let req = req_builder.build()?;
1223    let resp = client.execute(req).await?;
1224
1225    let status = resp.status();
1226    let content = resp.text().await?;
1227
1228    if !status.is_client_error() && !status.is_server_error() {
1229        Ok(())
1230    } else {
1231        let entity: Option<DeleteSubscriptionError> = serde_json::from_str(&content).ok();
1232        let error = ResponseContent { status: status, content: content, entity: entity };
1233        Err(Error::ResponseError(error))
1234    }
1235}
1236
1237/// Delete a template by id.
1238pub async fn delete_template(configuration: &configuration::Configuration, template_id: &str, app_id: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<DeleteTemplateError>> {
1239    let configuration = configuration;
1240
1241    let client = &configuration.client;
1242
1243    let uri_str = format!("{}/templates/{template_id}", configuration.base_path, template_id=crate::apis::urlencode(template_id));
1244    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1245
1246    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
1247    if let Some(ref user_agent) = configuration.user_agent {
1248        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1249    }
1250
1251    // Adds a telemetry header
1252    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1253
1254    if let Some(ref token) = configuration.rest_api_key_token {
1255        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1256    }
1257
1258    let req = req_builder.build()?;
1259    let resp = client.execute(req).await?;
1260
1261    let status = resp.status();
1262    let content = resp.text().await?;
1263
1264    if !status.is_client_error() && !status.is_server_error() {
1265        serde_json::from_str(&content).map_err(Error::from)
1266    } else {
1267        let entity: Option<DeleteTemplateError> = serde_json::from_str(&content).ok();
1268        let error = ResponseContent { status: status, content: content, entity: entity };
1269        Err(Error::ResponseError(error))
1270    }
1271}
1272
1273/// Removes the User identified by (:alias_label, :alias_id), and all Subscriptions and Aliases
1274pub async fn delete_user(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str) -> Result<(), Error<DeleteUserError>> {
1275    let configuration = configuration;
1276
1277    let client = &configuration.client;
1278
1279    let uri_str = format!("{}/apps/{app_id}/users/by/{alias_label}/{alias_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), alias_label=crate::apis::urlencode(alias_label), alias_id=crate::apis::urlencode(alias_id));
1280    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1281
1282    if let Some(ref user_agent) = configuration.user_agent {
1283        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1284    }
1285
1286    // Adds a telemetry header
1287    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1288
1289    if let Some(ref token) = configuration.rest_api_key_token {
1290        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1291    }
1292
1293    let req = req_builder.build()?;
1294    let resp = client.execute(req).await?;
1295
1296    let status = resp.status();
1297    let content = resp.text().await?;
1298
1299    if !status.is_client_error() && !status.is_server_error() {
1300        Ok(())
1301    } else {
1302        let entity: Option<DeleteUserError> = serde_json::from_str(&content).ok();
1303        let error = ResponseContent { status: status, content: content, entity: entity };
1304        Err(Error::ResponseError(error))
1305    }
1306}
1307
1308/// Generate a compressed CSV report of all of the events data for a notification. This will return a URL immediately upon success but it may take several minutes for the CSV to become available at that URL depending on the volume of data. Only one export can be in-progress per OneSignal account at any given time.
1309pub async fn export_events(configuration: &configuration::Configuration, notification_id: &str, app_id: &str) -> Result<crate::models::ExportEventsSuccessResponse, Error<ExportEventsError>> {
1310    let configuration = configuration;
1311
1312    let client = &configuration.client;
1313
1314    let uri_str = format!("{}/notifications/{notification_id}/export_events", configuration.base_path, notification_id=crate::apis::urlencode(notification_id));
1315    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1316
1317    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
1318    if let Some(ref user_agent) = configuration.user_agent {
1319        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1320    }
1321
1322    // Adds a telemetry header
1323    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1324
1325    if let Some(ref token) = configuration.rest_api_key_token {
1326        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1327    }
1328
1329    let req = req_builder.build()?;
1330    let resp = client.execute(req).await?;
1331
1332    let status = resp.status();
1333    let content = resp.text().await?;
1334
1335    if !status.is_client_error() && !status.is_server_error() {
1336        serde_json::from_str(&content).map_err(Error::from)
1337    } else {
1338        let entity: Option<ExportEventsError> = serde_json::from_str(&content).ok();
1339        let error = ResponseContent { status: status, content: content, entity: entity };
1340        Err(Error::ResponseError(error))
1341    }
1342}
1343
1344/// Generate a compressed CSV export of all of your current user data This method can be used to generate a compressed CSV export of all of your current user data. It is a much faster alternative than retrieving this data using the /players API endpoint. The file will be compressed using GZip. The file may take several minutes to generate depending on the number of users in your app. The URL generated will be available for 3 days and includes random v4 uuid as part of the resource name to be unguessable. &#x1F6A7; 403 Error Responses          You can test if it is complete by making a GET request to the csv_file_url value. This file may take time to generate depending on how many device records are being pulled. If the file is not ready, a 403 error will be returned. Otherwise the file itself will be returned. &#x1F6A7; Requires Authentication Key Requires your OneSignal App's REST API Key, available in Keys & IDs. &#x1F6A7; Concurrent Exports Only one concurrent export is allowed per OneSignal account. Please ensure you have successfully downloaded the .csv.gz file before exporting another app. CSV File Format: - Default Columns:   | Field | Details |   | --- | --- |   | id | OneSignal Player Id |   | identifier | Push Token |   | session_count | Number of times they visited the app or site   | language | Device language code |   | timezone | Number of seconds away from UTC. Example: -28800 |   | game_version | Version of your mobile app gathered from Android Studio versionCode in your App/build.gradle and iOS uses kCFBundleVersionKey in Xcode. |   | device_os | Device Operating System Version. Example: 80 = Chrome 80, 9 = Android 9 |   | device_type | Device Operating System Type |   | device_model | Device Hardware String Code. Example: Mobile Web Subscribers will have `Linux armv` |   | ad_id | Based on the Google Advertising Id for Android, identifierForVendor for iOS. OptedOut means user turned off Advertising tracking on the device. |   | tags | Current OneSignal Data Tags on the device. |   | last_active | Date and time the user last opened the mobile app or visited the site. |   | playtime | Total amount of time in seconds the user had the mobile app open. |   | amount_spent |  Mobile only - amount spent in USD on In-App Purchases. |    | created_at | Date and time the device record was created in OneSignal. Mobile - first time they opened the app with OneSignal SDK. Web - first time the user subscribed to the site. |   | invalid_identifier | t = unsubscribed, f = subscibed |   | badge_count | Current number of badges on the device | - Extra Columns:   | Field | Details |   | --- | --- |   | external_user_id | Your User Id set on the device |   | notification_types | Notification types |   | location | Location points (Latitude and Longitude) set on the device. |   | country | Country code |   | rooted | Android device rooted or not |   | ip | IP Address of the device if being tracked. See Handling Personal Data. |   | web_auth | Web Only authorization key. |   | web_p256 | Web Only p256 key. | 
1345pub async fn export_subscriptions(configuration: &configuration::Configuration, app_id: &str, export_subscriptions_request_body: Option<crate::models::ExportSubscriptionsRequestBody>) -> Result<crate::models::ExportSubscriptionsSuccessResponse, Error<ExportSubscriptionsError>> {
1346    let configuration = configuration;
1347
1348    let client = &configuration.client;
1349
1350    let uri_str = format!("{}/players/csv_export?app_id={app_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1351    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1352
1353    if let Some(ref user_agent) = configuration.user_agent {
1354        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1355    }
1356
1357    // Adds a telemetry header
1358    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1359
1360    if let Some(ref token) = configuration.rest_api_key_token {
1361        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1362    }
1363    req_builder = req_builder.json(&export_subscriptions_request_body);
1364
1365    let req = req_builder.build()?;
1366    let resp = client.execute(req).await?;
1367
1368    let status = resp.status();
1369    let content = resp.text().await?;
1370
1371    if !status.is_client_error() && !status.is_server_error() {
1372        serde_json::from_str(&content).map_err(Error::from)
1373    } else {
1374        let entity: Option<ExportSubscriptionsError> = serde_json::from_str(&content).ok();
1375        let error = ResponseContent { status: status, content: content, entity: entity };
1376        Err(Error::ResponseError(error))
1377    }
1378}
1379
1380/// Lists all Aliases for the User identified by (:alias_label, :alias_id).
1381pub async fn get_aliases(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str) -> Result<crate::models::UserIdentityBody, Error<GetAliasesError>> {
1382    let configuration = configuration;
1383
1384    let client = &configuration.client;
1385
1386    let uri_str = format!("{}/apps/{app_id}/users/by/{alias_label}/{alias_id}/identity", configuration.base_path, app_id=crate::apis::urlencode(app_id), alias_label=crate::apis::urlencode(alias_label), alias_id=crate::apis::urlencode(alias_id));
1387    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1388
1389    if let Some(ref user_agent) = configuration.user_agent {
1390        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1391    }
1392
1393    // Adds a telemetry header
1394    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1395
1396    if let Some(ref token) = configuration.rest_api_key_token {
1397        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1398    }
1399
1400    let req = req_builder.build()?;
1401    let resp = client.execute(req).await?;
1402
1403    let status = resp.status();
1404    let content = resp.text().await?;
1405
1406    if !status.is_client_error() && !status.is_server_error() {
1407        serde_json::from_str(&content).map_err(Error::from)
1408    } else {
1409        let entity: Option<GetAliasesError> = serde_json::from_str(&content).ok();
1410        let error = ResponseContent { status: status, content: content, entity: entity };
1411        Err(Error::ResponseError(error))
1412    }
1413}
1414
1415/// Lists all Aliases for the User identified by :subscription_id.
1416pub async fn get_aliases_by_subscription(configuration: &configuration::Configuration, app_id: &str, subscription_id: &str) -> Result<crate::models::UserIdentityBody, Error<GetAliasesBySubscriptionError>> {
1417    let configuration = configuration;
1418
1419    let client = &configuration.client;
1420
1421    let uri_str = format!("{}/apps/{app_id}/subscriptions/{subscription_id}/user/identity", configuration.base_path, app_id=crate::apis::urlencode(app_id), subscription_id=crate::apis::urlencode(subscription_id));
1422    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1423
1424    if let Some(ref user_agent) = configuration.user_agent {
1425        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1426    }
1427
1428    // Adds a telemetry header
1429    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1430
1431    if let Some(ref token) = configuration.rest_api_key_token {
1432        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1433    }
1434
1435    let req = req_builder.build()?;
1436    let resp = client.execute(req).await?;
1437
1438    let status = resp.status();
1439    let content = resp.text().await?;
1440
1441    if !status.is_client_error() && !status.is_server_error() {
1442        serde_json::from_str(&content).map_err(Error::from)
1443    } else {
1444        let entity: Option<GetAliasesBySubscriptionError> = serde_json::from_str(&content).ok();
1445        let error = ResponseContent { status: status, content: content, entity: entity };
1446        Err(Error::ResponseError(error))
1447    }
1448}
1449
1450/// View the details of a single OneSignal app
1451pub async fn get_app(configuration: &configuration::Configuration, app_id: &str) -> Result<crate::models::App, Error<GetAppError>> {
1452    let configuration = configuration;
1453
1454    let client = &configuration.client;
1455
1456    let uri_str = format!("{}/apps/{app_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1457    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1458
1459    if let Some(ref user_agent) = configuration.user_agent {
1460        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1461    }
1462
1463    // Adds a telemetry header
1464    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1465
1466    if let Some(ref token) = configuration.organization_api_key_token {
1467        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1468    }
1469
1470    let req = req_builder.build()?;
1471    let resp = client.execute(req).await?;
1472
1473    let status = resp.status();
1474    let content = resp.text().await?;
1475
1476    if !status.is_client_error() && !status.is_server_error() {
1477        serde_json::from_str(&content).map_err(Error::from)
1478    } else {
1479        let entity: Option<GetAppError> = serde_json::from_str(&content).ok();
1480        let error = ResponseContent { status: status, content: content, entity: entity };
1481        Err(Error::ResponseError(error))
1482    }
1483}
1484
1485/// View the details of all of your current OneSignal apps
1486pub async fn get_apps(configuration: &configuration::Configuration, ) -> Result<Vec<crate::models::App>, Error<GetAppsError>> {
1487    let configuration = configuration;
1488
1489    let client = &configuration.client;
1490
1491    let uri_str = format!("{}/apps", configuration.base_path);
1492    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1493
1494    if let Some(ref user_agent) = configuration.user_agent {
1495        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1496    }
1497
1498    // Adds a telemetry header
1499    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1500
1501    if let Some(ref token) = configuration.organization_api_key_token {
1502        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1503    }
1504
1505    let req = req_builder.build()?;
1506    let resp = client.execute(req).await?;
1507
1508    let status = resp.status();
1509    let content = resp.text().await?;
1510
1511    if !status.is_client_error() && !status.is_server_error() {
1512        serde_json::from_str(&content).map_err(Error::from)
1513    } else {
1514        let entity: Option<GetAppsError> = serde_json::from_str(&content).ok();
1515        let error = ResponseContent { status: status, content: content, entity: entity };
1516        Err(Error::ResponseError(error))
1517    }
1518}
1519
1520/// View the details of a single notification and outcomes associated with it
1521pub async fn get_notification(configuration: &configuration::Configuration, app_id: &str, notification_id: &str) -> Result<crate::models::NotificationWithMeta, Error<GetNotificationError>> {
1522    let configuration = configuration;
1523
1524    let client = &configuration.client;
1525
1526    let uri_str = format!("{}/notifications/{notification_id}", configuration.base_path, notification_id=crate::apis::urlencode(notification_id));
1527    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1528
1529    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
1530    if let Some(ref user_agent) = configuration.user_agent {
1531        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1532    }
1533
1534    // Adds a telemetry header
1535    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1536
1537    if let Some(ref token) = configuration.rest_api_key_token {
1538        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1539    }
1540
1541    let req = req_builder.build()?;
1542    let resp = client.execute(req).await?;
1543
1544    let status = resp.status();
1545    let content = resp.text().await?;
1546
1547    if !status.is_client_error() && !status.is_server_error() {
1548        serde_json::from_str(&content).map_err(Error::from)
1549    } else {
1550        let entity: Option<GetNotificationError> = serde_json::from_str(&content).ok();
1551        let error = ResponseContent { status: status, content: content, entity: entity };
1552        Err(Error::ResponseError(error))
1553    }
1554}
1555
1556/// -> View the devices sent a message - OneSignal Paid Plan Required This method will return all devices that were sent the given notification_id of an Email or Push Notification if used within 7 days of the date sent. After 7 days of the sending date, the message history data will be unavailable. After a successful response is received, the destination url may be polled until the file becomes available. Most exports are done in ~1-3 minutes, so setting a poll interval of 10 seconds should be adequate. For use cases that are not meant to be consumed by a script, an email will be sent to the supplied email address. &#x1F6A7; Requirements A OneSignal Paid Plan. Turn on Send History via OneSignal API in Settings -> Analytics. Cannot get data before this was turned on. Must be called within 7 days after sending the message. Messages targeting under 1000 recipients will not have \"sent\" events recorded, but will show \"clicked\" events. Requires your OneSignal App's REST API Key, available in Keys & IDs.
1557pub async fn get_notification_history(configuration: &configuration::Configuration, notification_id: &str, get_notification_history_request_body: crate::models::GetNotificationHistoryRequestBody) -> Result<crate::models::NotificationHistorySuccessResponse, Error<GetNotificationHistoryError>> {
1558    let configuration = configuration;
1559
1560    let client = &configuration.client;
1561
1562    let uri_str = format!("{}/notifications/{notification_id}/history", configuration.base_path, notification_id=crate::apis::urlencode(notification_id));
1563    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1564
1565    if let Some(ref user_agent) = configuration.user_agent {
1566        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1567    }
1568
1569    // Adds a telemetry header
1570    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1571
1572    if let Some(ref token) = configuration.rest_api_key_token {
1573        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1574    }
1575    req_builder = req_builder.json(&get_notification_history_request_body);
1576
1577    let req = req_builder.build()?;
1578    let resp = client.execute(req).await?;
1579
1580    let status = resp.status();
1581    let content = resp.text().await?;
1582
1583    if !status.is_client_error() && !status.is_server_error() {
1584        serde_json::from_str(&content).map_err(Error::from)
1585    } else {
1586        let entity: Option<GetNotificationHistoryError> = serde_json::from_str(&content).ok();
1587        let error = ResponseContent { status: status, content: content, entity: entity };
1588        Err(Error::ResponseError(error))
1589    }
1590}
1591
1592/// View the details of multiple notifications
1593pub async fn get_notifications(configuration: &configuration::Configuration, app_id: &str, limit: Option<i32>, offset: Option<i32>, kind: Option<i32>, time_offset: Option<&str>) -> Result<crate::models::NotificationSlice, Error<GetNotificationsError>> {
1594    let configuration = configuration;
1595
1596    let client = &configuration.client;
1597
1598    let uri_str = format!("{}/notifications", configuration.base_path);
1599    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1600
1601    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
1602    if let Some(ref str) = limit {
1603        req_builder = req_builder.query(&[("limit", &str.to_string())]);
1604    }
1605    if let Some(ref str) = offset {
1606        req_builder = req_builder.query(&[("offset", &str.to_string())]);
1607    }
1608    if let Some(ref str) = kind {
1609        req_builder = req_builder.query(&[("kind", &str.to_string())]);
1610    }
1611    if let Some(ref str) = time_offset {
1612        req_builder = req_builder.query(&[("time_offset", &str.to_string())]);
1613    }
1614    if let Some(ref user_agent) = configuration.user_agent {
1615        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1616    }
1617
1618    // Adds a telemetry header
1619    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1620
1621    if let Some(ref token) = configuration.rest_api_key_token {
1622        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1623    }
1624
1625    let req = req_builder.build()?;
1626    let resp = client.execute(req).await?;
1627
1628    let status = resp.status();
1629    let content = resp.text().await?;
1630
1631    if !status.is_client_error() && !status.is_server_error() {
1632        serde_json::from_str(&content).map_err(Error::from)
1633    } else {
1634        let entity: Option<GetNotificationsError> = serde_json::from_str(&content).ok();
1635        let error = ResponseContent { status: status, content: content, entity: entity };
1636        Err(Error::ResponseError(error))
1637    }
1638}
1639
1640/// View the details of all the outcomes associated with your app  &#x1F6A7; Requires Authentication Key Requires your OneSignal App's REST API Key, available in Keys & IDs.  &#x1F6A7; Outcome Data Limitations Outcomes are only accessible for around 30 days before deleted from our servers. You will need to export this data every month if you want to keep it. 
1641pub async fn get_outcomes(configuration: &configuration::Configuration, app_id: &str, outcome_names: &str, outcome_names2: Option<&str>, outcome_time_range: Option<&str>, outcome_platforms: Option<&str>, outcome_attribution: Option<&str>) -> Result<crate::models::OutcomesData, Error<GetOutcomesError>> {
1642    let configuration = configuration;
1643
1644    let client = &configuration.client;
1645
1646    let uri_str = format!("{}/apps/{app_id}/outcomes", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1647    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1648
1649    req_builder = req_builder.query(&[("outcome_names", &outcome_names.to_string())]);
1650    if let Some(ref str) = outcome_names2 {
1651        req_builder = req_builder.query(&[("outcome_names[]", &str.to_string())]);
1652    }
1653    if let Some(ref str) = outcome_time_range {
1654        req_builder = req_builder.query(&[("outcome_time_range", &str.to_string())]);
1655    }
1656    if let Some(ref str) = outcome_platforms {
1657        req_builder = req_builder.query(&[("outcome_platforms", &str.to_string())]);
1658    }
1659    if let Some(ref str) = outcome_attribution {
1660        req_builder = req_builder.query(&[("outcome_attribution", &str.to_string())]);
1661    }
1662    if let Some(ref user_agent) = configuration.user_agent {
1663        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1664    }
1665
1666    // Adds a telemetry header
1667    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1668
1669    if let Some(ref token) = configuration.rest_api_key_token {
1670        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1671    }
1672
1673    let req = req_builder.build()?;
1674    let resp = client.execute(req).await?;
1675
1676    let status = resp.status();
1677    let content = resp.text().await?;
1678
1679    if !status.is_client_error() && !status.is_server_error() {
1680        serde_json::from_str(&content).map_err(Error::from)
1681    } else {
1682        let entity: Option<GetOutcomesError> = serde_json::from_str(&content).ok();
1683        let error = ResponseContent { status: status, content: content, entity: entity };
1684        Err(Error::ResponseError(error))
1685    }
1686}
1687
1688/// Retrieve details for a single segment by its ID, including subscriber count and optionally segment metadata and filters.
1689pub async fn get_segment(configuration: &configuration::Configuration, app_id: &str, segment_id: &str, include_segment_detail: Option<bool>) -> Result<crate::models::GetSegmentSuccessResponse, Error<GetSegmentError>> {
1690    let configuration = configuration;
1691
1692    let client = &configuration.client;
1693
1694    let uri_str = format!("{}/apps/{app_id}/segments/{segment_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), segment_id=crate::apis::urlencode(segment_id));
1695    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1696
1697    if let Some(ref str) = include_segment_detail {
1698        req_builder = req_builder.query(&[("include-segment-detail", &str.to_string())]);
1699    }
1700    if let Some(ref user_agent) = configuration.user_agent {
1701        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1702    }
1703
1704    // Adds a telemetry header
1705    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1706
1707    if let Some(ref token) = configuration.rest_api_key_token {
1708        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1709    }
1710
1711    let req = req_builder.build()?;
1712    let resp = client.execute(req).await?;
1713
1714    let status = resp.status();
1715    let content = resp.text().await?;
1716
1717    if !status.is_client_error() && !status.is_server_error() {
1718        serde_json::from_str(&content).map_err(Error::from)
1719    } else {
1720        let entity: Option<GetSegmentError> = serde_json::from_str(&content).ok();
1721        let error = ResponseContent { status: status, content: content, entity: entity };
1722        Err(Error::ResponseError(error))
1723    }
1724}
1725
1726/// Returns an array of segments from an app.
1727pub async fn get_segments(configuration: &configuration::Configuration, app_id: &str, offset: Option<i32>, limit: Option<i32>) -> Result<crate::models::GetSegmentsSuccessResponse, Error<GetSegmentsError>> {
1728    let configuration = configuration;
1729
1730    let client = &configuration.client;
1731
1732    let uri_str = format!("{}/apps/{app_id}/segments", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1733    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1734
1735    if let Some(ref str) = offset {
1736        req_builder = req_builder.query(&[("offset", &str.to_string())]);
1737    }
1738    if let Some(ref str) = limit {
1739        req_builder = req_builder.query(&[("limit", &str.to_string())]);
1740    }
1741    if let Some(ref user_agent) = configuration.user_agent {
1742        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1743    }
1744
1745    // Adds a telemetry header
1746    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1747
1748    if let Some(ref token) = configuration.rest_api_key_token {
1749        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1750    }
1751
1752    let req = req_builder.build()?;
1753    let resp = client.execute(req).await?;
1754
1755    let status = resp.status();
1756    let content = resp.text().await?;
1757
1758    if !status.is_client_error() && !status.is_server_error() {
1759        serde_json::from_str(&content).map_err(Error::from)
1760    } else {
1761        let entity: Option<GetSegmentsError> = serde_json::from_str(&content).ok();
1762        let error = ResponseContent { status: status, content: content, entity: entity };
1763        Err(Error::ResponseError(error))
1764    }
1765}
1766
1767/// Returns the User’s properties, Aliases, and Subscriptions.
1768pub async fn get_user(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str) -> Result<crate::models::User, Error<GetUserError>> {
1769    let configuration = configuration;
1770
1771    let client = &configuration.client;
1772
1773    let uri_str = format!("{}/apps/{app_id}/users/by/{alias_label}/{alias_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), alias_label=crate::apis::urlencode(alias_label), alias_id=crate::apis::urlencode(alias_id));
1774    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1775
1776    if let Some(ref user_agent) = configuration.user_agent {
1777        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1778    }
1779
1780    // Adds a telemetry header
1781    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1782
1783    if let Some(ref token) = configuration.rest_api_key_token {
1784        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1785    }
1786
1787    let req = req_builder.build()?;
1788    let resp = client.execute(req).await?;
1789
1790    let status = resp.status();
1791    let content = resp.text().await?;
1792
1793    if !status.is_client_error() && !status.is_server_error() {
1794        serde_json::from_str(&content).map_err(Error::from)
1795    } else {
1796        let entity: Option<GetUserError> = serde_json::from_str(&content).ok();
1797        let error = ResponseContent { status: status, content: content, entity: entity };
1798        Err(Error::ResponseError(error))
1799    }
1800}
1801
1802/// Retrieve a paginated, time-scoped list of audit log events for an organization. Requires an Enterprise plan with the audit logs entitlement enabled.
1803pub async fn list_audit_logs(configuration: &configuration::Configuration, organization_id: &str, start_time: Option<&str>, end_time: Option<&str>, cursor: Option<&str>, limit: Option<i32>, app_ids: Option<Vec<String>>, actions: Option<Vec<String>>, actor_ids: Option<Vec<String>>, actor_emails: Option<Vec<String>>, target_types: Option<Vec<String>>, target_ids: Option<Vec<String>>, ip_addresses: Option<Vec<String>>) -> Result<crate::models::ListAuditLogsSuccessResponse, Error<ListAuditLogsError>> {
1804    let configuration = configuration;
1805
1806    let client = &configuration.client;
1807
1808    let uri_str = format!("{}/organizations/{organization_id}/audit_logs", configuration.base_path, organization_id=crate::apis::urlencode(organization_id));
1809    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1810
1811    if let Some(ref str) = start_time {
1812        req_builder = req_builder.query(&[("start_time", &str.to_string())]);
1813    }
1814    if let Some(ref str) = end_time {
1815        req_builder = req_builder.query(&[("end_time", &str.to_string())]);
1816    }
1817    if let Some(ref str) = cursor {
1818        req_builder = req_builder.query(&[("cursor", &str.to_string())]);
1819    }
1820    if let Some(ref str) = limit {
1821        req_builder = req_builder.query(&[("limit", &str.to_string())]);
1822    }
1823    if let Some(ref str) = app_ids {
1824        req_builder = match "multi" {
1825            "multi" => req_builder.query(&str.into_iter().map(|p| ("app_ids".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1826            _ => req_builder.query(&[("app_ids", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1827        };
1828    }
1829    if let Some(ref str) = actions {
1830        req_builder = match "multi" {
1831            "multi" => req_builder.query(&str.into_iter().map(|p| ("actions".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1832            _ => req_builder.query(&[("actions", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1833        };
1834    }
1835    if let Some(ref str) = actor_ids {
1836        req_builder = match "multi" {
1837            "multi" => req_builder.query(&str.into_iter().map(|p| ("actor_ids".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1838            _ => req_builder.query(&[("actor_ids", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1839        };
1840    }
1841    if let Some(ref str) = actor_emails {
1842        req_builder = match "multi" {
1843            "multi" => req_builder.query(&str.into_iter().map(|p| ("actor_emails".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1844            _ => req_builder.query(&[("actor_emails", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1845        };
1846    }
1847    if let Some(ref str) = target_types {
1848        req_builder = match "multi" {
1849            "multi" => req_builder.query(&str.into_iter().map(|p| ("target_types".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1850            _ => req_builder.query(&[("target_types", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1851        };
1852    }
1853    if let Some(ref str) = target_ids {
1854        req_builder = match "multi" {
1855            "multi" => req_builder.query(&str.into_iter().map(|p| ("target_ids".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1856            _ => req_builder.query(&[("target_ids", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1857        };
1858    }
1859    if let Some(ref str) = ip_addresses {
1860        req_builder = match "multi" {
1861            "multi" => req_builder.query(&str.into_iter().map(|p| ("ip_addresses".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1862            _ => req_builder.query(&[("ip_addresses", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1863        };
1864    }
1865    if let Some(ref user_agent) = configuration.user_agent {
1866        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1867    }
1868
1869    // Adds a telemetry header
1870    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1871
1872    if let Some(ref token) = configuration.organization_api_key_token {
1873        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1874    }
1875
1876    let req = req_builder.build()?;
1877    let resp = client.execute(req).await?;
1878
1879    let status = resp.status();
1880    let content = resp.text().await?;
1881
1882    if !status.is_client_error() && !status.is_server_error() {
1883        serde_json::from_str(&content).map_err(Error::from)
1884    } else {
1885        let entity: Option<ListAuditLogsError> = serde_json::from_str(&content).ok();
1886        let error = ResponseContent { status: status, content: content, entity: entity };
1887        Err(Error::ResponseError(error))
1888    }
1889}
1890
1891/// Rotate a Rich Authentication Token (App API Key) for a OneSignal app. Rotating a key revokes the current token and generates a new one under the same configuration—ideal when a token is lost or compromised but you don’t want to recreate and reconfigure it from scratch.
1892pub async fn rotate_api_key(configuration: &configuration::Configuration, app_id: &str, token_id: &str) -> Result<crate::models::CreateApiKeyResponse, Error<RotateApiKeyError>> {
1893    let configuration = configuration;
1894
1895    let client = &configuration.client;
1896
1897    let uri_str = format!("{}/apps/{app_id}/auth/tokens/{token_id}/rotate", configuration.base_path, app_id=crate::apis::urlencode(app_id), token_id=crate::apis::urlencode(token_id));
1898    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1899
1900    if let Some(ref user_agent) = configuration.user_agent {
1901        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1902    }
1903
1904    // Adds a telemetry header
1905    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1906
1907    if let Some(ref token) = configuration.organization_api_key_token {
1908        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1909    }
1910
1911    let req = req_builder.build()?;
1912    let resp = client.execute(req).await?;
1913
1914    let status = resp.status();
1915    let content = resp.text().await?;
1916
1917    if !status.is_client_error() && !status.is_server_error() {
1918        serde_json::from_str(&content).map_err(Error::from)
1919    } else {
1920        let entity: Option<RotateApiKeyError> = serde_json::from_str(&content).ok();
1921        let error = ResponseContent { status: status, content: content, entity: entity };
1922        Err(Error::ResponseError(error))
1923    }
1924}
1925
1926/// Remotely start a Live Activity on iOS devices via OneSignal’s REST API.
1927pub async fn start_live_activity(configuration: &configuration::Configuration, app_id: &str, activity_type: &str, start_live_activity_request: crate::models::StartLiveActivityRequest) -> Result<crate::models::StartLiveActivitySuccessResponse, Error<StartLiveActivityError>> {
1928    let configuration = configuration;
1929
1930    let client = &configuration.client;
1931
1932    let uri_str = format!("{}/apps/{app_id}/activities/activity/{activity_type}", configuration.base_path, app_id=crate::apis::urlencode(app_id), activity_type=crate::apis::urlencode(activity_type));
1933    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1934
1935    if let Some(ref user_agent) = configuration.user_agent {
1936        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1937    }
1938
1939    // Adds a telemetry header
1940    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1941
1942    if let Some(ref token) = configuration.rest_api_key_token {
1943        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1944    }
1945    req_builder = req_builder.json(&start_live_activity_request);
1946
1947    let req = req_builder.build()?;
1948    let resp = client.execute(req).await?;
1949
1950    let status = resp.status();
1951    let content = resp.text().await?;
1952
1953    if !status.is_client_error() && !status.is_server_error() {
1954        serde_json::from_str(&content).map_err(Error::from)
1955    } else {
1956        let entity: Option<StartLiveActivityError> = serde_json::from_str(&content).ok();
1957        let error = ResponseContent { status: status, content: content, entity: entity };
1958        Err(Error::ResponseError(error))
1959    }
1960}
1961
1962/// Transfers this Subscription to the User identified by the identity in the payload.
1963pub async fn transfer_subscription(configuration: &configuration::Configuration, app_id: &str, subscription_id: &str, transfer_subscription_request_body: crate::models::TransferSubscriptionRequestBody) -> Result<crate::models::UserIdentityBody, Error<TransferSubscriptionError>> {
1964    let configuration = configuration;
1965
1966    let client = &configuration.client;
1967
1968    let uri_str = format!("{}/apps/{app_id}/subscriptions/{subscription_id}/owner", configuration.base_path, app_id=crate::apis::urlencode(app_id), subscription_id=crate::apis::urlencode(subscription_id));
1969    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
1970
1971    if let Some(ref user_agent) = configuration.user_agent {
1972        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1973    }
1974
1975    // Adds a telemetry header
1976    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
1977
1978    if let Some(ref token) = configuration.rest_api_key_token {
1979        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1980    }
1981    req_builder = req_builder.json(&transfer_subscription_request_body);
1982
1983    let req = req_builder.build()?;
1984    let resp = client.execute(req).await?;
1985
1986    let status = resp.status();
1987    let content = resp.text().await?;
1988
1989    if !status.is_client_error() && !status.is_server_error() {
1990        serde_json::from_str(&content).map_err(Error::from)
1991    } else {
1992        let entity: Option<TransferSubscriptionError> = serde_json::from_str(&content).ok();
1993        let error = ResponseContent { status: status, content: content, entity: entity };
1994        Err(Error::ResponseError(error))
1995    }
1996}
1997
1998/// Unsubscribe an email with a token when using your own custom email unsubscribe landing page
1999pub async fn unsubscribe_email_with_token(configuration: &configuration::Configuration, app_id: &str, notification_id: &str, token: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<UnsubscribeEmailWithTokenError>> {
2000    let configuration = configuration;
2001
2002    let client = &configuration.client;
2003
2004    let uri_str = format!("{}/apps/{app_id}/notifications/{notification_id}/unsubscribe", configuration.base_path, app_id=crate::apis::urlencode(app_id), notification_id=crate::apis::urlencode(notification_id));
2005    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
2006
2007    req_builder = req_builder.query(&[("token", &token.to_string())]);
2008    if let Some(ref user_agent) = configuration.user_agent {
2009        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2010    }
2011
2012    // Adds a telemetry header
2013    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2014
2015    if let Some(ref token) = configuration.rest_api_key_token {
2016        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2017    }
2018
2019    let req = req_builder.build()?;
2020    let resp = client.execute(req).await?;
2021
2022    let status = resp.status();
2023    let content = resp.text().await?;
2024
2025    if !status.is_client_error() && !status.is_server_error() {
2026        serde_json::from_str(&content).map_err(Error::from)
2027    } else {
2028        let entity: Option<UnsubscribeEmailWithTokenError> = serde_json::from_str(&content).ok();
2029        let error = ResponseContent { status: status, content: content, entity: entity };
2030        Err(Error::ResponseError(error))
2031    }
2032}
2033
2034/// Update a Rich Authentication Token (App API Key) for a OneSignal app.
2035pub async fn update_api_key(configuration: &configuration::Configuration, app_id: &str, token_id: &str, update_api_key_request: crate::models::UpdateApiKeyRequest) -> Result<serde_json::Value, Error<UpdateApiKeyError>> {
2036    let configuration = configuration;
2037
2038    let client = &configuration.client;
2039
2040    let uri_str = format!("{}/apps/{app_id}/auth/tokens/{token_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), token_id=crate::apis::urlencode(token_id));
2041    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2042
2043    if let Some(ref user_agent) = configuration.user_agent {
2044        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2045    }
2046
2047    // Adds a telemetry header
2048    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2049
2050    if let Some(ref token) = configuration.organization_api_key_token {
2051        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2052    }
2053    req_builder = req_builder.json(&update_api_key_request);
2054
2055    let req = req_builder.build()?;
2056    let resp = client.execute(req).await?;
2057
2058    let status = resp.status();
2059    let content = resp.text().await?;
2060
2061    if !status.is_client_error() && !status.is_server_error() {
2062        serde_json::from_str(&content).map_err(Error::from)
2063    } else {
2064        let entity: Option<UpdateApiKeyError> = serde_json::from_str(&content).ok();
2065        let error = ResponseContent { status: status, content: content, entity: entity };
2066        Err(Error::ResponseError(error))
2067    }
2068}
2069
2070/// Updates the name or configuration settings of an existing OneSignal app
2071pub async fn update_app(configuration: &configuration::Configuration, app_id: &str, app: crate::models::App) -> Result<crate::models::App, Error<UpdateAppError>> {
2072    let configuration = configuration;
2073
2074    let client = &configuration.client;
2075
2076    let uri_str = format!("{}/apps/{app_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id));
2077    let mut req_builder = client.request(reqwest::Method::PUT, uri_str.as_str());
2078
2079    if let Some(ref user_agent) = configuration.user_agent {
2080        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2081    }
2082
2083    // Adds a telemetry header
2084    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2085
2086    if let Some(ref token) = configuration.organization_api_key_token {
2087        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2088    }
2089    req_builder = req_builder.json(&app);
2090
2091    let req = req_builder.build()?;
2092    let resp = client.execute(req).await?;
2093
2094    let status = resp.status();
2095    let content = resp.text().await?;
2096
2097    if !status.is_client_error() && !status.is_server_error() {
2098        serde_json::from_str(&content).map_err(Error::from)
2099    } else {
2100        let entity: Option<UpdateAppError> = serde_json::from_str(&content).ok();
2101        let error = ResponseContent { status: status, content: content, entity: entity };
2102        Err(Error::ResponseError(error))
2103    }
2104}
2105
2106/// The Journeys API is in beta. Endpoints and response fields can still change. Apply a partial update to a journey using JSON Merge Patch (RFC 7396). Send only the fields you want to change; omitted fields are left unchanged. A null value clears a nullable field, and arrays such as nodes are replaced wholesale. Set state to active to activate a draft journey.
2107pub async fn update_journey(configuration: &configuration::Configuration, app_id: &str, journey_id: &str, update_journey_request: crate::models::UpdateJourneyRequest) -> Result<crate::models::Journey, Error<UpdateJourneyError>> {
2108    let configuration = configuration;
2109
2110    let client = &configuration.client;
2111
2112    let uri_str = format!("{}/apps/{app_id}/journeys/{journey_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), journey_id=crate::apis::urlencode(journey_id));
2113    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2114
2115    if let Some(ref user_agent) = configuration.user_agent {
2116        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2117    }
2118
2119    // Adds a telemetry header
2120    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2121
2122    if let Some(ref token) = configuration.rest_api_key_token {
2123        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2124    }
2125    req_builder = req_builder.json(&update_journey_request);
2126
2127    let req = req_builder.build()?;
2128    let resp = client.execute(req).await?;
2129
2130    let status = resp.status();
2131    let content = resp.text().await?;
2132
2133    if !status.is_client_error() && !status.is_server_error() {
2134        serde_json::from_str(&content).map_err(Error::from)
2135    } else {
2136        let entity: Option<UpdateJourneyError> = serde_json::from_str(&content).ok();
2137        let error = ResponseContent { status: status, content: content, entity: entity };
2138        Err(Error::ResponseError(error))
2139    }
2140}
2141
2142/// The Journeys API is in beta. Endpoints and response fields can still change. Apply a partial update to a single node, located by its server-assigned id, using JSON Merge Patch (RFC 7396). Send only the node fields you want to change; the rest of the node and the rest of the journey graph are left untouched. Returns the full updated journey.
2143pub async fn update_journey_node(configuration: &configuration::Configuration, app_id: &str, journey_id: &str, node_id: &str, update_journey_node_request: crate::models::UpdateJourneyNodeRequest) -> Result<crate::models::Journey, Error<UpdateJourneyNodeError>> {
2144    let configuration = configuration;
2145
2146    let client = &configuration.client;
2147
2148    let uri_str = format!("{}/apps/{app_id}/journeys/{journey_id}/nodes/{node_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), journey_id=crate::apis::urlencode(journey_id), node_id=crate::apis::urlencode(node_id));
2149    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2150
2151    if let Some(ref user_agent) = configuration.user_agent {
2152        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2153    }
2154
2155    // Adds a telemetry header
2156    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2157
2158    if let Some(ref token) = configuration.rest_api_key_token {
2159        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2160    }
2161    req_builder = req_builder.json(&update_journey_node_request);
2162
2163    let req = req_builder.build()?;
2164    let resp = client.execute(req).await?;
2165
2166    let status = resp.status();
2167    let content = resp.text().await?;
2168
2169    if !status.is_client_error() && !status.is_server_error() {
2170        serde_json::from_str(&content).map_err(Error::from)
2171    } else {
2172        let entity: Option<UpdateJourneyNodeError> = serde_json::from_str(&content).ok();
2173        let error = ResponseContent { status: status, content: content, entity: entity };
2174        Err(Error::ResponseError(error))
2175    }
2176}
2177
2178/// Updates a specified live activity.
2179pub async fn update_live_activity(configuration: &configuration::Configuration, app_id: &str, activity_id: &str, update_live_activity_request: crate::models::UpdateLiveActivityRequest) -> Result<crate::models::UpdateLiveActivitySuccessResponse, Error<UpdateLiveActivityError>> {
2180    let configuration = configuration;
2181
2182    let client = &configuration.client;
2183
2184    let uri_str = format!("{}/apps/{app_id}/live_activities/{activity_id}/notifications", configuration.base_path, app_id=crate::apis::urlencode(app_id), activity_id=crate::apis::urlencode(activity_id));
2185    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
2186
2187    if let Some(ref user_agent) = configuration.user_agent {
2188        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2189    }
2190
2191    // Adds a telemetry header
2192    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2193
2194    if let Some(ref token) = configuration.rest_api_key_token {
2195        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2196    }
2197    req_builder = req_builder.json(&update_live_activity_request);
2198
2199    let req = req_builder.build()?;
2200    let resp = client.execute(req).await?;
2201
2202    let status = resp.status();
2203    let content = resp.text().await?;
2204
2205    if !status.is_client_error() && !status.is_server_error() {
2206        serde_json::from_str(&content).map_err(Error::from)
2207    } else {
2208        let entity: Option<UpdateLiveActivityError> = serde_json::from_str(&content).ok();
2209        let error = ResponseContent { status: status, content: content, entity: entity };
2210        Err(Error::ResponseError(error))
2211    }
2212}
2213
2214/// Update an existing segment's name and/or filters. The name parameter is always required. When filters are provided, all existing filters are replaced with the new ones.
2215pub async fn update_segment(configuration: &configuration::Configuration, app_id: &str, segment_id: &str, update_segment_request: Option<crate::models::UpdateSegmentRequest>) -> Result<crate::models::UpdateSegmentSuccessResponse, Error<UpdateSegmentError>> {
2216    let configuration = configuration;
2217
2218    let client = &configuration.client;
2219
2220    let uri_str = format!("{}/apps/{app_id}/segments/{segment_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), segment_id=crate::apis::urlencode(segment_id));
2221    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2222
2223    if let Some(ref user_agent) = configuration.user_agent {
2224        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2225    }
2226
2227    // Adds a telemetry header
2228    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2229
2230    if let Some(ref token) = configuration.rest_api_key_token {
2231        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2232    }
2233    req_builder = req_builder.json(&update_segment_request);
2234
2235    let req = req_builder.build()?;
2236    let resp = client.execute(req).await?;
2237
2238    let status = resp.status();
2239    let content = resp.text().await?;
2240
2241    if !status.is_client_error() && !status.is_server_error() {
2242        serde_json::from_str(&content).map_err(Error::from)
2243    } else {
2244        let entity: Option<UpdateSegmentError> = serde_json::from_str(&content).ok();
2245        let error = ResponseContent { status: status, content: content, entity: entity };
2246        Err(Error::ResponseError(error))
2247    }
2248}
2249
2250/// Updates an existing Subscription’s properties.
2251pub async fn update_subscription(configuration: &configuration::Configuration, app_id: &str, subscription_id: &str, subscription_body: crate::models::SubscriptionBody) -> Result<(), Error<UpdateSubscriptionError>> {
2252    let configuration = configuration;
2253
2254    let client = &configuration.client;
2255
2256    let uri_str = format!("{}/apps/{app_id}/subscriptions/{subscription_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), subscription_id=crate::apis::urlencode(subscription_id));
2257    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2258
2259    if let Some(ref user_agent) = configuration.user_agent {
2260        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2261    }
2262
2263    // Adds a telemetry header
2264    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2265
2266    if let Some(ref token) = configuration.rest_api_key_token {
2267        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2268    }
2269    req_builder = req_builder.json(&subscription_body);
2270
2271    let req = req_builder.build()?;
2272    let resp = client.execute(req).await?;
2273
2274    let status = resp.status();
2275    let content = resp.text().await?;
2276
2277    if !status.is_client_error() && !status.is_server_error() {
2278        Ok(())
2279    } else {
2280        let entity: Option<UpdateSubscriptionError> = serde_json::from_str(&content).ok();
2281        let error = ResponseContent { status: status, content: content, entity: entity };
2282        Err(Error::ResponseError(error))
2283    }
2284}
2285
2286/// Update properties on an existing OneSignal subscription using its token.
2287pub async fn update_subscription_by_token(configuration: &configuration::Configuration, app_id: &str, token_type: &str, token: &str, subscription_body: crate::models::SubscriptionBody) -> Result<serde_json::Value, Error<UpdateSubscriptionByTokenError>> {
2288    let configuration = configuration;
2289
2290    let client = &configuration.client;
2291
2292    let uri_str = format!("{}/apps/{app_id}/subscriptions_by_token/{token_type}/{token}", configuration.base_path, app_id=crate::apis::urlencode(app_id), token_type=crate::apis::urlencode(token_type), token=crate::apis::urlencode(token));
2293    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2294
2295    if let Some(ref user_agent) = configuration.user_agent {
2296        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2297    }
2298
2299    // Adds a telemetry header
2300    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2301
2302    if let Some(ref token) = configuration.rest_api_key_token {
2303        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2304    }
2305    req_builder = req_builder.json(&subscription_body);
2306
2307    let req = req_builder.build()?;
2308    let resp = client.execute(req).await?;
2309
2310    let status = resp.status();
2311    let content = resp.text().await?;
2312
2313    if !status.is_client_error() && !status.is_server_error() {
2314        serde_json::from_str(&content).map_err(Error::from)
2315    } else {
2316        let entity: Option<UpdateSubscriptionByTokenError> = serde_json::from_str(&content).ok();
2317        let error = ResponseContent { status: status, content: content, entity: entity };
2318        Err(Error::ResponseError(error))
2319    }
2320}
2321
2322/// Update an existing template.
2323pub async fn update_template(configuration: &configuration::Configuration, template_id: &str, app_id: &str, update_template_request: crate::models::UpdateTemplateRequest) -> Result<crate::models::TemplateResource, Error<UpdateTemplateError>> {
2324    let configuration = configuration;
2325
2326    let client = &configuration.client;
2327
2328    let uri_str = format!("{}/templates/{template_id}", configuration.base_path, template_id=crate::apis::urlencode(template_id));
2329    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2330
2331    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
2332    if let Some(ref user_agent) = configuration.user_agent {
2333        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2334    }
2335
2336    // Adds a telemetry header
2337    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2338
2339    if let Some(ref token) = configuration.rest_api_key_token {
2340        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2341    }
2342    req_builder = req_builder.json(&update_template_request);
2343
2344    let req = req_builder.build()?;
2345    let resp = client.execute(req).await?;
2346
2347    let status = resp.status();
2348    let content = resp.text().await?;
2349
2350    if !status.is_client_error() && !status.is_server_error() {
2351        serde_json::from_str(&content).map_err(Error::from)
2352    } else {
2353        let entity: Option<UpdateTemplateError> = serde_json::from_str(&content).ok();
2354        let error = ResponseContent { status: status, content: content, entity: entity };
2355        Err(Error::ResponseError(error))
2356    }
2357}
2358
2359/// Updates an existing User’s properties.
2360pub async fn update_user(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str, update_user_request: crate::models::UpdateUserRequest) -> Result<crate::models::PropertiesBody, Error<UpdateUserError>> {
2361    let configuration = configuration;
2362
2363    let client = &configuration.client;
2364
2365    let uri_str = format!("{}/apps/{app_id}/users/by/{alias_label}/{alias_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), alias_label=crate::apis::urlencode(alias_label), alias_id=crate::apis::urlencode(alias_id));
2366    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2367
2368    if let Some(ref user_agent) = configuration.user_agent {
2369        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2370    }
2371
2372    // Adds a telemetry header
2373    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2374
2375    if let Some(ref token) = configuration.rest_api_key_token {
2376        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2377    }
2378    req_builder = req_builder.json(&update_user_request);
2379
2380    let req = req_builder.build()?;
2381    let resp = client.execute(req).await?;
2382
2383    let status = resp.status();
2384    let content = resp.text().await?;
2385
2386    if !status.is_client_error() && !status.is_server_error() {
2387        serde_json::from_str(&content).map_err(Error::from)
2388    } else {
2389        let entity: Option<UpdateUserError> = serde_json::from_str(&content).ok();
2390        let error = ResponseContent { status: status, content: content, entity: entity };
2391        Err(Error::ResponseError(error))
2392    }
2393}
2394
2395/// View the details of all of your current app API keys (Rich Authentication Token) for a single OneSignal app.
2396pub async fn view_api_keys(configuration: &configuration::Configuration, app_id: &str) -> Result<crate::models::ApiKeyTokensListResponse, Error<ViewApiKeysError>> {
2397    let configuration = configuration;
2398
2399    let client = &configuration.client;
2400
2401    let uri_str = format!("{}/apps/{app_id}/auth/tokens", configuration.base_path, app_id=crate::apis::urlencode(app_id));
2402    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2403
2404    if let Some(ref user_agent) = configuration.user_agent {
2405        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2406    }
2407
2408    // Adds a telemetry header
2409    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2410
2411    if let Some(ref token) = configuration.organization_api_key_token {
2412        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2413    }
2414
2415    let req = req_builder.build()?;
2416    let resp = client.execute(req).await?;
2417
2418    let status = resp.status();
2419    let content = resp.text().await?;
2420
2421    if !status.is_client_error() && !status.is_server_error() {
2422        serde_json::from_str(&content).map_err(Error::from)
2423    } else {
2424        let entity: Option<ViewApiKeysError> = serde_json::from_str(&content).ok();
2425        let error = ResponseContent { status: status, content: content, entity: entity };
2426        Err(Error::ResponseError(error))
2427    }
2428}
2429
2430/// The Journeys API is in beta. Endpoints and response fields can still change. Retrieve the full configuration of a single journey by its UUID, including its audience and node graph.
2431pub async fn view_journey(configuration: &configuration::Configuration, app_id: &str, journey_id: &str) -> Result<crate::models::Journey, Error<ViewJourneyError>> {
2432    let configuration = configuration;
2433
2434    let client = &configuration.client;
2435
2436    let uri_str = format!("{}/apps/{app_id}/journeys/{journey_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id), journey_id=crate::apis::urlencode(journey_id));
2437    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2438
2439    if let Some(ref user_agent) = configuration.user_agent {
2440        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2441    }
2442
2443    // Adds a telemetry header
2444    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2445
2446    if let Some(ref token) = configuration.rest_api_key_token {
2447        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2448    }
2449
2450    let req = req_builder.build()?;
2451    let resp = client.execute(req).await?;
2452
2453    let status = resp.status();
2454    let content = resp.text().await?;
2455
2456    if !status.is_client_error() && !status.is_server_error() {
2457        serde_json::from_str(&content).map_err(Error::from)
2458    } else {
2459        let entity: Option<ViewJourneyError> = serde_json::from_str(&content).ok();
2460        let error = ResponseContent { status: status, content: content, entity: entity };
2461        Err(Error::ResponseError(error))
2462    }
2463}
2464
2465/// The Journeys API is in beta. Endpoints and response fields can still change. Retrieve performance stats for a single journey: journey-level entry and exit counts, per-node counts keyed by node id, per-branch counts keyed by branch id, and channel delivery stats for message-sending nodes. The response carries no definition detail, so join it by id against the journey from View journey.
2466pub async fn view_journey_stats(configuration: &configuration::Configuration, app_id: &str, journey_id: &str) -> Result<crate::models::JourneyStats, Error<ViewJourneyStatsError>> {
2467    let configuration = configuration;
2468
2469    let client = &configuration.client;
2470
2471    let uri_str = format!("{}/apps/{app_id}/journeys/{journey_id}/stats", configuration.base_path, app_id=crate::apis::urlencode(app_id), journey_id=crate::apis::urlencode(journey_id));
2472    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2473
2474    if let Some(ref user_agent) = configuration.user_agent {
2475        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2476    }
2477
2478    // Adds a telemetry header
2479    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2480
2481    if let Some(ref token) = configuration.rest_api_key_token {
2482        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2483    }
2484
2485    let req = req_builder.build()?;
2486    let resp = client.execute(req).await?;
2487
2488    let status = resp.status();
2489    let content = resp.text().await?;
2490
2491    if !status.is_client_error() && !status.is_server_error() {
2492        serde_json::from_str(&content).map_err(Error::from)
2493    } else {
2494        let entity: Option<ViewJourneyStatsError> = serde_json::from_str(&content).ok();
2495        let error = ResponseContent { status: status, content: content, entity: entity };
2496        Err(Error::ResponseError(error))
2497    }
2498}
2499
2500/// The Journeys API is in beta. Endpoints and response fields can still change. Retrieve a paginated list of journeys for an app. Returns a summary representation of each journey; use View journey for the full configuration. Uses forward-only cursor-based pagination.
2501pub async fn view_journeys(configuration: &configuration::Configuration, app_id: &str, cursor: Option<&str>, limit: Option<i32>) -> Result<crate::models::JourneyListResponse, Error<ViewJourneysError>> {
2502    let configuration = configuration;
2503
2504    let client = &configuration.client;
2505
2506    let uri_str = format!("{}/apps/{app_id}/journeys", configuration.base_path, app_id=crate::apis::urlencode(app_id));
2507    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2508
2509    if let Some(ref str) = cursor {
2510        req_builder = req_builder.query(&[("cursor", &str.to_string())]);
2511    }
2512    if let Some(ref str) = limit {
2513        req_builder = req_builder.query(&[("limit", &str.to_string())]);
2514    }
2515    if let Some(ref user_agent) = configuration.user_agent {
2516        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2517    }
2518
2519    // Adds a telemetry header
2520    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2521
2522    if let Some(ref token) = configuration.rest_api_key_token {
2523        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2524    }
2525
2526    let req = req_builder.build()?;
2527    let resp = client.execute(req).await?;
2528
2529    let status = resp.status();
2530    let content = resp.text().await?;
2531
2532    if !status.is_client_error() && !status.is_server_error() {
2533        serde_json::from_str(&content).map_err(Error::from)
2534    } else {
2535        let entity: Option<ViewJourneysError> = serde_json::from_str(&content).ok();
2536        let error = ResponseContent { status: status, content: content, entity: entity };
2537        Err(Error::ResponseError(error))
2538    }
2539}
2540
2541/// Fetch a single template by id.
2542pub async fn view_template(configuration: &configuration::Configuration, template_id: &str, app_id: &str) -> Result<crate::models::TemplateResource, Error<ViewTemplateError>> {
2543    let configuration = configuration;
2544
2545    let client = &configuration.client;
2546
2547    let uri_str = format!("{}/templates/{template_id}", configuration.base_path, template_id=crate::apis::urlencode(template_id));
2548    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2549
2550    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
2551    if let Some(ref user_agent) = configuration.user_agent {
2552        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2553    }
2554
2555    // Adds a telemetry header
2556    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2557
2558    if let Some(ref token) = configuration.rest_api_key_token {
2559        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2560    }
2561
2562    let req = req_builder.build()?;
2563    let resp = client.execute(req).await?;
2564
2565    let status = resp.status();
2566    let content = resp.text().await?;
2567
2568    if !status.is_client_error() && !status.is_server_error() {
2569        serde_json::from_str(&content).map_err(Error::from)
2570    } else {
2571        let entity: Option<ViewTemplateError> = serde_json::from_str(&content).ok();
2572        let error = ResponseContent { status: status, content: content, entity: entity };
2573        Err(Error::ResponseError(error))
2574    }
2575}
2576
2577/// List templates for an app.
2578pub async fn view_templates(configuration: &configuration::Configuration, app_id: &str, limit: Option<i32>, offset: Option<i32>, channel: Option<&str>) -> Result<crate::models::TemplatesListResponse, Error<ViewTemplatesError>> {
2579    let configuration = configuration;
2580
2581    let client = &configuration.client;
2582
2583    let uri_str = format!("{}/templates", configuration.base_path);
2584    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2585
2586    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
2587    if let Some(ref str) = limit {
2588        req_builder = req_builder.query(&[("limit", &str.to_string())]);
2589    }
2590    if let Some(ref str) = offset {
2591        req_builder = req_builder.query(&[("offset", &str.to_string())]);
2592    }
2593    if let Some(ref str) = channel {
2594        req_builder = req_builder.query(&[("channel", &str.to_string())]);
2595    }
2596    if let Some(ref user_agent) = configuration.user_agent {
2597        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2598    }
2599
2600    // Adds a telemetry header
2601    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.13.0");
2602
2603    if let Some(ref token) = configuration.rest_api_key_token {
2604        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2605    }
2606
2607    let req = req_builder.build()?;
2608    let resp = client.execute(req).await?;
2609
2610    let status = resp.status();
2611    let content = resp.text().await?;
2612
2613    if !status.is_client_error() && !status.is_server_error() {
2614        serde_json::from_str(&content).map_err(Error::from)
2615    } else {
2616        let entity: Option<ViewTemplatesError> = serde_json::from_str(&content).ok();
2617        let error = ResponseContent { status: status, content: content, entity: entity };
2618        Err(Error::ResponseError(error))
2619    }
2620}
2621
onesignal_rust_api/apis/default_api.rs

onesignal_rust_api/apis/
default_api.rs
