nominal_api_conjure/conjure/clients/scout/compute/api/
compute_service.rs

1use conjure_http::endpoint;
2/// The Compute Service provides the ability to compute the output of compute graphs.
3#[conjure_http::conjure_client(name = "ComputeService")]
4pub trait ComputeService<
5    #[response_body]
6    I: Iterator<
7            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
8        >,
9> {
10    /// Computes the output of the compute graph specified by a ComputeNodeRequest.
11    #[endpoint(
12        method = POST,
13        path = "/compute/v2/compute",
14        name = "compute",
15        accept = conjure_http::client::StdResponseDeserializer
16    )]
17    fn compute(
18        &self,
19        #[auth]
20        auth_: &conjure_object::BearerToken,
21        #[body(serializer = conjure_http::client::StdRequestSerializer)]
22        request: &super::super::super::super::super::objects::scout::compute::api::ComputeNodeRequest,
23    ) -> Result<
24        super::super::super::super::super::objects::scout::compute::api::ComputeNodeResponse,
25        conjure_http::private::Error,
26    >;
27    /// Computes the output of the compute graph specified by a ParameterizedComputeNodeRequest. A parameterized
28    /// compute request supports multiple values for a single variable, supplied by the ParameterizedContext.
29    /// Results are returned in the same order of the request.
30    #[endpoint(
31        method = POST,
32        path = "/compute/v2/compute/parameterized",
33        name = "parameterizedCompute",
34        accept = conjure_http::client::StdResponseDeserializer
35    )]
36    fn parameterized_compute(
37        &self,
38        #[auth]
39        auth_: &conjure_object::BearerToken,
40        #[body(serializer = conjure_http::client::StdRequestSerializer)]
41        request: &super::super::super::super::super::objects::scout::compute::api::ParameterizedComputeNodeRequest,
42    ) -> Result<
43        super::super::super::super::super::objects::scout::compute::api::ParameterizedComputeNodeResponse,
44        conjure_http::private::Error,
45    >;
46    /// Returns the resulting unit for the output of a compute graph. If the resulting unit is equivalent to exactly
47    /// one existing unit in the system, it will be returned (for example, a series in Coulombs divided by a series
48    /// in Volts will return an output of Farads). If the output does not have units (for example, a range output,)
49    /// the unit result will return noUnitAvailable, and if the computation was not successful, corresponding errors
50    /// are returned.
51    #[endpoint(
52        method = POST,
53        path = "/compute/v2/compute/units",
54        name = "computeUnits",
55        accept = conjure_http::client::StdResponseDeserializer
56    )]
57    fn compute_units(
58        &self,
59        #[auth]
60        auth_: &conjure_object::BearerToken,
61        #[body(serializer = conjure_http::client::StdRequestSerializer)]
62        request: &super::super::super::super::super::objects::scout::compute::api::ComputeUnitsRequest,
63    ) -> Result<
64        super::super::super::super::super::objects::scout::compute::api::ComputeUnitResult,
65        conjure_http::private::Error,
66    >;
67    /// Computes the output of compute graphs specified by BatchComputeNodeRequest. Results are returned in the same
68    /// order as the request.
69    #[endpoint(
70        method = POST,
71        path = "/compute/v2/compute/batch",
72        name = "batchComputeWithUnits",
73        accept = conjure_http::client::StdResponseDeserializer
74    )]
75    fn batch_compute_with_units(
76        &self,
77        #[auth]
78        auth_: &conjure_object::BearerToken,
79        #[body(serializer = conjure_http::client::StdRequestSerializer)]
80        request: &super::super::super::super::super::objects::scout::compute::api::BatchComputeWithUnitsRequest,
81    ) -> Result<
82        super::super::super::super::super::objects::scout::compute::api::BatchComputeWithUnitsResponse,
83        conjure_http::private::Error,
84    >;
85    /// Same as computeUnits, however this endpoint functions on a batch of requests for wire efficiency purposes. An
86    /// extra note is that this method will serialize underlying conjure errors into the BatchComputeUnitResult type,
87    /// meaning callers are required to check for errors explicitly (rather than relying on exceptions being thrown).
88    #[endpoint(
89        method = POST,
90        path = "/compute/v2/compute/batch-units",
91        name = "batchComputeUnits",
92        accept = conjure_http::client::StdResponseDeserializer
93    )]
94    fn batch_compute_units(
95        &self,
96        #[auth]
97        auth_: &conjure_object::BearerToken,
98        #[body(serializer = conjure_http::client::StdRequestSerializer)]
99        request: &super::super::super::super::super::objects::scout::compute::api::BatchComputeUnitsRequest,
100    ) -> Result<
101        super::super::super::super::super::objects::scout::compute::api::BatchComputeUnitResult,
102        conjure_http::private::Error,
103    >;
104    /// Computes the output of the compute graph specified by a ComputeNodeRequest, as well as providing the resulting
105    /// unit for the output of a compute graph. If the resulting unit is equivalent to exactly one existing unit in the
106    /// system, it will be returned (for example, a series in Coulombs divided by a series in Volts will return an
107    /// output of Farads). If the output does not have units (for example, a range output,) the unit result will return
108    /// noUnitAvailable, and if the computation was not successful, corresponding errors are returned.
109    #[endpoint(
110        method = POST,
111        path = "/compute/v2/computeWithUnits",
112        name = "computeWithUnits",
113        accept = conjure_http::client::StdResponseDeserializer
114    )]
115    fn compute_with_units(
116        &self,
117        #[auth]
118        auth_: &conjure_object::BearerToken,
119        #[body(serializer = conjure_http::client::StdRequestSerializer)]
120        request: &super::super::super::super::super::objects::scout::compute::api::ComputeWithUnitsRequest,
121    ) -> Result<
122        super::super::super::super::super::objects::scout::compute::api::ComputeWithUnitsResponse,
123        conjure_http::private::Error,
124    >;
125    /// Best-effort cancellation of active compute requests. Each ID should be the request ID that
126    /// the client originally passed when starting the request. A single request may correspond to
127    /// one or more underlying operations, all of which will be cancelled.
128    #[endpoint(
129        method = POST,
130        path = "/compute/v2/compute/batch/kill",
131        name = "batchKillRequests",
132        accept = conjure_http::client::conjure::EmptyResponseDeserializer
133    )]
134    fn batch_kill_requests(
135        &self,
136        #[auth]
137        auth_: &conjure_object::BearerToken,
138        #[body(serializer = conjure_http::client::StdRequestSerializer)]
139        request: &super::super::super::super::super::objects::scout::compute::api::BatchKillRequestsRequest,
140    ) -> Result<(), conjure_http::private::Error>;
141    /// Returns a point-in-time snapshot of progress for the given active compute requests. Each
142    /// ID should be the request ID that the client originally passed when starting the request.
143    /// Intended to be polled (roughly once per second) for requests that have been running
144    /// longer than the slow-query threshold.
145    ///
146    /// A request with no active queries is not necessarily finished: its underlying queries may
147    /// not have started yet, the request may be in a post-processing phase, or the request's
148    /// work may be executed somewhere that does not report progress — in which case it stays
149    /// inactive for its entire duration. Clients should derive progress from the raw row
150    /// counters and must not assume monotonicity, since totalRowsApprox can grow while a
151    /// request runs.
152    #[endpoint(
153        method = POST,
154        path = "/compute/v2/compute/batch/progress",
155        name = "batchGetRequestProgress",
156        accept = conjure_http::client::StdResponseDeserializer
157    )]
158    fn batch_get_request_progress(
159        &self,
160        #[auth]
161        auth_: &conjure_object::BearerToken,
162        #[body(serializer = conjure_http::client::StdRequestSerializer)]
163        request: &super::super::super::super::super::objects::scout::compute::api::BatchGetRequestProgressRequest,
164    ) -> Result<
165        super::super::super::super::super::objects::scout::compute::api::BatchGetRequestProgressResponse,
166        conjure_http::private::Error,
167    >;
168    /// Returns the calling user's compute quota usage for their current organization, one entry
169    /// per quota window. Returns no intervals when quotas are not enabled for the organization.
170    #[endpoint(
171        method = GET,
172        path = "/compute/v2/compute/quota/usage",
173        name = "getQuotaUsage",
174        accept = conjure_http::client::StdResponseDeserializer
175    )]
176    fn get_quota_usage(
177        &self,
178        #[auth]
179        auth_: &conjure_object::BearerToken,
180    ) -> Result<
181        super::super::super::super::super::objects::scout::compute::api::GetQuotaUsageResponse,
182        conjure_http::private::Error,
183    >;
184}
185/// The Compute Service provides the ability to compute the output of compute graphs.
186#[conjure_http::conjure_client(name = "ComputeService")]
187pub trait AsyncComputeService<
188    #[response_body]
189    I: conjure_http::private::Stream<
190            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
191        >,
192> {
193    /// Computes the output of the compute graph specified by a ComputeNodeRequest.
194    #[endpoint(
195        method = POST,
196        path = "/compute/v2/compute",
197        name = "compute",
198        accept = conjure_http::client::StdResponseDeserializer
199    )]
200    async fn compute(
201        &self,
202        #[auth]
203        auth_: &conjure_object::BearerToken,
204        #[body(serializer = conjure_http::client::StdRequestSerializer)]
205        request: &super::super::super::super::super::objects::scout::compute::api::ComputeNodeRequest,
206    ) -> Result<
207        super::super::super::super::super::objects::scout::compute::api::ComputeNodeResponse,
208        conjure_http::private::Error,
209    >;
210    /// Computes the output of the compute graph specified by a ParameterizedComputeNodeRequest. A parameterized
211    /// compute request supports multiple values for a single variable, supplied by the ParameterizedContext.
212    /// Results are returned in the same order of the request.
213    #[endpoint(
214        method = POST,
215        path = "/compute/v2/compute/parameterized",
216        name = "parameterizedCompute",
217        accept = conjure_http::client::StdResponseDeserializer
218    )]
219    async fn parameterized_compute(
220        &self,
221        #[auth]
222        auth_: &conjure_object::BearerToken,
223        #[body(serializer = conjure_http::client::StdRequestSerializer)]
224        request: &super::super::super::super::super::objects::scout::compute::api::ParameterizedComputeNodeRequest,
225    ) -> Result<
226        super::super::super::super::super::objects::scout::compute::api::ParameterizedComputeNodeResponse,
227        conjure_http::private::Error,
228    >;
229    /// Returns the resulting unit for the output of a compute graph. If the resulting unit is equivalent to exactly
230    /// one existing unit in the system, it will be returned (for example, a series in Coulombs divided by a series
231    /// in Volts will return an output of Farads). If the output does not have units (for example, a range output,)
232    /// the unit result will return noUnitAvailable, and if the computation was not successful, corresponding errors
233    /// are returned.
234    #[endpoint(
235        method = POST,
236        path = "/compute/v2/compute/units",
237        name = "computeUnits",
238        accept = conjure_http::client::StdResponseDeserializer
239    )]
240    async fn compute_units(
241        &self,
242        #[auth]
243        auth_: &conjure_object::BearerToken,
244        #[body(serializer = conjure_http::client::StdRequestSerializer)]
245        request: &super::super::super::super::super::objects::scout::compute::api::ComputeUnitsRequest,
246    ) -> Result<
247        super::super::super::super::super::objects::scout::compute::api::ComputeUnitResult,
248        conjure_http::private::Error,
249    >;
250    /// Computes the output of compute graphs specified by BatchComputeNodeRequest. Results are returned in the same
251    /// order as the request.
252    #[endpoint(
253        method = POST,
254        path = "/compute/v2/compute/batch",
255        name = "batchComputeWithUnits",
256        accept = conjure_http::client::StdResponseDeserializer
257    )]
258    async fn batch_compute_with_units(
259        &self,
260        #[auth]
261        auth_: &conjure_object::BearerToken,
262        #[body(serializer = conjure_http::client::StdRequestSerializer)]
263        request: &super::super::super::super::super::objects::scout::compute::api::BatchComputeWithUnitsRequest,
264    ) -> Result<
265        super::super::super::super::super::objects::scout::compute::api::BatchComputeWithUnitsResponse,
266        conjure_http::private::Error,
267    >;
268    /// Same as computeUnits, however this endpoint functions on a batch of requests for wire efficiency purposes. An
269    /// extra note is that this method will serialize underlying conjure errors into the BatchComputeUnitResult type,
270    /// meaning callers are required to check for errors explicitly (rather than relying on exceptions being thrown).
271    #[endpoint(
272        method = POST,
273        path = "/compute/v2/compute/batch-units",
274        name = "batchComputeUnits",
275        accept = conjure_http::client::StdResponseDeserializer
276    )]
277    async fn batch_compute_units(
278        &self,
279        #[auth]
280        auth_: &conjure_object::BearerToken,
281        #[body(serializer = conjure_http::client::StdRequestSerializer)]
282        request: &super::super::super::super::super::objects::scout::compute::api::BatchComputeUnitsRequest,
283    ) -> Result<
284        super::super::super::super::super::objects::scout::compute::api::BatchComputeUnitResult,
285        conjure_http::private::Error,
286    >;
287    /// Computes the output of the compute graph specified by a ComputeNodeRequest, as well as providing the resulting
288    /// unit for the output of a compute graph. If the resulting unit is equivalent to exactly one existing unit in the
289    /// system, it will be returned (for example, a series in Coulombs divided by a series in Volts will return an
290    /// output of Farads). If the output does not have units (for example, a range output,) the unit result will return
291    /// noUnitAvailable, and if the computation was not successful, corresponding errors are returned.
292    #[endpoint(
293        method = POST,
294        path = "/compute/v2/computeWithUnits",
295        name = "computeWithUnits",
296        accept = conjure_http::client::StdResponseDeserializer
297    )]
298    async fn compute_with_units(
299        &self,
300        #[auth]
301        auth_: &conjure_object::BearerToken,
302        #[body(serializer = conjure_http::client::StdRequestSerializer)]
303        request: &super::super::super::super::super::objects::scout::compute::api::ComputeWithUnitsRequest,
304    ) -> Result<
305        super::super::super::super::super::objects::scout::compute::api::ComputeWithUnitsResponse,
306        conjure_http::private::Error,
307    >;
308    /// Best-effort cancellation of active compute requests. Each ID should be the request ID that
309    /// the client originally passed when starting the request. A single request may correspond to
310    /// one or more underlying operations, all of which will be cancelled.
311    #[endpoint(
312        method = POST,
313        path = "/compute/v2/compute/batch/kill",
314        name = "batchKillRequests",
315        accept = conjure_http::client::conjure::EmptyResponseDeserializer
316    )]
317    async fn batch_kill_requests(
318        &self,
319        #[auth]
320        auth_: &conjure_object::BearerToken,
321        #[body(serializer = conjure_http::client::StdRequestSerializer)]
322        request: &super::super::super::super::super::objects::scout::compute::api::BatchKillRequestsRequest,
323    ) -> Result<(), conjure_http::private::Error>;
324    /// Returns a point-in-time snapshot of progress for the given active compute requests. Each
325    /// ID should be the request ID that the client originally passed when starting the request.
326    /// Intended to be polled (roughly once per second) for requests that have been running
327    /// longer than the slow-query threshold.
328    ///
329    /// A request with no active queries is not necessarily finished: its underlying queries may
330    /// not have started yet, the request may be in a post-processing phase, or the request's
331    /// work may be executed somewhere that does not report progress — in which case it stays
332    /// inactive for its entire duration. Clients should derive progress from the raw row
333    /// counters and must not assume monotonicity, since totalRowsApprox can grow while a
334    /// request runs.
335    #[endpoint(
336        method = POST,
337        path = "/compute/v2/compute/batch/progress",
338        name = "batchGetRequestProgress",
339        accept = conjure_http::client::StdResponseDeserializer
340    )]
341    async fn batch_get_request_progress(
342        &self,
343        #[auth]
344        auth_: &conjure_object::BearerToken,
345        #[body(serializer = conjure_http::client::StdRequestSerializer)]
346        request: &super::super::super::super::super::objects::scout::compute::api::BatchGetRequestProgressRequest,
347    ) -> Result<
348        super::super::super::super::super::objects::scout::compute::api::BatchGetRequestProgressResponse,
349        conjure_http::private::Error,
350    >;
351    /// Returns the calling user's compute quota usage for their current organization, one entry
352    /// per quota window. Returns no intervals when quotas are not enabled for the organization.
353    #[endpoint(
354        method = GET,
355        path = "/compute/v2/compute/quota/usage",
356        name = "getQuotaUsage",
357        accept = conjure_http::client::StdResponseDeserializer
358    )]
359    async fn get_quota_usage(
360        &self,
361        #[auth]
362        auth_: &conjure_object::BearerToken,
363    ) -> Result<
364        super::super::super::super::super::objects::scout::compute::api::GetQuotaUsageResponse,
365        conjure_http::private::Error,
366    >;
367}
368/// The Compute Service provides the ability to compute the output of compute graphs.
369#[conjure_http::conjure_client(name = "ComputeService", local)]
370pub trait LocalAsyncComputeService<
371    #[response_body]
372    I: conjure_http::private::Stream<
373            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
374        >,
375> {
376    /// Computes the output of the compute graph specified by a ComputeNodeRequest.
377    #[endpoint(
378        method = POST,
379        path = "/compute/v2/compute",
380        name = "compute",
381        accept = conjure_http::client::StdResponseDeserializer
382    )]
383    async fn compute(
384        &self,
385        #[auth]
386        auth_: &conjure_object::BearerToken,
387        #[body(serializer = conjure_http::client::StdRequestSerializer)]
388        request: &super::super::super::super::super::objects::scout::compute::api::ComputeNodeRequest,
389    ) -> Result<
390        super::super::super::super::super::objects::scout::compute::api::ComputeNodeResponse,
391        conjure_http::private::Error,
392    >;
393    /// Computes the output of the compute graph specified by a ParameterizedComputeNodeRequest. A parameterized
394    /// compute request supports multiple values for a single variable, supplied by the ParameterizedContext.
395    /// Results are returned in the same order of the request.
396    #[endpoint(
397        method = POST,
398        path = "/compute/v2/compute/parameterized",
399        name = "parameterizedCompute",
400        accept = conjure_http::client::StdResponseDeserializer
401    )]
402    async fn parameterized_compute(
403        &self,
404        #[auth]
405        auth_: &conjure_object::BearerToken,
406        #[body(serializer = conjure_http::client::StdRequestSerializer)]
407        request: &super::super::super::super::super::objects::scout::compute::api::ParameterizedComputeNodeRequest,
408    ) -> Result<
409        super::super::super::super::super::objects::scout::compute::api::ParameterizedComputeNodeResponse,
410        conjure_http::private::Error,
411    >;
412    /// Returns the resulting unit for the output of a compute graph. If the resulting unit is equivalent to exactly
413    /// one existing unit in the system, it will be returned (for example, a series in Coulombs divided by a series
414    /// in Volts will return an output of Farads). If the output does not have units (for example, a range output,)
415    /// the unit result will return noUnitAvailable, and if the computation was not successful, corresponding errors
416    /// are returned.
417    #[endpoint(
418        method = POST,
419        path = "/compute/v2/compute/units",
420        name = "computeUnits",
421        accept = conjure_http::client::StdResponseDeserializer
422    )]
423    async fn compute_units(
424        &self,
425        #[auth]
426        auth_: &conjure_object::BearerToken,
427        #[body(serializer = conjure_http::client::StdRequestSerializer)]
428        request: &super::super::super::super::super::objects::scout::compute::api::ComputeUnitsRequest,
429    ) -> Result<
430        super::super::super::super::super::objects::scout::compute::api::ComputeUnitResult,
431        conjure_http::private::Error,
432    >;
433    /// Computes the output of compute graphs specified by BatchComputeNodeRequest. Results are returned in the same
434    /// order as the request.
435    #[endpoint(
436        method = POST,
437        path = "/compute/v2/compute/batch",
438        name = "batchComputeWithUnits",
439        accept = conjure_http::client::StdResponseDeserializer
440    )]
441    async fn batch_compute_with_units(
442        &self,
443        #[auth]
444        auth_: &conjure_object::BearerToken,
445        #[body(serializer = conjure_http::client::StdRequestSerializer)]
446        request: &super::super::super::super::super::objects::scout::compute::api::BatchComputeWithUnitsRequest,
447    ) -> Result<
448        super::super::super::super::super::objects::scout::compute::api::BatchComputeWithUnitsResponse,
449        conjure_http::private::Error,
450    >;
451    /// Same as computeUnits, however this endpoint functions on a batch of requests for wire efficiency purposes. An
452    /// extra note is that this method will serialize underlying conjure errors into the BatchComputeUnitResult type,
453    /// meaning callers are required to check for errors explicitly (rather than relying on exceptions being thrown).
454    #[endpoint(
455        method = POST,
456        path = "/compute/v2/compute/batch-units",
457        name = "batchComputeUnits",
458        accept = conjure_http::client::StdResponseDeserializer
459    )]
460    async fn batch_compute_units(
461        &self,
462        #[auth]
463        auth_: &conjure_object::BearerToken,
464        #[body(serializer = conjure_http::client::StdRequestSerializer)]
465        request: &super::super::super::super::super::objects::scout::compute::api::BatchComputeUnitsRequest,
466    ) -> Result<
467        super::super::super::super::super::objects::scout::compute::api::BatchComputeUnitResult,
468        conjure_http::private::Error,
469    >;
470    /// Computes the output of the compute graph specified by a ComputeNodeRequest, as well as providing the resulting
471    /// unit for the output of a compute graph. If the resulting unit is equivalent to exactly one existing unit in the
472    /// system, it will be returned (for example, a series in Coulombs divided by a series in Volts will return an
473    /// output of Farads). If the output does not have units (for example, a range output,) the unit result will return
474    /// noUnitAvailable, and if the computation was not successful, corresponding errors are returned.
475    #[endpoint(
476        method = POST,
477        path = "/compute/v2/computeWithUnits",
478        name = "computeWithUnits",
479        accept = conjure_http::client::StdResponseDeserializer
480    )]
481    async fn compute_with_units(
482        &self,
483        #[auth]
484        auth_: &conjure_object::BearerToken,
485        #[body(serializer = conjure_http::client::StdRequestSerializer)]
486        request: &super::super::super::super::super::objects::scout::compute::api::ComputeWithUnitsRequest,
487    ) -> Result<
488        super::super::super::super::super::objects::scout::compute::api::ComputeWithUnitsResponse,
489        conjure_http::private::Error,
490    >;
491    /// Best-effort cancellation of active compute requests. Each ID should be the request ID that
492    /// the client originally passed when starting the request. A single request may correspond to
493    /// one or more underlying operations, all of which will be cancelled.
494    #[endpoint(
495        method = POST,
496        path = "/compute/v2/compute/batch/kill",
497        name = "batchKillRequests",
498        accept = conjure_http::client::conjure::EmptyResponseDeserializer
499    )]
500    async fn batch_kill_requests(
501        &self,
502        #[auth]
503        auth_: &conjure_object::BearerToken,
504        #[body(serializer = conjure_http::client::StdRequestSerializer)]
505        request: &super::super::super::super::super::objects::scout::compute::api::BatchKillRequestsRequest,
506    ) -> Result<(), conjure_http::private::Error>;
507    /// Returns a point-in-time snapshot of progress for the given active compute requests. Each
508    /// ID should be the request ID that the client originally passed when starting the request.
509    /// Intended to be polled (roughly once per second) for requests that have been running
510    /// longer than the slow-query threshold.
511    ///
512    /// A request with no active queries is not necessarily finished: its underlying queries may
513    /// not have started yet, the request may be in a post-processing phase, or the request's
514    /// work may be executed somewhere that does not report progress — in which case it stays
515    /// inactive for its entire duration. Clients should derive progress from the raw row
516    /// counters and must not assume monotonicity, since totalRowsApprox can grow while a
517    /// request runs.
518    #[endpoint(
519        method = POST,
520        path = "/compute/v2/compute/batch/progress",
521        name = "batchGetRequestProgress",
522        accept = conjure_http::client::StdResponseDeserializer
523    )]
524    async fn batch_get_request_progress(
525        &self,
526        #[auth]
527        auth_: &conjure_object::BearerToken,
528        #[body(serializer = conjure_http::client::StdRequestSerializer)]
529        request: &super::super::super::super::super::objects::scout::compute::api::BatchGetRequestProgressRequest,
530    ) -> Result<
531        super::super::super::super::super::objects::scout::compute::api::BatchGetRequestProgressResponse,
532        conjure_http::private::Error,
533    >;
534    /// Returns the calling user's compute quota usage for their current organization, one entry
535    /// per quota window. Returns no intervals when quotas are not enabled for the organization.
536    #[endpoint(
537        method = GET,
538        path = "/compute/v2/compute/quota/usage",
539        name = "getQuotaUsage",
540        accept = conjure_http::client::StdResponseDeserializer
541    )]
542    async fn get_quota_usage(
543        &self,
544        #[auth]
545        auth_: &conjure_object::BearerToken,
546    ) -> Result<
547        super::super::super::super::super::objects::scout::compute::api::GetQuotaUsageResponse,
548        conjure_http::private::Error,
549    >;
550}
nominal_api_conjure/conjure/clients/scout/compute/api/compute_service.rs

nominal_api_conjure/conjure/clients/scout/compute/api/
compute_service.rs
