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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
// this file is @generated
#![allow(clippy::doc_markdown, clippy::default_trait_access)]
#[allow(unused_imports, clippy::wildcard_imports)]
use crate::{error::Result, models::*, Configuration};
/// Query and header parameters of [`UsageCostsSubscription::list_costs`], built
/// with the required ones by [`new`](Self::new).
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct UsageCostsSubscriptionListCostsOptions {
/// Billable metric, by ID or code.
pub metric: String,
/// Event property to split the usage by.
pub group_by: Option<String>,
/// The `granularity` query parameter.
pub granularity: ListSubscriptionUsageCostsGranularity,
/// Start of the range, inclusive.
pub from: chrono::DateTime<chrono::Utc>,
/// End of the range, exclusive. At most 93 days after `from`.
pub to: chrono::DateTime<chrono::Utc>,
}
impl UsageCostsSubscriptionListCostsOptions {
/// Options with the required parameters set.
#[must_use]
pub fn new(
metric: impl Into<String>,
granularity: impl Into<ListSubscriptionUsageCostsGranularity>,
from: impl Into<chrono::DateTime<chrono::Utc>>,
to: impl Into<chrono::DateTime<chrono::Utc>>,
) -> Self {
Self {
metric: metric.into(),
group_by: None,
granularity: granularity.into(),
from: from.into(),
to: to.into(),
}
}
/// Sets the `group_by` query parameter.
#[must_use]
pub fn group_by(mut self, group_by: impl Into<String>) -> Self {
self.group_by = Some(group_by.into());
self
}
/// Sets the `group_by` query parameter, or unsets it with `None`.
#[must_use]
pub fn maybe_group_by(mut self, group_by: Option<String>) -> Self {
self.group_by = group_by;
self
}
}
/// Query and header parameters of [`UsageCostsSubscription::list_events`], built
/// with the required ones by [`new`](Self::new).
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct UsageCostsSubscriptionListEventsOptions {
/// Billable metric, by ID or code.
pub metric: String,
/// Start of the range, inclusive.
pub from: chrono::DateTime<chrono::Utc>,
/// End of the range, exclusive. At most 93 days after `from`.
pub to: chrono::DateTime<chrono::Utc>,
/// The `next_cursor` of the previous page.
pub cursor: Option<String>,
/// Page size, 100 by default and 500 at most.
pub limit: Option<i32>,
}
impl UsageCostsSubscriptionListEventsOptions {
/// Options with the required parameters set.
#[must_use]
pub fn new(
metric: impl Into<String>,
from: impl Into<chrono::DateTime<chrono::Utc>>,
to: impl Into<chrono::DateTime<chrono::Utc>>,
) -> Self {
Self {
metric: metric.into(),
from: from.into(),
to: to.into(),
cursor: None,
limit: None,
}
}
/// Sets the `cursor` query parameter.
#[must_use]
pub fn cursor(mut self, cursor: impl Into<String>) -> Self {
self.cursor = Some(cursor.into());
self
}
/// Sets the `cursor` query parameter, or unsets it with `None`.
#[must_use]
pub fn maybe_cursor(mut self, cursor: Option<String>) -> Self {
self.cursor = cursor;
self
}
/// Sets the `limit` query parameter.
#[must_use]
pub fn limit(mut self, limit: impl Into<i32>) -> Self {
self.limit = Some(limit.into());
self
}
/// Sets the `limit` query parameter, or unsets it with `None`.
#[must_use]
pub fn maybe_limit(mut self, limit: Option<i32>) -> Self {
self.limit = limit;
self
}
}
/// The usage costs subscription API, from
/// [`UsageCosts::subscription`](crate::api::UsageCosts::subscription).
#[derive(Clone)]
pub struct UsageCostsSubscription {
cfg: std::sync::Arc<Configuration>,
options: crate::api::RequestOptions,
}
impl std::fmt::Debug for UsageCostsSubscription {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("UsageCostsSubscription")
.field("options", &self.options)
.finish_non_exhaustive()
}
}
impl UsageCostsSubscription {
pub(super) fn new(cfg: std::sync::Arc<Configuration>) -> Self {
Self {
cfg,
options: crate::api::RequestOptions::default(),
}
}
/// Applies `options` (headers, timeout, retries, idempotency key) to the calls made
/// through the returned value.
#[must_use]
pub fn with_options(mut self, options: crate::api::RequestOptions) -> Self {
self.options = options;
self
}
/// List a subscription's usage costs over time
///
/// The subscription's usage of one billable metric and what it costs, as for a customer but
/// counting only the events the subscription bills (see its usage filter) and only its own billing
/// periods. The range is at most 93 days.
///
/// Beta: the request and response shapes of this endpoint may change before general availability.
///
/// `GET /api/v1/usage/subscription/{subscription_id}/costs`.
///
/// # Errors
///
/// An API error's body is [`RestErrorResponse`](crate::models::RestErrorResponse) (400, 401, 403, 404, 429, 500).
pub fn list_costs(
&self,
subscription_id: impl Into<crate::models::SubscriptionId>,
options: UsageCostsSubscriptionListCostsOptions,
) -> crate::api::Call<crate::models::UsageCostListResponse> {
let UsageCostsSubscriptionListCostsOptions {
metric,
group_by,
granularity,
from,
to,
} = options;
crate::request::Request::new(
http::Method::GET,
"/api/v1/usage/subscription/{subscription_id}/costs",
)
.with_path_param(
"subscription_id",
Into::<crate::models::SubscriptionId>::into(subscription_id),
)
.with_query_param("metric", &metric)
.with_optional_query_param("group_by", group_by)
.with_query_param("granularity", &granularity)
.with_query_param("from", &from)
.with_query_param("to", &to)
.with_options(&self.options)
.json(&self.cfg)
}
/// List a subscription's usage events with their cost
///
/// The events of one billable metric that the subscription bills, oldest first: with a usage
/// filter, only the customer's events matching it; without, those no other subscription's filter
/// claims. Costs are as for the customer's events. The range is at most 93 days.
///
/// Beta: the request and response shapes of this endpoint may change before general availability.
///
/// `GET /api/v1/usage/subscription/{subscription_id}/events`.
///
/// # Errors
///
/// An API error's body is [`RestErrorResponse`](crate::models::RestErrorResponse) (400, 401, 403, 404, 429, 500).
pub fn list_events(
&self,
subscription_id: impl Into<crate::models::SubscriptionId>,
options: UsageCostsSubscriptionListEventsOptions,
) -> crate::api::Call<crate::models::UsageEventListResponse> {
let UsageCostsSubscriptionListEventsOptions {
metric,
from,
to,
cursor,
limit,
} = options;
crate::request::Request::new(
http::Method::GET,
"/api/v1/usage/subscription/{subscription_id}/events",
)
.with_path_param(
"subscription_id",
Into::<crate::models::SubscriptionId>::into(subscription_id),
)
.with_query_param("metric", &metric)
.with_query_param("from", &from)
.with_query_param("to", &to)
.with_optional_query_param("cursor", cursor)
.with_optional_query_param("limit", limit)
.with_options(&self.options)
.json(&self.cfg)
}
}