svix 1.91.1

Svix webhooks API client and webhook verification library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

// this file is @generated
use crate::{error::Result, models::*, Configuration};

#[derive(Default)]
pub struct ApplicationListOptions {
    /// Exclude applications that have no endpoints. Default is false.
    pub exclude_apps_with_no_endpoints: Option<bool>,

    /// Exclude applications that have only disabled endpoints. Default is
    /// false.
    pub exclude_apps_with_disabled_endpoints: Option<bool>,

    pub exclude_apps_with_svix_play_endpoints: Option<bool>,

    /// Limit the number of returned items
    pub limit: Option<i32>,

    /// The iterator returned from a prior invocation
    pub iterator: Option<String>,

    /// The sorting order of the returned items
    pub order: Option<Ordering>,
}

#[derive(Default)]
pub struct ApplicationCreateOptions {
    pub idempotency_key: Option<String>,
}

pub struct Application<'a> {
    cfg: &'a Configuration,
}

impl<'a> Application<'a> {
    pub(super) fn new(cfg: &'a Configuration) -> Self {
        Self { cfg }
    }

    /// List of all the organization's applications.
    pub async fn list(
        &self,
        options: Option<ApplicationListOptions>,
    ) -> Result<ListResponseApplicationOut> {
        let ApplicationListOptions {
            exclude_apps_with_no_endpoints,
            exclude_apps_with_disabled_endpoints,
            exclude_apps_with_svix_play_endpoints,
            limit,
            iterator,
            order,
        } = options.unwrap_or_default();

        crate::request::Request::new(http1::Method::GET, "/api/v1/app")
            .with_optional_query_param(
                "exclude_apps_with_no_endpoints",
                exclude_apps_with_no_endpoints,
            )
            .with_optional_query_param(
                "exclude_apps_with_disabled_endpoints",
                exclude_apps_with_disabled_endpoints,
            )
            .with_optional_query_param(
                "exclude_apps_with_svix_play_endpoints",
                exclude_apps_with_svix_play_endpoints,
            )
            .with_optional_query_param("limit", limit)
            .with_optional_query_param("iterator", iterator)
            .with_optional_query_param("order", order)
            .execute(self.cfg)
            .await
    }

    /// Create a new application.
    pub async fn create(
        &self,
        application_in: ApplicationIn,
        options: Option<ApplicationCreateOptions>,
    ) -> Result<ApplicationOut> {
        let ApplicationCreateOptions { idempotency_key } = options.unwrap_or_default();

        crate::request::Request::new(http1::Method::POST, "/api/v1/app")
            .with_optional_header_param("idempotency-key", idempotency_key)
            .with_body_param(application_in)
            .execute(self.cfg)
            .await
    }

    /// Create the application with the given ID, or create a new one if it
    /// doesn't exist yet.
    pub async fn get_or_create(
        &self,
        application_in: ApplicationIn,
        options: Option<ApplicationCreateOptions>,
    ) -> Result<ApplicationOut> {
        let ApplicationCreateOptions { idempotency_key } = options.unwrap_or_default();

        crate::request::Request::new(http1::Method::POST, "/api/v1/app")
            .with_query_param("get_if_exists", "true".to_owned())
            .with_optional_header_param("idempotency-key", idempotency_key)
            .with_body_param(application_in)
            .execute(self.cfg)
            .await
    }

    /// Get an application.
    pub async fn get(&self, app_id: String) -> Result<ApplicationOut> {
        crate::request::Request::new(http1::Method::GET, "/api/v1/app/{app_id}")
            .with_path_param("app_id", app_id)
            .execute(self.cfg)
            .await
    }

    /// Update an application.
    pub async fn update(
        &self,
        app_id: String,
        application_in: ApplicationIn,
    ) -> Result<ApplicationOut> {
        crate::request::Request::new(http1::Method::PUT, "/api/v1/app/{app_id}")
            .with_path_param("app_id", app_id)
            .with_body_param(application_in)
            .execute(self.cfg)
            .await
    }

    /// Delete an application.
    pub async fn delete(&self, app_id: String) -> Result<()> {
        crate::request::Request::new(http1::Method::DELETE, "/api/v1/app/{app_id}")
            .with_path_param("app_id", app_id)
            .returns_nothing()
            .execute(self.cfg)
            .await
    }

    /// Partially update an application.
    pub async fn patch(
        &self,
        app_id: String,
        application_patch: ApplicationPatch,
    ) -> Result<ApplicationOut> {
        crate::request::Request::new(http1::Method::PATCH, "/api/v1/app/{app_id}")
            .with_path_param("app_id", app_id)
            .with_body_param(application_patch)
            .execute(self.cfg)
            .await
    }
}