hooksniff 1.5.1

HookSniff 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
148

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

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

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

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

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

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

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

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

    /// Logout an app token.
    ///
    /// Trying to log out other tokens will fail.
    pub async fn logout(&self, options: Option<AuthenticationLogoutOptions>) -> Result<()> {
        let AuthenticationLogoutOptions { idempotency_key } = options.unwrap_or_default();

        crate::request::Request::new(http1::Method::POST, "/v1/auth/logout")
            .with_optional_header_param("idempotency-key", idempotency_key)
            .returns_nothing()
            .execute(self.cfg)
            .await
    }

    /// Logout a stream token.
    ///
    /// Trying to log out other tokens will fail.
    pub async fn stream_logout(
        &self,
        options: Option<AuthenticationStreamLogoutOptions>,
    ) -> Result<()> {
        let AuthenticationStreamLogoutOptions { idempotency_key } = options.unwrap_or_default();

        crate::request::Request::new(http1::Method::POST, "/v1/auth/stream-logout")
            .with_optional_header_param("idempotency-key", idempotency_key)
            .returns_nothing()
            .execute(self.cfg)
            .await
    }

    /// Use this function to get magic links (and authentication codes) for
    /// connecting your users to the Stream Consumer Portal.
    pub async fn stream_portal_access(
        &self,
        stream_id: String,
        stream_portal_access_in: StreamPortalAccessIn,
        options: Option<AuthenticationStreamPortalAccessOptions>,
    ) -> Result<AppPortalAccessOut> {
        let AuthenticationStreamPortalAccessOptions { idempotency_key } =
            options.unwrap_or_default();

        crate::request::Request::new(
            http1::Method::POST,
            "/v1/auth/stream-portal-access/{stream_id}",
        )
        .with_path_param("stream_id", stream_id)
        .with_optional_header_param("idempotency-key", idempotency_key)
        .with_body_param(stream_portal_access_in)
        .execute(self.cfg)
        .await
    }

    /// Expire all of the tokens associated with a specific stream.
    pub async fn stream_expire_all(
        &self,
        stream_id: String,
        stream_token_expire_in: StreamTokenExpireIn,
        options: Option<AuthenticationStreamExpireAllOptions>,
    ) -> Result<()> {
        let AuthenticationStreamExpireAllOptions { idempotency_key } = options.unwrap_or_default();

        crate::request::Request::new(
            http1::Method::POST,
            "/v1/auth/stream/{stream_id}/expire-all",
        )
        .with_path_param("stream_id", stream_id)
        .with_optional_header_param("idempotency-key", idempotency_key)
        .with_body_param(stream_token_expire_in)
        .returns_nothing()
        .execute(self.cfg)
        .await
    }

    /// Get the current auth token for the stream poller.
    pub async fn get_stream_poller_token(
        &self,
        stream_id: String,
        sink_id: String,
    ) -> Result<ApiTokenOut> {
        crate::request::Request::new(
            http1::Method::GET,
            "/v1/auth/stream/{stream_id}/sink/{sink_id}/poller/token",
        )
        .with_path_param("stream_id", stream_id)
        .with_path_param("sink_id", sink_id)
        .execute(self.cfg)
        .await
    }

    /// Create a new auth token for the stream poller API.
    pub async fn rotate_stream_poller_token(
        &self,
        stream_id: String,
        sink_id: String,
        rotate_poller_token_in: RotatePollerTokenIn,
        options: Option<AuthenticationRotateStreamPollerTokenOptions>,
    ) -> Result<ApiTokenOut> {
        let AuthenticationRotateStreamPollerTokenOptions { idempotency_key } =
            options.unwrap_or_default();

        crate::request::Request::new(
            http1::Method::POST,
            "/v1/auth/stream/{stream_id}/sink/{sink_id}/poller/token/rotate",
        )
        .with_path_param("stream_id", stream_id)
        .with_path_param("sink_id", sink_id)
        .with_optional_header_param("idempotency-key", idempotency_key)
        .with_body_param(rotate_poller_token_in)
        .execute(self.cfg)
        .await
    }
}