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 [`estimate_notification_recipients`]
233#[derive(Debug, Clone, Serialize, Deserialize)]
234#[serde(untagged)]
235pub enum EstimateNotificationRecipientsError {
236    Status400(crate::models::GenericError),
237    Status429(crate::models::RateLimitError),
238    DefaultResponse(crate::models::GenericError),
239    UnknownValue(serde_json::Value),
240}
241
242/// struct for typed errors of method [`export_events`]
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum ExportEventsError {
246    Status400(crate::models::GenericError),
247    Status404(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 [`export_subscriptions`]
254#[derive(Debug, Clone, Serialize, Deserialize)]
255#[serde(untagged)]
256pub enum ExportSubscriptionsError {
257    Status400(crate::models::GenericError),
258    Status429(crate::models::RateLimitError),
259    DefaultResponse(crate::models::GenericError),
260    UnknownValue(serde_json::Value),
261}
262
263/// struct for typed errors of method [`get_aliases`]
264#[derive(Debug, Clone, Serialize, Deserialize)]
265#[serde(untagged)]
266pub enum GetAliasesError {
267    Status400(crate::models::GenericError),
268    Status404(crate::models::GenericError),
269    Status429(crate::models::RateLimitError),
270    DefaultResponse(crate::models::GenericError),
271    UnknownValue(serde_json::Value),
272}
273
274/// struct for typed errors of method [`get_aliases_by_subscription`]
275#[derive(Debug, Clone, Serialize, Deserialize)]
276#[serde(untagged)]
277pub enum GetAliasesBySubscriptionError {
278    Status400(crate::models::GenericError),
279    Status404(crate::models::GenericError),
280    DefaultResponse(crate::models::GenericError),
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`get_app`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum GetAppError {
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_apps`]
295#[derive(Debug, Clone, Serialize, Deserialize)]
296#[serde(untagged)]
297pub enum GetAppsError {
298    Status400(crate::models::GenericError),
299    Status429(crate::models::RateLimitError),
300    DefaultResponse(crate::models::GenericError),
301    UnknownValue(serde_json::Value),
302}
303
304/// struct for typed errors of method [`get_notification`]
305#[derive(Debug, Clone, Serialize, Deserialize)]
306#[serde(untagged)]
307pub enum GetNotificationError {
308    Status400(crate::models::GenericError),
309    Status404(crate::models::GenericError),
310    Status429(crate::models::RateLimitError),
311    DefaultResponse(crate::models::GenericError),
312    UnknownValue(serde_json::Value),
313}
314
315/// struct for typed errors of method [`get_notification_history`]
316#[derive(Debug, Clone, Serialize, Deserialize)]
317#[serde(untagged)]
318pub enum GetNotificationHistoryError {
319    Status400(crate::models::GenericError),
320    Status404(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_notifications`]
327#[derive(Debug, Clone, Serialize, Deserialize)]
328#[serde(untagged)]
329pub enum GetNotificationsError {
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_outcomes`]
337#[derive(Debug, Clone, Serialize, Deserialize)]
338#[serde(untagged)]
339pub enum GetOutcomesError {
340    Status400(crate::models::GenericError),
341    Status429(crate::models::RateLimitError),
342    DefaultResponse(crate::models::GenericError),
343    UnknownValue(serde_json::Value),
344}
345
346/// struct for typed errors of method [`get_segment`]
347#[derive(Debug, Clone, Serialize, Deserialize)]
348#[serde(untagged)]
349pub enum GetSegmentError {
350    Status400(crate::models::GenericError),
351    Status404(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_segments`]
358#[derive(Debug, Clone, Serialize, Deserialize)]
359#[serde(untagged)]
360pub enum GetSegmentsError {
361    Status400(crate::models::GenericError),
362    Status429(crate::models::RateLimitError),
363    DefaultResponse(crate::models::GenericError),
364    UnknownValue(serde_json::Value),
365}
366
367/// struct for typed errors of method [`get_user`]
368#[derive(Debug, Clone, Serialize, Deserialize)]
369#[serde(untagged)]
370pub enum GetUserError {
371    Status400(crate::models::GenericError),
372    Status404(crate::models::GenericError),
373    Status429(crate::models::RateLimitError),
374    DefaultResponse(crate::models::GenericError),
375    UnknownValue(serde_json::Value),
376}
377
378/// struct for typed errors of method [`list_audit_logs`]
379#[derive(Debug, Clone, Serialize, Deserialize)]
380#[serde(untagged)]
381pub enum ListAuditLogsError {
382    Status400(crate::models::GenericError),
383    Status403(crate::models::GenericError),
384    Status404(crate::models::GenericError),
385    Status429(crate::models::RateLimitError),
386    DefaultResponse(crate::models::GenericError),
387    UnknownValue(serde_json::Value),
388}
389
390/// struct for typed errors of method [`rotate_api_key`]
391#[derive(Debug, Clone, Serialize, Deserialize)]
392#[serde(untagged)]
393pub enum RotateApiKeyError {
394    Status400(crate::models::GenericError),
395    DefaultResponse(crate::models::GenericError),
396    UnknownValue(serde_json::Value),
397}
398
399/// struct for typed errors of method [`start_live_activity`]
400#[derive(Debug, Clone, Serialize, Deserialize)]
401#[serde(untagged)]
402pub enum StartLiveActivityError {
403    Status400(crate::models::GenericError),
404    Status429(crate::models::RateLimitError),
405    DefaultResponse(crate::models::GenericError),
406    UnknownValue(serde_json::Value),
407}
408
409/// struct for typed errors of method [`transfer_subscription`]
410#[derive(Debug, Clone, Serialize, Deserialize)]
411#[serde(untagged)]
412pub enum TransferSubscriptionError {
413    Status400(crate::models::GenericError),
414    Status404(crate::models::GenericError),
415    Status409(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 [`unsubscribe_email_with_token`]
422#[derive(Debug, Clone, Serialize, Deserialize)]
423#[serde(untagged)]
424pub enum UnsubscribeEmailWithTokenError {
425    Status400(crate::models::GenericError),
426    Status429(crate::models::RateLimitError),
427    DefaultResponse(crate::models::GenericError),
428    UnknownValue(serde_json::Value),
429}
430
431/// struct for typed errors of method [`update_api_key`]
432#[derive(Debug, Clone, Serialize, Deserialize)]
433#[serde(untagged)]
434pub enum UpdateApiKeyError {
435    Status400(crate::models::GenericError),
436    DefaultResponse(crate::models::GenericError),
437    UnknownValue(serde_json::Value),
438}
439
440/// struct for typed errors of method [`update_app`]
441#[derive(Debug, Clone, Serialize, Deserialize)]
442#[serde(untagged)]
443pub enum UpdateAppError {
444    Status400(crate::models::GenericError),
445    Status429(crate::models::RateLimitError),
446    DefaultResponse(crate::models::GenericError),
447    UnknownValue(serde_json::Value),
448}
449
450/// struct for typed errors of method [`update_journey`]
451#[derive(Debug, Clone, Serialize, Deserialize)]
452#[serde(untagged)]
453pub enum UpdateJourneyError {
454    Status400(crate::models::GenericError),
455    Status403(crate::models::GenericError),
456    Status404(crate::models::GenericError),
457    Status409(crate::models::GenericError),
458    Status422(crate::models::GenericError),
459    Status429(crate::models::RateLimitError),
460    DefaultResponse(crate::models::GenericError),
461    UnknownValue(serde_json::Value),
462}
463
464/// struct for typed errors of method [`update_journey_node`]
465#[derive(Debug, Clone, Serialize, Deserialize)]
466#[serde(untagged)]
467pub enum UpdateJourneyNodeError {
468    Status400(crate::models::GenericError),
469    Status403(crate::models::GenericError),
470    Status404(crate::models::GenericError),
471    Status409(crate::models::GenericError),
472    Status422(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_live_activity`]
479#[derive(Debug, Clone, Serialize, Deserialize)]
480#[serde(untagged)]
481pub enum UpdateLiveActivityError {
482    Status400(crate::models::GenericError),
483    Status429(crate::models::RateLimitError),
484    DefaultResponse(crate::models::GenericError),
485    UnknownValue(serde_json::Value),
486}
487
488/// struct for typed errors of method [`update_segment`]
489#[derive(Debug, Clone, Serialize, Deserialize)]
490#[serde(untagged)]
491pub enum UpdateSegmentError {
492    Status400(crate::models::GenericError),
493    Status403(crate::models::GenericError),
494    Status404(crate::models::GenericError),
495    Status429(crate::models::RateLimitError),
496    DefaultResponse(crate::models::GenericError),
497    UnknownValue(serde_json::Value),
498}
499
500/// struct for typed errors of method [`update_subscription`]
501#[derive(Debug, Clone, Serialize, Deserialize)]
502#[serde(untagged)]
503pub enum UpdateSubscriptionError {
504    Status400(crate::models::GenericError),
505    Status404(crate::models::GenericError),
506    Status409(crate::models::GenericError),
507    Status429(crate::models::RateLimitError),
508    DefaultResponse(crate::models::GenericError),
509    UnknownValue(serde_json::Value),
510}
511
512/// struct for typed errors of method [`update_subscription_by_token`]
513#[derive(Debug, Clone, Serialize, Deserialize)]
514#[serde(untagged)]
515pub enum UpdateSubscriptionByTokenError {
516    Status400(crate::models::GenericError),
517    Status404(crate::models::GenericError),
518    DefaultResponse(crate::models::GenericError),
519    UnknownValue(serde_json::Value),
520}
521
522/// struct for typed errors of method [`update_template`]
523#[derive(Debug, Clone, Serialize, Deserialize)]
524#[serde(untagged)]
525pub enum UpdateTemplateError {
526    Status400(crate::models::GenericError),
527    DefaultResponse(crate::models::GenericError),
528    UnknownValue(serde_json::Value),
529}
530
531/// struct for typed errors of method [`update_user`]
532#[derive(Debug, Clone, Serialize, Deserialize)]
533#[serde(untagged)]
534pub enum UpdateUserError {
535    Status400(crate::models::GenericError),
536    Status409(crate::models::GenericError),
537    Status429(crate::models::RateLimitError),
538    DefaultResponse(crate::models::GenericError),
539    UnknownValue(serde_json::Value),
540}
541
542/// struct for typed errors of method [`view_api_keys`]
543#[derive(Debug, Clone, Serialize, Deserialize)]
544#[serde(untagged)]
545pub enum ViewApiKeysError {
546    Status400(crate::models::GenericError),
547    DefaultResponse(crate::models::GenericError),
548    UnknownValue(serde_json::Value),
549}
550
551/// struct for typed errors of method [`view_journey`]
552#[derive(Debug, Clone, Serialize, Deserialize)]
553#[serde(untagged)]
554pub enum ViewJourneyError {
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_journey_stats`]
562#[derive(Debug, Clone, Serialize, Deserialize)]
563#[serde(untagged)]
564pub enum ViewJourneyStatsError {
565    Status404(crate::models::GenericError),
566    Status429(crate::models::RateLimitError),
567    DefaultResponse(crate::models::GenericError),
568    UnknownValue(serde_json::Value),
569}
570
571/// struct for typed errors of method [`view_journeys`]
572#[derive(Debug, Clone, Serialize, Deserialize)]
573#[serde(untagged)]
574pub enum ViewJourneysError {
575    Status400(crate::models::GenericError),
576    Status403(crate::models::GenericError),
577    Status429(crate::models::RateLimitError),
578    DefaultResponse(crate::models::GenericError),
579    UnknownValue(serde_json::Value),
580}
581
582/// struct for typed errors of method [`view_template`]
583#[derive(Debug, Clone, Serialize, Deserialize)]
584#[serde(untagged)]
585pub enum ViewTemplateError {
586    Status400(crate::models::GenericError),
587    Status404(crate::models::GenericError),
588    DefaultResponse(crate::models::GenericError),
589    UnknownValue(serde_json::Value),
590}
591
592/// struct for typed errors of method [`view_templates`]
593#[derive(Debug, Clone, Serialize, Deserialize)]
594#[serde(untagged)]
595pub enum ViewTemplatesError {
596    Status400(crate::models::GenericError),
597    Status429(crate::models::RateLimitError),
598    DefaultResponse(crate::models::GenericError),
599    UnknownValue(serde_json::Value),
600}
601
602
603/// Used to stop a scheduled or currently outgoing notification
604pub async fn cancel_notification(configuration: &configuration::Configuration, app_id: &str, notification_id: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<CancelNotificationError>> {
605    let configuration = configuration;
606
607    let client = &configuration.client;
608
609    let uri_str = format!("{}/notifications/{notification_id}", configuration.base_path, notification_id=crate::apis::urlencode(notification_id));
610    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
611
612    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
613    if let Some(ref user_agent) = configuration.user_agent {
614        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
615    }
616
617    // Adds a telemetry header
618    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
619
620    if let Some(ref token) = configuration.rest_api_key_token {
621        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
622    }
623
624    let req = req_builder.build()?;
625    let resp = client.execute(req).await?;
626
627    let status = resp.status();
628    let content = resp.text().await?;
629
630    if !status.is_client_error() && !status.is_server_error() {
631        serde_json::from_str(&content).map_err(Error::from)
632    } else {
633        let entity: Option<CancelNotificationError> = serde_json::from_str(&content).ok();
634        let error = ResponseContent { status: status, content: content, entity: entity };
635        Err(Error::ResponseError(error))
636    }
637}
638
639/// Copy a template to a destination app.
640pub 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>> {
641    let configuration = configuration;
642
643    let client = &configuration.client;
644
645    let uri_str = format!("{}/templates/{template_id}/copy_to_app", configuration.base_path, template_id=crate::apis::urlencode(template_id));
646    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
647
648    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
649    if let Some(ref user_agent) = configuration.user_agent {
650        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
651    }
652
653    // Adds a telemetry header
654    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
655
656    if let Some(ref token) = configuration.organization_api_key_token {
657        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
658    }
659    req_builder = req_builder.json(&copy_template_request);
660
661    let req = req_builder.build()?;
662    let resp = client.execute(req).await?;
663
664    let status = resp.status();
665    let content = resp.text().await?;
666
667    if !status.is_client_error() && !status.is_server_error() {
668        serde_json::from_str(&content).map_err(Error::from)
669    } else {
670        let entity: Option<CopyTemplateToAppError> = serde_json::from_str(&content).ok();
671        let error = ResponseContent { status: status, content: content, entity: entity };
672        Err(Error::ResponseError(error))
673    }
674}
675
676/// Upserts one or more Aliases to an existing User identified by (:alias_label, :alias_id).
677pub 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>> {
678    let configuration = configuration;
679
680    let client = &configuration.client;
681
682    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));
683    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
684
685    if let Some(ref user_agent) = configuration.user_agent {
686        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
687    }
688
689    // Adds a telemetry header
690    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
691
692    if let Some(ref token) = configuration.rest_api_key_token {
693        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
694    }
695    req_builder = req_builder.json(&user_identity_body);
696
697    let req = req_builder.build()?;
698    let resp = client.execute(req).await?;
699
700    let status = resp.status();
701    let content = resp.text().await?;
702
703    if !status.is_client_error() && !status.is_server_error() {
704        serde_json::from_str(&content).map_err(Error::from)
705    } else {
706        let entity: Option<CreateAliasError> = serde_json::from_str(&content).ok();
707        let error = ResponseContent { status: status, content: content, entity: entity };
708        Err(Error::ResponseError(error))
709    }
710}
711
712/// Upserts one or more Aliases for the User identified by :subscription_id.
713pub 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>> {
714    let configuration = configuration;
715
716    let client = &configuration.client;
717
718    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));
719    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
720
721    if let Some(ref user_agent) = configuration.user_agent {
722        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
723    }
724
725    // Adds a telemetry header
726    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
727
728    if let Some(ref token) = configuration.rest_api_key_token {
729        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
730    }
731    req_builder = req_builder.json(&user_identity_body);
732
733    let req = req_builder.build()?;
734    let resp = client.execute(req).await?;
735
736    let status = resp.status();
737    let content = resp.text().await?;
738
739    if !status.is_client_error() && !status.is_server_error() {
740        serde_json::from_str(&content).map_err(Error::from)
741    } else {
742        let entity: Option<CreateAliasBySubscriptionError> = serde_json::from_str(&content).ok();
743        let error = ResponseContent { status: status, content: content, entity: entity };
744        Err(Error::ResponseError(error))
745    }
746}
747
748/// 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.
749pub async fn create_api_key(configuration: &configuration::Configuration, app_id: &str, create_api_key_request: crate::models::CreateApiKeyRequest) -> Result<crate::models::CreateApiKeyResponse, Error<CreateApiKeyError>> {
750    let configuration = configuration;
751
752    let client = &configuration.client;
753
754    let uri_str = format!("{}/apps/{app_id}/auth/tokens", configuration.base_path, app_id=crate::apis::urlencode(app_id));
755    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
756
757    if let Some(ref user_agent) = configuration.user_agent {
758        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
759    }
760
761    // Adds a telemetry header
762    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
763
764    if let Some(ref token) = configuration.organization_api_key_token {
765        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
766    }
767    req_builder = req_builder.json(&create_api_key_request);
768
769    let req = req_builder.build()?;
770    let resp = client.execute(req).await?;
771
772    let status = resp.status();
773    let content = resp.text().await?;
774
775    if !status.is_client_error() && !status.is_server_error() {
776        serde_json::from_str(&content).map_err(Error::from)
777    } else {
778        let entity: Option<CreateApiKeyError> = serde_json::from_str(&content).ok();
779        let error = ResponseContent { status: status, content: content, entity: entity };
780        Err(Error::ResponseError(error))
781    }
782}
783
784/// Creates a new OneSignal app
785pub async fn create_app(configuration: &configuration::Configuration, app: crate::models::App) -> Result<crate::models::App, Error<CreateAppError>> {
786    let configuration = configuration;
787
788    let client = &configuration.client;
789
790    let uri_str = format!("{}/apps", configuration.base_path);
791    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
792
793    if let Some(ref user_agent) = configuration.user_agent {
794        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
795    }
796
797    // Adds a telemetry header
798    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
799
800    if let Some(ref token) = configuration.organization_api_key_token {
801        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
802    }
803    req_builder = req_builder.json(&app);
804
805    let req = req_builder.build()?;
806    let resp = client.execute(req).await?;
807
808    let status = resp.status();
809    let content = resp.text().await?;
810
811    if !status.is_client_error() && !status.is_server_error() {
812        serde_json::from_str(&content).map_err(Error::from)
813    } else {
814        let entity: Option<CreateAppError> = serde_json::from_str(&content).ok();
815        let error = ResponseContent { status: status, content: content, entity: entity };
816        Err(Error::ResponseError(error))
817    }
818}
819
820/// 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.
821pub async fn create_custom_events(configuration: &configuration::Configuration, app_id: &str, custom_events_request: crate::models::CustomEventsRequest) -> Result<serde_json::Value, Error<CreateCustomEventsError>> {
822    let configuration = configuration;
823
824    let client = &configuration.client;
825
826    let uri_str = format!("{}/apps/{app_id}/custom_events", configuration.base_path, app_id=crate::apis::urlencode(app_id));
827    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
828
829    if let Some(ref user_agent) = configuration.user_agent {
830        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
831    }
832
833    // Adds a telemetry header
834    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
835
836    if let Some(ref token) = configuration.rest_api_key_token {
837        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
838    }
839    req_builder = req_builder.json(&custom_events_request);
840
841    let req = req_builder.build()?;
842    let resp = client.execute(req).await?;
843
844    let status = resp.status();
845    let content = resp.text().await?;
846
847    if !status.is_client_error() && !status.is_server_error() {
848        serde_json::from_str(&content).map_err(Error::from)
849    } else {
850        let entity: Option<CreateCustomEventsError> = serde_json::from_str(&content).ok();
851        let error = ResponseContent { status: status, content: content, entity: entity };
852        Err(Error::ResponseError(error))
853    }
854}
855
856/// 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.
857pub async fn create_journey(configuration: &configuration::Configuration, app_id: &str, create_journey_request: crate::models::CreateJourneyRequest) -> Result<crate::models::Journey, Error<CreateJourneyError>> {
858    let configuration = configuration;
859
860    let client = &configuration.client;
861
862    let uri_str = format!("{}/apps/{app_id}/journeys", configuration.base_path, app_id=crate::apis::urlencode(app_id));
863    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
864
865    if let Some(ref user_agent) = configuration.user_agent {
866        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
867    }
868
869    // Adds a telemetry header
870    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
871
872    if let Some(ref token) = configuration.rest_api_key_token {
873        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
874    }
875    req_builder = req_builder.json(&create_journey_request);
876
877    let req = req_builder.build()?;
878    let resp = client.execute(req).await?;
879
880    let status = resp.status();
881    let content = resp.text().await?;
882
883    if !status.is_client_error() && !status.is_server_error() {
884        serde_json::from_str(&content).map_err(Error::from)
885    } else {
886        let entity: Option<CreateJourneyError> = serde_json::from_str(&content).ok();
887        let error = ResponseContent { status: status, content: content, entity: entity };
888        Err(Error::ResponseError(error))
889    }
890}
891
892/// 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. 
893pub async fn create_notification(configuration: &configuration::Configuration, notification: crate::models::Notification) -> Result<crate::models::CreateNotificationSuccessResponse, Error<CreateNotificationError>> {
894    let configuration = configuration;
895
896    let client = &configuration.client;
897
898    let uri_str = format!("{}/notifications", configuration.base_path);
899    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
900
901    if let Some(ref user_agent) = configuration.user_agent {
902        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
903    }
904
905    // Adds a telemetry header
906    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
907
908    if let Some(ref token) = configuration.rest_api_key_token {
909        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
910    }
911    req_builder = req_builder.json(&notification);
912
913    let req = req_builder.build()?;
914    let resp = client.execute(req).await?;
915
916    let status = resp.status();
917    let content = resp.text().await?;
918
919    if !status.is_client_error() && !status.is_server_error() {
920        serde_json::from_str(&content).map_err(Error::from)
921    } else {
922        let entity: Option<CreateNotificationError> = serde_json::from_str(&content).ok();
923        let error = ResponseContent { status: status, content: content, entity: entity };
924        Err(Error::ResponseError(error))
925    }
926}
927
928/// 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. 
929pub async fn create_segment(configuration: &configuration::Configuration, app_id: &str, segment: Option<crate::models::Segment>) -> Result<crate::models::CreateSegmentSuccessResponse, Error<CreateSegmentError>> {
930    let configuration = configuration;
931
932    let client = &configuration.client;
933
934    let uri_str = format!("{}/apps/{app_id}/segments", configuration.base_path, app_id=crate::apis::urlencode(app_id));
935    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
936
937    if let Some(ref user_agent) = configuration.user_agent {
938        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
939    }
940
941    // Adds a telemetry header
942    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
943
944    if let Some(ref token) = configuration.rest_api_key_token {
945        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
946    }
947    req_builder = req_builder.json(&segment);
948
949    let req = req_builder.build()?;
950    let resp = client.execute(req).await?;
951
952    let status = resp.status();
953    let content = resp.text().await?;
954
955    if !status.is_client_error() && !status.is_server_error() {
956        serde_json::from_str(&content).map_err(Error::from)
957    } else {
958        let entity: Option<CreateSegmentError> = serde_json::from_str(&content).ok();
959        let error = ResponseContent { status: status, content: content, entity: entity };
960        Err(Error::ResponseError(error))
961    }
962}
963
964/// Creates a new Subscription under the User provided. Useful to add email addresses and SMS numbers to the User.
965pub 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>> {
966    let configuration = configuration;
967
968    let client = &configuration.client;
969
970    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));
971    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
972
973    if let Some(ref user_agent) = configuration.user_agent {
974        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
975    }
976
977    // Adds a telemetry header
978    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
979
980    if let Some(ref token) = configuration.rest_api_key_token {
981        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
982    }
983    req_builder = req_builder.json(&subscription_body);
984
985    let req = req_builder.build()?;
986    let resp = client.execute(req).await?;
987
988    let status = resp.status();
989    let content = resp.text().await?;
990
991    if !status.is_client_error() && !status.is_server_error() {
992        serde_json::from_str(&content).map_err(Error::from)
993    } else {
994        let entity: Option<CreateSubscriptionError> = serde_json::from_str(&content).ok();
995        let error = ResponseContent { status: status, content: content, entity: entity };
996        Err(Error::ResponseError(error))
997    }
998}
999
1000/// Create reusable message templates for push, email, and SMS channels.
1001pub async fn create_template(configuration: &configuration::Configuration, create_template_request: crate::models::CreateTemplateRequest) -> Result<crate::models::TemplateResource, Error<CreateTemplateError>> {
1002    let configuration = configuration;
1003
1004    let client = &configuration.client;
1005
1006    let uri_str = format!("{}/templates", configuration.base_path);
1007    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1008
1009    if let Some(ref user_agent) = configuration.user_agent {
1010        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1011    }
1012
1013    // Adds a telemetry header
1014    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1015
1016    if let Some(ref token) = configuration.rest_api_key_token {
1017        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1018    }
1019    req_builder = req_builder.json(&create_template_request);
1020
1021    let req = req_builder.build()?;
1022    let resp = client.execute(req).await?;
1023
1024    let status = resp.status();
1025    let content = resp.text().await?;
1026
1027    if !status.is_client_error() && !status.is_server_error() {
1028        serde_json::from_str(&content).map_err(Error::from)
1029    } else {
1030        let entity: Option<CreateTemplateError> = serde_json::from_str(&content).ok();
1031        let error = ResponseContent { status: status, content: content, entity: entity };
1032        Err(Error::ResponseError(error))
1033    }
1034}
1035
1036/// 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.
1037pub async fn create_user(configuration: &configuration::Configuration, app_id: &str, user: crate::models::User) -> Result<crate::models::User, Error<CreateUserError>> {
1038    let configuration = configuration;
1039
1040    let client = &configuration.client;
1041
1042    let uri_str = format!("{}/apps/{app_id}/users", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1043    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1044
1045    if let Some(ref user_agent) = configuration.user_agent {
1046        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1047    }
1048
1049    // Adds a telemetry header
1050    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1051
1052    if let Some(ref token) = configuration.rest_api_key_token {
1053        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1054    }
1055    req_builder = req_builder.json(&user);
1056
1057    let req = req_builder.build()?;
1058    let resp = client.execute(req).await?;
1059
1060    let status = resp.status();
1061    let content = resp.text().await?;
1062
1063    if !status.is_client_error() && !status.is_server_error() {
1064        serde_json::from_str(&content).map_err(Error::from)
1065    } else {
1066        let entity: Option<CreateUserError> = serde_json::from_str(&content).ok();
1067        let error = ResponseContent { status: status, content: content, entity: entity };
1068        Err(Error::ResponseError(error))
1069    }
1070}
1071
1072/// Deletes an alias by alias label
1073pub 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>> {
1074    let configuration = configuration;
1075
1076    let client = &configuration.client;
1077
1078    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));
1079    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1080
1081    if let Some(ref user_agent) = configuration.user_agent {
1082        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1083    }
1084
1085    // Adds a telemetry header
1086    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1087
1088    if let Some(ref token) = configuration.rest_api_key_token {
1089        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1090    }
1091
1092    let req = req_builder.build()?;
1093    let resp = client.execute(req).await?;
1094
1095    let status = resp.status();
1096    let content = resp.text().await?;
1097
1098    if !status.is_client_error() && !status.is_server_error() {
1099        serde_json::from_str(&content).map_err(Error::from)
1100    } else {
1101        let entity: Option<DeleteAliasError> = serde_json::from_str(&content).ok();
1102        let error = ResponseContent { status: status, content: content, entity: entity };
1103        Err(Error::ResponseError(error))
1104    }
1105}
1106
1107/// 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.
1108pub async fn delete_api_key(configuration: &configuration::Configuration, app_id: &str, token_id: &str) -> Result<serde_json::Value, Error<DeleteApiKeyError>> {
1109    let configuration = configuration;
1110
1111    let client = &configuration.client;
1112
1113    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));
1114    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1115
1116    if let Some(ref user_agent) = configuration.user_agent {
1117        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1118    }
1119
1120    // Adds a telemetry header
1121    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1122
1123    if let Some(ref token) = configuration.organization_api_key_token {
1124        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1125    }
1126
1127    let req = req_builder.build()?;
1128    let resp = client.execute(req).await?;
1129
1130    let status = resp.status();
1131    let content = resp.text().await?;
1132
1133    if !status.is_client_error() && !status.is_server_error() {
1134        serde_json::from_str(&content).map_err(Error::from)
1135    } else {
1136        let entity: Option<DeleteApiKeyError> = serde_json::from_str(&content).ok();
1137        let error = ResponseContent { status: status, content: content, entity: entity };
1138        Err(Error::ResponseError(error))
1139    }
1140}
1141
1142/// 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.
1143pub async fn delete_journey(configuration: &configuration::Configuration, app_id: &str, journey_id: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<DeleteJourneyError>> {
1144    let configuration = configuration;
1145
1146    let client = &configuration.client;
1147
1148    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));
1149    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1150
1151    if let Some(ref user_agent) = configuration.user_agent {
1152        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1153    }
1154
1155    // Adds a telemetry header
1156    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1157
1158    if let Some(ref token) = configuration.rest_api_key_token {
1159        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1160    }
1161
1162    let req = req_builder.build()?;
1163    let resp = client.execute(req).await?;
1164
1165    let status = resp.status();
1166    let content = resp.text().await?;
1167
1168    if !status.is_client_error() && !status.is_server_error() {
1169        serde_json::from_str(&content).map_err(Error::from)
1170    } else {
1171        let entity: Option<DeleteJourneyError> = serde_json::from_str(&content).ok();
1172        let error = ResponseContent { status: status, content: content, entity: entity };
1173        Err(Error::ResponseError(error))
1174    }
1175}
1176
1177/// 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. 
1178pub async fn delete_segment(configuration: &configuration::Configuration, app_id: &str, segment_id: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<DeleteSegmentError>> {
1179    let configuration = configuration;
1180
1181    let client = &configuration.client;
1182
1183    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));
1184    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1185
1186    if let Some(ref user_agent) = configuration.user_agent {
1187        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1188    }
1189
1190    // Adds a telemetry header
1191    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1192
1193    if let Some(ref token) = configuration.rest_api_key_token {
1194        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1195    }
1196
1197    let req = req_builder.build()?;
1198    let resp = client.execute(req).await?;
1199
1200    let status = resp.status();
1201    let content = resp.text().await?;
1202
1203    if !status.is_client_error() && !status.is_server_error() {
1204        serde_json::from_str(&content).map_err(Error::from)
1205    } else {
1206        let entity: Option<DeleteSegmentError> = serde_json::from_str(&content).ok();
1207        let error = ResponseContent { status: status, content: content, entity: entity };
1208        Err(Error::ResponseError(error))
1209    }
1210}
1211
1212/// Deletes the Subscription.
1213pub async fn delete_subscription(configuration: &configuration::Configuration, app_id: &str, subscription_id: &str) -> Result<(), Error<DeleteSubscriptionError>> {
1214    let configuration = configuration;
1215
1216    let client = &configuration.client;
1217
1218    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));
1219    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1220
1221    if let Some(ref user_agent) = configuration.user_agent {
1222        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1223    }
1224
1225    // Adds a telemetry header
1226    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1227
1228    if let Some(ref token) = configuration.rest_api_key_token {
1229        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1230    }
1231
1232    let req = req_builder.build()?;
1233    let resp = client.execute(req).await?;
1234
1235    let status = resp.status();
1236    let content = resp.text().await?;
1237
1238    if !status.is_client_error() && !status.is_server_error() {
1239        Ok(())
1240    } else {
1241        let entity: Option<DeleteSubscriptionError> = serde_json::from_str(&content).ok();
1242        let error = ResponseContent { status: status, content: content, entity: entity };
1243        Err(Error::ResponseError(error))
1244    }
1245}
1246
1247/// Delete a template by id.
1248pub async fn delete_template(configuration: &configuration::Configuration, template_id: &str, app_id: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<DeleteTemplateError>> {
1249    let configuration = configuration;
1250
1251    let client = &configuration.client;
1252
1253    let uri_str = format!("{}/templates/{template_id}", configuration.base_path, template_id=crate::apis::urlencode(template_id));
1254    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1255
1256    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
1257    if let Some(ref user_agent) = configuration.user_agent {
1258        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1259    }
1260
1261    // Adds a telemetry header
1262    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1263
1264    if let Some(ref token) = configuration.rest_api_key_token {
1265        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1266    }
1267
1268    let req = req_builder.build()?;
1269    let resp = client.execute(req).await?;
1270
1271    let status = resp.status();
1272    let content = resp.text().await?;
1273
1274    if !status.is_client_error() && !status.is_server_error() {
1275        serde_json::from_str(&content).map_err(Error::from)
1276    } else {
1277        let entity: Option<DeleteTemplateError> = serde_json::from_str(&content).ok();
1278        let error = ResponseContent { status: status, content: content, entity: entity };
1279        Err(Error::ResponseError(error))
1280    }
1281}
1282
1283/// Removes the User identified by (:alias_label, :alias_id), and all Subscriptions and Aliases
1284pub async fn delete_user(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str) -> Result<(), Error<DeleteUserError>> {
1285    let configuration = configuration;
1286
1287    let client = &configuration.client;
1288
1289    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));
1290    let mut req_builder = client.request(reqwest::Method::DELETE, uri_str.as_str());
1291
1292    if let Some(ref user_agent) = configuration.user_agent {
1293        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1294    }
1295
1296    // Adds a telemetry header
1297    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1298
1299    if let Some(ref token) = configuration.rest_api_key_token {
1300        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1301    }
1302
1303    let req = req_builder.build()?;
1304    let resp = client.execute(req).await?;
1305
1306    let status = resp.status();
1307    let content = resp.text().await?;
1308
1309    if !status.is_client_error() && !status.is_server_error() {
1310        Ok(())
1311    } else {
1312        let entity: Option<DeleteUserError> = serde_json::from_str(&content).ok();
1313        let error = ResponseContent { status: status, content: content, entity: entity };
1314        Err(Error::ResponseError(error))
1315    }
1316}
1317
1318/// Returns the estimated number of recipients for a notification's targeting, without creating or sending anything. The returned `count` reflects the same audience-size estimate you would see under \"Choose your target audience\" when composing a message. It is based on the user targeting method you've set and the specific platforms the message is targeted to send to. This endpoint only supports a subset of targeting parameters: `included_segments` is required (its `\"All\"` shorthand targets every subscriber), and `excluded_segments`, `filters`, `include_aliases`, and `target_channel` narrow that audience further. Use `target_channel` to select platforms. `include_subscription_ids` and the other raw subscription id/token fields, and the individual `isIos` / `isAndroid` / etc. platform flags, are not supported. All other notification fields (content, delivery options, and so on) are accepted, but ignored. 
1319pub async fn estimate_notification_recipients(configuration: &configuration::Configuration, estimate_notification_recipients_request: crate::models::EstimateNotificationRecipientsRequest) -> Result<crate::models::EstimateNotificationRecipientsSuccessResponse, Error<EstimateNotificationRecipientsError>> {
1320    let configuration = configuration;
1321
1322    let client = &configuration.client;
1323
1324    let uri_str = format!("{}/notifications/count-unsaved", configuration.base_path);
1325    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1326
1327    if let Some(ref user_agent) = configuration.user_agent {
1328        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1329    }
1330
1331    // Adds a telemetry header
1332    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1333
1334    if let Some(ref token) = configuration.rest_api_key_token {
1335        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1336    }
1337    req_builder = req_builder.json(&estimate_notification_recipients_request);
1338
1339    let req = req_builder.build()?;
1340    let resp = client.execute(req).await?;
1341
1342    let status = resp.status();
1343    let content = resp.text().await?;
1344
1345    if !status.is_client_error() && !status.is_server_error() {
1346        serde_json::from_str(&content).map_err(Error::from)
1347    } else {
1348        let entity: Option<EstimateNotificationRecipientsError> = serde_json::from_str(&content).ok();
1349        let error = ResponseContent { status: status, content: content, entity: entity };
1350        Err(Error::ResponseError(error))
1351    }
1352}
1353
1354/// 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.
1355pub async fn export_events(configuration: &configuration::Configuration, notification_id: &str, app_id: &str) -> Result<crate::models::ExportEventsSuccessResponse, Error<ExportEventsError>> {
1356    let configuration = configuration;
1357
1358    let client = &configuration.client;
1359
1360    let uri_str = format!("{}/notifications/{notification_id}/export_events", configuration.base_path, notification_id=crate::apis::urlencode(notification_id));
1361    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1362
1363    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
1364    if let Some(ref user_agent) = configuration.user_agent {
1365        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1366    }
1367
1368    // Adds a telemetry header
1369    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1370
1371    if let Some(ref token) = configuration.rest_api_key_token {
1372        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1373    }
1374
1375    let req = req_builder.build()?;
1376    let resp = client.execute(req).await?;
1377
1378    let status = resp.status();
1379    let content = resp.text().await?;
1380
1381    if !status.is_client_error() && !status.is_server_error() {
1382        serde_json::from_str(&content).map_err(Error::from)
1383    } else {
1384        let entity: Option<ExportEventsError> = serde_json::from_str(&content).ok();
1385        let error = ResponseContent { status: status, content: content, entity: entity };
1386        Err(Error::ResponseError(error))
1387    }
1388}
1389
1390/// 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. | 
1391pub async fn export_subscriptions(configuration: &configuration::Configuration, app_id: &str, export_subscriptions_request_body: Option<crate::models::ExportSubscriptionsRequestBody>) -> Result<crate::models::ExportSubscriptionsSuccessResponse, Error<ExportSubscriptionsError>> {
1392    let configuration = configuration;
1393
1394    let client = &configuration.client;
1395
1396    let uri_str = format!("{}/players/csv_export?app_id={app_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1397    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1398
1399    if let Some(ref user_agent) = configuration.user_agent {
1400        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1401    }
1402
1403    // Adds a telemetry header
1404    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1405
1406    if let Some(ref token) = configuration.rest_api_key_token {
1407        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1408    }
1409    req_builder = req_builder.json(&export_subscriptions_request_body);
1410
1411    let req = req_builder.build()?;
1412    let resp = client.execute(req).await?;
1413
1414    let status = resp.status();
1415    let content = resp.text().await?;
1416
1417    if !status.is_client_error() && !status.is_server_error() {
1418        serde_json::from_str(&content).map_err(Error::from)
1419    } else {
1420        let entity: Option<ExportSubscriptionsError> = serde_json::from_str(&content).ok();
1421        let error = ResponseContent { status: status, content: content, entity: entity };
1422        Err(Error::ResponseError(error))
1423    }
1424}
1425
1426/// Lists all Aliases for the User identified by (:alias_label, :alias_id).
1427pub async fn get_aliases(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str) -> Result<crate::models::UserIdentityBody, Error<GetAliasesError>> {
1428    let configuration = configuration;
1429
1430    let client = &configuration.client;
1431
1432    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));
1433    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1434
1435    if let Some(ref user_agent) = configuration.user_agent {
1436        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1437    }
1438
1439    // Adds a telemetry header
1440    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1441
1442    if let Some(ref token) = configuration.rest_api_key_token {
1443        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1444    }
1445
1446    let req = req_builder.build()?;
1447    let resp = client.execute(req).await?;
1448
1449    let status = resp.status();
1450    let content = resp.text().await?;
1451
1452    if !status.is_client_error() && !status.is_server_error() {
1453        serde_json::from_str(&content).map_err(Error::from)
1454    } else {
1455        let entity: Option<GetAliasesError> = serde_json::from_str(&content).ok();
1456        let error = ResponseContent { status: status, content: content, entity: entity };
1457        Err(Error::ResponseError(error))
1458    }
1459}
1460
1461/// Lists all Aliases for the User identified by :subscription_id.
1462pub async fn get_aliases_by_subscription(configuration: &configuration::Configuration, app_id: &str, subscription_id: &str) -> Result<crate::models::UserIdentityBody, Error<GetAliasesBySubscriptionError>> {
1463    let configuration = configuration;
1464
1465    let client = &configuration.client;
1466
1467    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));
1468    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1469
1470    if let Some(ref user_agent) = configuration.user_agent {
1471        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1472    }
1473
1474    // Adds a telemetry header
1475    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1476
1477    if let Some(ref token) = configuration.rest_api_key_token {
1478        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1479    }
1480
1481    let req = req_builder.build()?;
1482    let resp = client.execute(req).await?;
1483
1484    let status = resp.status();
1485    let content = resp.text().await?;
1486
1487    if !status.is_client_error() && !status.is_server_error() {
1488        serde_json::from_str(&content).map_err(Error::from)
1489    } else {
1490        let entity: Option<GetAliasesBySubscriptionError> = serde_json::from_str(&content).ok();
1491        let error = ResponseContent { status: status, content: content, entity: entity };
1492        Err(Error::ResponseError(error))
1493    }
1494}
1495
1496/// View the details of a single OneSignal app
1497pub async fn get_app(configuration: &configuration::Configuration, app_id: &str) -> Result<crate::models::App, Error<GetAppError>> {
1498    let configuration = configuration;
1499
1500    let client = &configuration.client;
1501
1502    let uri_str = format!("{}/apps/{app_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1503    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1504
1505    if let Some(ref user_agent) = configuration.user_agent {
1506        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1507    }
1508
1509    // Adds a telemetry header
1510    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1511
1512    if let Some(ref token) = configuration.organization_api_key_token {
1513        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1514    }
1515
1516    let req = req_builder.build()?;
1517    let resp = client.execute(req).await?;
1518
1519    let status = resp.status();
1520    let content = resp.text().await?;
1521
1522    if !status.is_client_error() && !status.is_server_error() {
1523        serde_json::from_str(&content).map_err(Error::from)
1524    } else {
1525        let entity: Option<GetAppError> = serde_json::from_str(&content).ok();
1526        let error = ResponseContent { status: status, content: content, entity: entity };
1527        Err(Error::ResponseError(error))
1528    }
1529}
1530
1531/// View the details of all of your current OneSignal apps
1532pub async fn get_apps(configuration: &configuration::Configuration, ) -> Result<Vec<crate::models::App>, Error<GetAppsError>> {
1533    let configuration = configuration;
1534
1535    let client = &configuration.client;
1536
1537    let uri_str = format!("{}/apps", configuration.base_path);
1538    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1539
1540    if let Some(ref user_agent) = configuration.user_agent {
1541        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1542    }
1543
1544    // Adds a telemetry header
1545    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1546
1547    if let Some(ref token) = configuration.organization_api_key_token {
1548        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1549    }
1550
1551    let req = req_builder.build()?;
1552    let resp = client.execute(req).await?;
1553
1554    let status = resp.status();
1555    let content = resp.text().await?;
1556
1557    if !status.is_client_error() && !status.is_server_error() {
1558        serde_json::from_str(&content).map_err(Error::from)
1559    } else {
1560        let entity: Option<GetAppsError> = serde_json::from_str(&content).ok();
1561        let error = ResponseContent { status: status, content: content, entity: entity };
1562        Err(Error::ResponseError(error))
1563    }
1564}
1565
1566/// View the details of a single notification and outcomes associated with it
1567pub async fn get_notification(configuration: &configuration::Configuration, app_id: &str, notification_id: &str) -> Result<crate::models::NotificationWithMeta, Error<GetNotificationError>> {
1568    let configuration = configuration;
1569
1570    let client = &configuration.client;
1571
1572    let uri_str = format!("{}/notifications/{notification_id}", configuration.base_path, notification_id=crate::apis::urlencode(notification_id));
1573    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1574
1575    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
1576    if let Some(ref user_agent) = configuration.user_agent {
1577        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1578    }
1579
1580    // Adds a telemetry header
1581    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1582
1583    if let Some(ref token) = configuration.rest_api_key_token {
1584        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1585    }
1586
1587    let req = req_builder.build()?;
1588    let resp = client.execute(req).await?;
1589
1590    let status = resp.status();
1591    let content = resp.text().await?;
1592
1593    if !status.is_client_error() && !status.is_server_error() {
1594        serde_json::from_str(&content).map_err(Error::from)
1595    } else {
1596        let entity: Option<GetNotificationError> = serde_json::from_str(&content).ok();
1597        let error = ResponseContent { status: status, content: content, entity: entity };
1598        Err(Error::ResponseError(error))
1599    }
1600}
1601
1602/// -> 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.
1603pub 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>> {
1604    let configuration = configuration;
1605
1606    let client = &configuration.client;
1607
1608    let uri_str = format!("{}/notifications/{notification_id}/history", configuration.base_path, notification_id=crate::apis::urlencode(notification_id));
1609    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1610
1611    if let Some(ref user_agent) = configuration.user_agent {
1612        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1613    }
1614
1615    // Adds a telemetry header
1616    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1617
1618    if let Some(ref token) = configuration.rest_api_key_token {
1619        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1620    }
1621    req_builder = req_builder.json(&get_notification_history_request_body);
1622
1623    let req = req_builder.build()?;
1624    let resp = client.execute(req).await?;
1625
1626    let status = resp.status();
1627    let content = resp.text().await?;
1628
1629    if !status.is_client_error() && !status.is_server_error() {
1630        serde_json::from_str(&content).map_err(Error::from)
1631    } else {
1632        let entity: Option<GetNotificationHistoryError> = serde_json::from_str(&content).ok();
1633        let error = ResponseContent { status: status, content: content, entity: entity };
1634        Err(Error::ResponseError(error))
1635    }
1636}
1637
1638/// View the details of multiple notifications
1639pub 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>> {
1640    let configuration = configuration;
1641
1642    let client = &configuration.client;
1643
1644    let uri_str = format!("{}/notifications", configuration.base_path);
1645    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1646
1647    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
1648    if let Some(ref str) = limit {
1649        req_builder = req_builder.query(&[("limit", &str.to_string())]);
1650    }
1651    if let Some(ref str) = offset {
1652        req_builder = req_builder.query(&[("offset", &str.to_string())]);
1653    }
1654    if let Some(ref str) = kind {
1655        req_builder = req_builder.query(&[("kind", &str.to_string())]);
1656    }
1657    if let Some(ref str) = time_offset {
1658        req_builder = req_builder.query(&[("time_offset", &str.to_string())]);
1659    }
1660    if let Some(ref user_agent) = configuration.user_agent {
1661        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1662    }
1663
1664    // Adds a telemetry header
1665    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1666
1667    if let Some(ref token) = configuration.rest_api_key_token {
1668        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1669    }
1670
1671    let req = req_builder.build()?;
1672    let resp = client.execute(req).await?;
1673
1674    let status = resp.status();
1675    let content = resp.text().await?;
1676
1677    if !status.is_client_error() && !status.is_server_error() {
1678        serde_json::from_str(&content).map_err(Error::from)
1679    } else {
1680        let entity: Option<GetNotificationsError> = serde_json::from_str(&content).ok();
1681        let error = ResponseContent { status: status, content: content, entity: entity };
1682        Err(Error::ResponseError(error))
1683    }
1684}
1685
1686/// 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. 
1687pub 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>> {
1688    let configuration = configuration;
1689
1690    let client = &configuration.client;
1691
1692    let uri_str = format!("{}/apps/{app_id}/outcomes", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1693    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1694
1695    req_builder = req_builder.query(&[("outcome_names", &outcome_names.to_string())]);
1696    if let Some(ref str) = outcome_names2 {
1697        req_builder = req_builder.query(&[("outcome_names[]", &str.to_string())]);
1698    }
1699    if let Some(ref str) = outcome_time_range {
1700        req_builder = req_builder.query(&[("outcome_time_range", &str.to_string())]);
1701    }
1702    if let Some(ref str) = outcome_platforms {
1703        req_builder = req_builder.query(&[("outcome_platforms", &str.to_string())]);
1704    }
1705    if let Some(ref str) = outcome_attribution {
1706        req_builder = req_builder.query(&[("outcome_attribution", &str.to_string())]);
1707    }
1708    if let Some(ref user_agent) = configuration.user_agent {
1709        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1710    }
1711
1712    // Adds a telemetry header
1713    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1714
1715    if let Some(ref token) = configuration.rest_api_key_token {
1716        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1717    }
1718
1719    let req = req_builder.build()?;
1720    let resp = client.execute(req).await?;
1721
1722    let status = resp.status();
1723    let content = resp.text().await?;
1724
1725    if !status.is_client_error() && !status.is_server_error() {
1726        serde_json::from_str(&content).map_err(Error::from)
1727    } else {
1728        let entity: Option<GetOutcomesError> = serde_json::from_str(&content).ok();
1729        let error = ResponseContent { status: status, content: content, entity: entity };
1730        Err(Error::ResponseError(error))
1731    }
1732}
1733
1734/// Retrieve details for a single segment by its ID, including subscriber count and optionally segment metadata and filters.
1735pub async fn get_segment(configuration: &configuration::Configuration, app_id: &str, segment_id: &str, include_segment_detail: Option<bool>) -> Result<crate::models::GetSegmentSuccessResponse, Error<GetSegmentError>> {
1736    let configuration = configuration;
1737
1738    let client = &configuration.client;
1739
1740    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));
1741    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1742
1743    if let Some(ref str) = include_segment_detail {
1744        req_builder = req_builder.query(&[("include-segment-detail", &str.to_string())]);
1745    }
1746    if let Some(ref user_agent) = configuration.user_agent {
1747        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1748    }
1749
1750    // Adds a telemetry header
1751    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1752
1753    if let Some(ref token) = configuration.rest_api_key_token {
1754        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1755    }
1756
1757    let req = req_builder.build()?;
1758    let resp = client.execute(req).await?;
1759
1760    let status = resp.status();
1761    let content = resp.text().await?;
1762
1763    if !status.is_client_error() && !status.is_server_error() {
1764        serde_json::from_str(&content).map_err(Error::from)
1765    } else {
1766        let entity: Option<GetSegmentError> = serde_json::from_str(&content).ok();
1767        let error = ResponseContent { status: status, content: content, entity: entity };
1768        Err(Error::ResponseError(error))
1769    }
1770}
1771
1772/// Returns an array of segments from an app.
1773pub async fn get_segments(configuration: &configuration::Configuration, app_id: &str, offset: Option<i32>, limit: Option<i32>) -> Result<crate::models::GetSegmentsSuccessResponse, Error<GetSegmentsError>> {
1774    let configuration = configuration;
1775
1776    let client = &configuration.client;
1777
1778    let uri_str = format!("{}/apps/{app_id}/segments", configuration.base_path, app_id=crate::apis::urlencode(app_id));
1779    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1780
1781    if let Some(ref str) = offset {
1782        req_builder = req_builder.query(&[("offset", &str.to_string())]);
1783    }
1784    if let Some(ref str) = limit {
1785        req_builder = req_builder.query(&[("limit", &str.to_string())]);
1786    }
1787    if let Some(ref user_agent) = configuration.user_agent {
1788        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1789    }
1790
1791    // Adds a telemetry header
1792    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1793
1794    if let Some(ref token) = configuration.rest_api_key_token {
1795        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1796    }
1797
1798    let req = req_builder.build()?;
1799    let resp = client.execute(req).await?;
1800
1801    let status = resp.status();
1802    let content = resp.text().await?;
1803
1804    if !status.is_client_error() && !status.is_server_error() {
1805        serde_json::from_str(&content).map_err(Error::from)
1806    } else {
1807        let entity: Option<GetSegmentsError> = serde_json::from_str(&content).ok();
1808        let error = ResponseContent { status: status, content: content, entity: entity };
1809        Err(Error::ResponseError(error))
1810    }
1811}
1812
1813/// Returns the User’s properties, Aliases, and Subscriptions.
1814pub async fn get_user(configuration: &configuration::Configuration, app_id: &str, alias_label: &str, alias_id: &str) -> Result<crate::models::User, Error<GetUserError>> {
1815    let configuration = configuration;
1816
1817    let client = &configuration.client;
1818
1819    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));
1820    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1821
1822    if let Some(ref user_agent) = configuration.user_agent {
1823        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1824    }
1825
1826    // Adds a telemetry header
1827    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1828
1829    if let Some(ref token) = configuration.rest_api_key_token {
1830        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1831    }
1832
1833    let req = req_builder.build()?;
1834    let resp = client.execute(req).await?;
1835
1836    let status = resp.status();
1837    let content = resp.text().await?;
1838
1839    if !status.is_client_error() && !status.is_server_error() {
1840        serde_json::from_str(&content).map_err(Error::from)
1841    } else {
1842        let entity: Option<GetUserError> = serde_json::from_str(&content).ok();
1843        let error = ResponseContent { status: status, content: content, entity: entity };
1844        Err(Error::ResponseError(error))
1845    }
1846}
1847
1848/// Retrieve a paginated, time-scoped list of audit log events for an organization. Requires an Enterprise plan with the audit logs entitlement enabled.
1849pub 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>> {
1850    let configuration = configuration;
1851
1852    let client = &configuration.client;
1853
1854    let uri_str = format!("{}/organizations/{organization_id}/audit_logs", configuration.base_path, organization_id=crate::apis::urlencode(organization_id));
1855    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
1856
1857    if let Some(ref str) = start_time {
1858        req_builder = req_builder.query(&[("start_time", &str.to_string())]);
1859    }
1860    if let Some(ref str) = end_time {
1861        req_builder = req_builder.query(&[("end_time", &str.to_string())]);
1862    }
1863    if let Some(ref str) = cursor {
1864        req_builder = req_builder.query(&[("cursor", &str.to_string())]);
1865    }
1866    if let Some(ref str) = limit {
1867        req_builder = req_builder.query(&[("limit", &str.to_string())]);
1868    }
1869    if let Some(ref str) = app_ids {
1870        req_builder = match "multi" {
1871            "multi" => req_builder.query(&str.into_iter().map(|p| ("app_ids".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1872            _ => req_builder.query(&[("app_ids", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1873        };
1874    }
1875    if let Some(ref str) = actions {
1876        req_builder = match "multi" {
1877            "multi" => req_builder.query(&str.into_iter().map(|p| ("actions".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1878            _ => req_builder.query(&[("actions", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1879        };
1880    }
1881    if let Some(ref str) = actor_ids {
1882        req_builder = match "multi" {
1883            "multi" => req_builder.query(&str.into_iter().map(|p| ("actor_ids".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1884            _ => req_builder.query(&[("actor_ids", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1885        };
1886    }
1887    if let Some(ref str) = actor_emails {
1888        req_builder = match "multi" {
1889            "multi" => req_builder.query(&str.into_iter().map(|p| ("actor_emails".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1890            _ => req_builder.query(&[("actor_emails", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1891        };
1892    }
1893    if let Some(ref str) = target_types {
1894        req_builder = match "multi" {
1895            "multi" => req_builder.query(&str.into_iter().map(|p| ("target_types".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1896            _ => req_builder.query(&[("target_types", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1897        };
1898    }
1899    if let Some(ref str) = target_ids {
1900        req_builder = match "multi" {
1901            "multi" => req_builder.query(&str.into_iter().map(|p| ("target_ids".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1902            _ => req_builder.query(&[("target_ids", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1903        };
1904    }
1905    if let Some(ref str) = ip_addresses {
1906        req_builder = match "multi" {
1907            "multi" => req_builder.query(&str.into_iter().map(|p| ("ip_addresses".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
1908            _ => req_builder.query(&[("ip_addresses", &str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
1909        };
1910    }
1911    if let Some(ref user_agent) = configuration.user_agent {
1912        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1913    }
1914
1915    // Adds a telemetry header
1916    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1917
1918    if let Some(ref token) = configuration.organization_api_key_token {
1919        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1920    }
1921
1922    let req = req_builder.build()?;
1923    let resp = client.execute(req).await?;
1924
1925    let status = resp.status();
1926    let content = resp.text().await?;
1927
1928    if !status.is_client_error() && !status.is_server_error() {
1929        serde_json::from_str(&content).map_err(Error::from)
1930    } else {
1931        let entity: Option<ListAuditLogsError> = serde_json::from_str(&content).ok();
1932        let error = ResponseContent { status: status, content: content, entity: entity };
1933        Err(Error::ResponseError(error))
1934    }
1935}
1936
1937/// 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.
1938pub async fn rotate_api_key(configuration: &configuration::Configuration, app_id: &str, token_id: &str) -> Result<crate::models::CreateApiKeyResponse, Error<RotateApiKeyError>> {
1939    let configuration = configuration;
1940
1941    let client = &configuration.client;
1942
1943    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));
1944    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1945
1946    if let Some(ref user_agent) = configuration.user_agent {
1947        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1948    }
1949
1950    // Adds a telemetry header
1951    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1952
1953    if let Some(ref token) = configuration.organization_api_key_token {
1954        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1955    }
1956
1957    let req = req_builder.build()?;
1958    let resp = client.execute(req).await?;
1959
1960    let status = resp.status();
1961    let content = resp.text().await?;
1962
1963    if !status.is_client_error() && !status.is_server_error() {
1964        serde_json::from_str(&content).map_err(Error::from)
1965    } else {
1966        let entity: Option<RotateApiKeyError> = serde_json::from_str(&content).ok();
1967        let error = ResponseContent { status: status, content: content, entity: entity };
1968        Err(Error::ResponseError(error))
1969    }
1970}
1971
1972/// Remotely start a Live Activity on iOS devices via OneSignal’s REST API.
1973pub 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>> {
1974    let configuration = configuration;
1975
1976    let client = &configuration.client;
1977
1978    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));
1979    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
1980
1981    if let Some(ref user_agent) = configuration.user_agent {
1982        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1983    }
1984
1985    // Adds a telemetry header
1986    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
1987
1988    if let Some(ref token) = configuration.rest_api_key_token {
1989        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
1990    }
1991    req_builder = req_builder.json(&start_live_activity_request);
1992
1993    let req = req_builder.build()?;
1994    let resp = client.execute(req).await?;
1995
1996    let status = resp.status();
1997    let content = resp.text().await?;
1998
1999    if !status.is_client_error() && !status.is_server_error() {
2000        serde_json::from_str(&content).map_err(Error::from)
2001    } else {
2002        let entity: Option<StartLiveActivityError> = serde_json::from_str(&content).ok();
2003        let error = ResponseContent { status: status, content: content, entity: entity };
2004        Err(Error::ResponseError(error))
2005    }
2006}
2007
2008/// Transfers this Subscription to the User identified by the identity in the payload.
2009pub 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>> {
2010    let configuration = configuration;
2011
2012    let client = &configuration.client;
2013
2014    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));
2015    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2016
2017    if let Some(ref user_agent) = configuration.user_agent {
2018        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2019    }
2020
2021    // Adds a telemetry header
2022    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2023
2024    if let Some(ref token) = configuration.rest_api_key_token {
2025        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2026    }
2027    req_builder = req_builder.json(&transfer_subscription_request_body);
2028
2029    let req = req_builder.build()?;
2030    let resp = client.execute(req).await?;
2031
2032    let status = resp.status();
2033    let content = resp.text().await?;
2034
2035    if !status.is_client_error() && !status.is_server_error() {
2036        serde_json::from_str(&content).map_err(Error::from)
2037    } else {
2038        let entity: Option<TransferSubscriptionError> = serde_json::from_str(&content).ok();
2039        let error = ResponseContent { status: status, content: content, entity: entity };
2040        Err(Error::ResponseError(error))
2041    }
2042}
2043
2044/// Unsubscribe an email with a token when using your own custom email unsubscribe landing page
2045pub async fn unsubscribe_email_with_token(configuration: &configuration::Configuration, app_id: &str, notification_id: &str, token: &str) -> Result<crate::models::GenericSuccessBoolResponse, Error<UnsubscribeEmailWithTokenError>> {
2046    let configuration = configuration;
2047
2048    let client = &configuration.client;
2049
2050    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));
2051    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
2052
2053    req_builder = req_builder.query(&[("token", &token.to_string())]);
2054    if let Some(ref user_agent) = configuration.user_agent {
2055        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2056    }
2057
2058    // Adds a telemetry header
2059    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2060
2061    if let Some(ref token) = configuration.rest_api_key_token {
2062        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2063    }
2064
2065    let req = req_builder.build()?;
2066    let resp = client.execute(req).await?;
2067
2068    let status = resp.status();
2069    let content = resp.text().await?;
2070
2071    if !status.is_client_error() && !status.is_server_error() {
2072        serde_json::from_str(&content).map_err(Error::from)
2073    } else {
2074        let entity: Option<UnsubscribeEmailWithTokenError> = serde_json::from_str(&content).ok();
2075        let error = ResponseContent { status: status, content: content, entity: entity };
2076        Err(Error::ResponseError(error))
2077    }
2078}
2079
2080/// Update a Rich Authentication Token (App API Key) for a OneSignal app.
2081pub 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>> {
2082    let configuration = configuration;
2083
2084    let client = &configuration.client;
2085
2086    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));
2087    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2088
2089    if let Some(ref user_agent) = configuration.user_agent {
2090        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2091    }
2092
2093    // Adds a telemetry header
2094    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2095
2096    if let Some(ref token) = configuration.organization_api_key_token {
2097        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2098    }
2099    req_builder = req_builder.json(&update_api_key_request);
2100
2101    let req = req_builder.build()?;
2102    let resp = client.execute(req).await?;
2103
2104    let status = resp.status();
2105    let content = resp.text().await?;
2106
2107    if !status.is_client_error() && !status.is_server_error() {
2108        serde_json::from_str(&content).map_err(Error::from)
2109    } else {
2110        let entity: Option<UpdateApiKeyError> = serde_json::from_str(&content).ok();
2111        let error = ResponseContent { status: status, content: content, entity: entity };
2112        Err(Error::ResponseError(error))
2113    }
2114}
2115
2116/// Updates the name or configuration settings of an existing OneSignal app
2117pub async fn update_app(configuration: &configuration::Configuration, app_id: &str, app: crate::models::App) -> Result<crate::models::App, Error<UpdateAppError>> {
2118    let configuration = configuration;
2119
2120    let client = &configuration.client;
2121
2122    let uri_str = format!("{}/apps/{app_id}", configuration.base_path, app_id=crate::apis::urlencode(app_id));
2123    let mut req_builder = client.request(reqwest::Method::PUT, uri_str.as_str());
2124
2125    if let Some(ref user_agent) = configuration.user_agent {
2126        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2127    }
2128
2129    // Adds a telemetry header
2130    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2131
2132    if let Some(ref token) = configuration.organization_api_key_token {
2133        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2134    }
2135    req_builder = req_builder.json(&app);
2136
2137    let req = req_builder.build()?;
2138    let resp = client.execute(req).await?;
2139
2140    let status = resp.status();
2141    let content = resp.text().await?;
2142
2143    if !status.is_client_error() && !status.is_server_error() {
2144        serde_json::from_str(&content).map_err(Error::from)
2145    } else {
2146        let entity: Option<UpdateAppError> = serde_json::from_str(&content).ok();
2147        let error = ResponseContent { status: status, content: content, entity: entity };
2148        Err(Error::ResponseError(error))
2149    }
2150}
2151
2152/// 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.
2153pub 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>> {
2154    let configuration = configuration;
2155
2156    let client = &configuration.client;
2157
2158    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));
2159    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2160
2161    if let Some(ref user_agent) = configuration.user_agent {
2162        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2163    }
2164
2165    // Adds a telemetry header
2166    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2167
2168    if let Some(ref token) = configuration.rest_api_key_token {
2169        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2170    }
2171    req_builder = req_builder.json(&update_journey_request);
2172
2173    let req = req_builder.build()?;
2174    let resp = client.execute(req).await?;
2175
2176    let status = resp.status();
2177    let content = resp.text().await?;
2178
2179    if !status.is_client_error() && !status.is_server_error() {
2180        serde_json::from_str(&content).map_err(Error::from)
2181    } else {
2182        let entity: Option<UpdateJourneyError> = serde_json::from_str(&content).ok();
2183        let error = ResponseContent { status: status, content: content, entity: entity };
2184        Err(Error::ResponseError(error))
2185    }
2186}
2187
2188/// 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.
2189pub 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>> {
2190    let configuration = configuration;
2191
2192    let client = &configuration.client;
2193
2194    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));
2195    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2196
2197    if let Some(ref user_agent) = configuration.user_agent {
2198        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2199    }
2200
2201    // Adds a telemetry header
2202    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2203
2204    if let Some(ref token) = configuration.rest_api_key_token {
2205        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2206    }
2207    req_builder = req_builder.json(&update_journey_node_request);
2208
2209    let req = req_builder.build()?;
2210    let resp = client.execute(req).await?;
2211
2212    let status = resp.status();
2213    let content = resp.text().await?;
2214
2215    if !status.is_client_error() && !status.is_server_error() {
2216        serde_json::from_str(&content).map_err(Error::from)
2217    } else {
2218        let entity: Option<UpdateJourneyNodeError> = serde_json::from_str(&content).ok();
2219        let error = ResponseContent { status: status, content: content, entity: entity };
2220        Err(Error::ResponseError(error))
2221    }
2222}
2223
2224/// Updates a specified live activity.
2225pub 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>> {
2226    let configuration = configuration;
2227
2228    let client = &configuration.client;
2229
2230    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));
2231    let mut req_builder = client.request(reqwest::Method::POST, uri_str.as_str());
2232
2233    if let Some(ref user_agent) = configuration.user_agent {
2234        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2235    }
2236
2237    // Adds a telemetry header
2238    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2239
2240    if let Some(ref token) = configuration.rest_api_key_token {
2241        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2242    }
2243    req_builder = req_builder.json(&update_live_activity_request);
2244
2245    let req = req_builder.build()?;
2246    let resp = client.execute(req).await?;
2247
2248    let status = resp.status();
2249    let content = resp.text().await?;
2250
2251    if !status.is_client_error() && !status.is_server_error() {
2252        serde_json::from_str(&content).map_err(Error::from)
2253    } else {
2254        let entity: Option<UpdateLiveActivityError> = serde_json::from_str(&content).ok();
2255        let error = ResponseContent { status: status, content: content, entity: entity };
2256        Err(Error::ResponseError(error))
2257    }
2258}
2259
2260/// 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.
2261pub 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>> {
2262    let configuration = configuration;
2263
2264    let client = &configuration.client;
2265
2266    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));
2267    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2268
2269    if let Some(ref user_agent) = configuration.user_agent {
2270        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2271    }
2272
2273    // Adds a telemetry header
2274    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2275
2276    if let Some(ref token) = configuration.rest_api_key_token {
2277        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2278    }
2279    req_builder = req_builder.json(&update_segment_request);
2280
2281    let req = req_builder.build()?;
2282    let resp = client.execute(req).await?;
2283
2284    let status = resp.status();
2285    let content = resp.text().await?;
2286
2287    if !status.is_client_error() && !status.is_server_error() {
2288        serde_json::from_str(&content).map_err(Error::from)
2289    } else {
2290        let entity: Option<UpdateSegmentError> = serde_json::from_str(&content).ok();
2291        let error = ResponseContent { status: status, content: content, entity: entity };
2292        Err(Error::ResponseError(error))
2293    }
2294}
2295
2296/// Updates an existing Subscription’s properties.
2297pub async fn update_subscription(configuration: &configuration::Configuration, app_id: &str, subscription_id: &str, subscription_body: crate::models::SubscriptionBody) -> Result<(), Error<UpdateSubscriptionError>> {
2298    let configuration = configuration;
2299
2300    let client = &configuration.client;
2301
2302    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));
2303    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2304
2305    if let Some(ref user_agent) = configuration.user_agent {
2306        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2307    }
2308
2309    // Adds a telemetry header
2310    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2311
2312    if let Some(ref token) = configuration.rest_api_key_token {
2313        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2314    }
2315    req_builder = req_builder.json(&subscription_body);
2316
2317    let req = req_builder.build()?;
2318    let resp = client.execute(req).await?;
2319
2320    let status = resp.status();
2321    let content = resp.text().await?;
2322
2323    if !status.is_client_error() && !status.is_server_error() {
2324        Ok(())
2325    } else {
2326        let entity: Option<UpdateSubscriptionError> = serde_json::from_str(&content).ok();
2327        let error = ResponseContent { status: status, content: content, entity: entity };
2328        Err(Error::ResponseError(error))
2329    }
2330}
2331
2332/// Update properties on an existing OneSignal subscription using its token.
2333pub 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>> {
2334    let configuration = configuration;
2335
2336    let client = &configuration.client;
2337
2338    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));
2339    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2340
2341    if let Some(ref user_agent) = configuration.user_agent {
2342        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2343    }
2344
2345    // Adds a telemetry header
2346    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2347
2348    if let Some(ref token) = configuration.rest_api_key_token {
2349        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2350    }
2351    req_builder = req_builder.json(&subscription_body);
2352
2353    let req = req_builder.build()?;
2354    let resp = client.execute(req).await?;
2355
2356    let status = resp.status();
2357    let content = resp.text().await?;
2358
2359    if !status.is_client_error() && !status.is_server_error() {
2360        serde_json::from_str(&content).map_err(Error::from)
2361    } else {
2362        let entity: Option<UpdateSubscriptionByTokenError> = serde_json::from_str(&content).ok();
2363        let error = ResponseContent { status: status, content: content, entity: entity };
2364        Err(Error::ResponseError(error))
2365    }
2366}
2367
2368/// Update an existing template.
2369pub 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>> {
2370    let configuration = configuration;
2371
2372    let client = &configuration.client;
2373
2374    let uri_str = format!("{}/templates/{template_id}", configuration.base_path, template_id=crate::apis::urlencode(template_id));
2375    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2376
2377    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
2378    if let Some(ref user_agent) = configuration.user_agent {
2379        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2380    }
2381
2382    // Adds a telemetry header
2383    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2384
2385    if let Some(ref token) = configuration.rest_api_key_token {
2386        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2387    }
2388    req_builder = req_builder.json(&update_template_request);
2389
2390    let req = req_builder.build()?;
2391    let resp = client.execute(req).await?;
2392
2393    let status = resp.status();
2394    let content = resp.text().await?;
2395
2396    if !status.is_client_error() && !status.is_server_error() {
2397        serde_json::from_str(&content).map_err(Error::from)
2398    } else {
2399        let entity: Option<UpdateTemplateError> = serde_json::from_str(&content).ok();
2400        let error = ResponseContent { status: status, content: content, entity: entity };
2401        Err(Error::ResponseError(error))
2402    }
2403}
2404
2405/// Updates an existing User’s properties.
2406pub 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>> {
2407    let configuration = configuration;
2408
2409    let client = &configuration.client;
2410
2411    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));
2412    let mut req_builder = client.request(reqwest::Method::PATCH, uri_str.as_str());
2413
2414    if let Some(ref user_agent) = configuration.user_agent {
2415        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2416    }
2417
2418    // Adds a telemetry header
2419    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2420
2421    if let Some(ref token) = configuration.rest_api_key_token {
2422        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2423    }
2424    req_builder = req_builder.json(&update_user_request);
2425
2426    let req = req_builder.build()?;
2427    let resp = client.execute(req).await?;
2428
2429    let status = resp.status();
2430    let content = resp.text().await?;
2431
2432    if !status.is_client_error() && !status.is_server_error() {
2433        serde_json::from_str(&content).map_err(Error::from)
2434    } else {
2435        let entity: Option<UpdateUserError> = serde_json::from_str(&content).ok();
2436        let error = ResponseContent { status: status, content: content, entity: entity };
2437        Err(Error::ResponseError(error))
2438    }
2439}
2440
2441/// View the details of all of your current app API keys (Rich Authentication Token) for a single OneSignal app.
2442pub async fn view_api_keys(configuration: &configuration::Configuration, app_id: &str) -> Result<crate::models::ApiKeyTokensListResponse, Error<ViewApiKeysError>> {
2443    let configuration = configuration;
2444
2445    let client = &configuration.client;
2446
2447    let uri_str = format!("{}/apps/{app_id}/auth/tokens", configuration.base_path, app_id=crate::apis::urlencode(app_id));
2448    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2449
2450    if let Some(ref user_agent) = configuration.user_agent {
2451        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2452    }
2453
2454    // Adds a telemetry header
2455    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2456
2457    if let Some(ref token) = configuration.organization_api_key_token {
2458        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2459    }
2460
2461    let req = req_builder.build()?;
2462    let resp = client.execute(req).await?;
2463
2464    let status = resp.status();
2465    let content = resp.text().await?;
2466
2467    if !status.is_client_error() && !status.is_server_error() {
2468        serde_json::from_str(&content).map_err(Error::from)
2469    } else {
2470        let entity: Option<ViewApiKeysError> = serde_json::from_str(&content).ok();
2471        let error = ResponseContent { status: status, content: content, entity: entity };
2472        Err(Error::ResponseError(error))
2473    }
2474}
2475
2476/// 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.
2477pub async fn view_journey(configuration: &configuration::Configuration, app_id: &str, journey_id: &str) -> Result<crate::models::Journey, Error<ViewJourneyError>> {
2478    let configuration = configuration;
2479
2480    let client = &configuration.client;
2481
2482    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));
2483    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2484
2485    if let Some(ref user_agent) = configuration.user_agent {
2486        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2487    }
2488
2489    // Adds a telemetry header
2490    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2491
2492    if let Some(ref token) = configuration.rest_api_key_token {
2493        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2494    }
2495
2496    let req = req_builder.build()?;
2497    let resp = client.execute(req).await?;
2498
2499    let status = resp.status();
2500    let content = resp.text().await?;
2501
2502    if !status.is_client_error() && !status.is_server_error() {
2503        serde_json::from_str(&content).map_err(Error::from)
2504    } else {
2505        let entity: Option<ViewJourneyError> = serde_json::from_str(&content).ok();
2506        let error = ResponseContent { status: status, content: content, entity: entity };
2507        Err(Error::ResponseError(error))
2508    }
2509}
2510
2511/// 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.
2512pub async fn view_journey_stats(configuration: &configuration::Configuration, app_id: &str, journey_id: &str) -> Result<crate::models::JourneyStats, Error<ViewJourneyStatsError>> {
2513    let configuration = configuration;
2514
2515    let client = &configuration.client;
2516
2517    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));
2518    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2519
2520    if let Some(ref user_agent) = configuration.user_agent {
2521        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2522    }
2523
2524    // Adds a telemetry header
2525    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2526
2527    if let Some(ref token) = configuration.rest_api_key_token {
2528        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2529    }
2530
2531    let req = req_builder.build()?;
2532    let resp = client.execute(req).await?;
2533
2534    let status = resp.status();
2535    let content = resp.text().await?;
2536
2537    if !status.is_client_error() && !status.is_server_error() {
2538        serde_json::from_str(&content).map_err(Error::from)
2539    } else {
2540        let entity: Option<ViewJourneyStatsError> = serde_json::from_str(&content).ok();
2541        let error = ResponseContent { status: status, content: content, entity: entity };
2542        Err(Error::ResponseError(error))
2543    }
2544}
2545
2546/// 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.
2547pub async fn view_journeys(configuration: &configuration::Configuration, app_id: &str, cursor: Option<&str>, limit: Option<i32>) -> Result<crate::models::JourneyListResponse, Error<ViewJourneysError>> {
2548    let configuration = configuration;
2549
2550    let client = &configuration.client;
2551
2552    let uri_str = format!("{}/apps/{app_id}/journeys", configuration.base_path, app_id=crate::apis::urlencode(app_id));
2553    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2554
2555    if let Some(ref str) = cursor {
2556        req_builder = req_builder.query(&[("cursor", &str.to_string())]);
2557    }
2558    if let Some(ref str) = limit {
2559        req_builder = req_builder.query(&[("limit", &str.to_string())]);
2560    }
2561    if let Some(ref user_agent) = configuration.user_agent {
2562        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2563    }
2564
2565    // Adds a telemetry header
2566    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2567
2568    if let Some(ref token) = configuration.rest_api_key_token {
2569        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2570    }
2571
2572    let req = req_builder.build()?;
2573    let resp = client.execute(req).await?;
2574
2575    let status = resp.status();
2576    let content = resp.text().await?;
2577
2578    if !status.is_client_error() && !status.is_server_error() {
2579        serde_json::from_str(&content).map_err(Error::from)
2580    } else {
2581        let entity: Option<ViewJourneysError> = serde_json::from_str(&content).ok();
2582        let error = ResponseContent { status: status, content: content, entity: entity };
2583        Err(Error::ResponseError(error))
2584    }
2585}
2586
2587/// Fetch a single template by id.
2588pub async fn view_template(configuration: &configuration::Configuration, template_id: &str, app_id: &str) -> Result<crate::models::TemplateResource, Error<ViewTemplateError>> {
2589    let configuration = configuration;
2590
2591    let client = &configuration.client;
2592
2593    let uri_str = format!("{}/templates/{template_id}", configuration.base_path, template_id=crate::apis::urlencode(template_id));
2594    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2595
2596    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
2597    if let Some(ref user_agent) = configuration.user_agent {
2598        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2599    }
2600
2601    // Adds a telemetry header
2602    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2603
2604    if let Some(ref token) = configuration.rest_api_key_token {
2605        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2606    }
2607
2608    let req = req_builder.build()?;
2609    let resp = client.execute(req).await?;
2610
2611    let status = resp.status();
2612    let content = resp.text().await?;
2613
2614    if !status.is_client_error() && !status.is_server_error() {
2615        serde_json::from_str(&content).map_err(Error::from)
2616    } else {
2617        let entity: Option<ViewTemplateError> = serde_json::from_str(&content).ok();
2618        let error = ResponseContent { status: status, content: content, entity: entity };
2619        Err(Error::ResponseError(error))
2620    }
2621}
2622
2623/// List templates for an app.
2624pub 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>> {
2625    let configuration = configuration;
2626
2627    let client = &configuration.client;
2628
2629    let uri_str = format!("{}/templates", configuration.base_path);
2630    let mut req_builder = client.request(reqwest::Method::GET, uri_str.as_str());
2631
2632    req_builder = req_builder.query(&[("app_id", &app_id.to_string())]);
2633    if let Some(ref str) = limit {
2634        req_builder = req_builder.query(&[("limit", &str.to_string())]);
2635    }
2636    if let Some(ref str) = offset {
2637        req_builder = req_builder.query(&[("offset", &str.to_string())]);
2638    }
2639    if let Some(ref str) = channel {
2640        req_builder = req_builder.query(&[("channel", &str.to_string())]);
2641    }
2642    if let Some(ref user_agent) = configuration.user_agent {
2643        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2644    }
2645
2646    // Adds a telemetry header
2647    req_builder = req_builder.header("OS-Usage-Data", "kind=sdk, sdk-name=onesignal-rust, version=5.15.0");
2648
2649    if let Some(ref token) = configuration.rest_api_key_token {
2650        req_builder = req_builder.header("Authorization", format!("Key {}", token.to_owned()));
2651    }
2652
2653    let req = req_builder.build()?;
2654    let resp = client.execute(req).await?;
2655
2656    let status = resp.status();
2657    let content = resp.text().await?;
2658
2659    if !status.is_client_error() && !status.is_server_error() {
2660        serde_json::from_str(&content).map_err(Error::from)
2661    } else {
2662        let entity: Option<ViewTemplatesError> = serde_json::from_str(&content).ok();
2663        let error = ResponseContent { status: status, content: content, entity: entity };
2664        Err(Error::ResponseError(error))
2665    }
2666}
2667
onesignal_rust_api/apis/default_api.rs

onesignal_rust_api/apis/
default_api.rs
