Skip to main content

nominal_api/conjure/clients/timeseries/metadata/
series_metadata_service.rs

1use conjure_http::endpoint;
2/// [INTERNAL]
3/// Series metadata represents the constant information about data in a series - specifically, the name, units, a
4/// description, and the tags. Series metadata can be used to query points from specific series depending on the tag
5/// value selections.
6#[conjure_http::conjure_client(name = "SeriesMetadataService")]
7pub trait SeriesMetadataService<
8    #[response_body]
9    I: Iterator<
10            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
11        >,
12> {
13    /// Batch get series metadata by DataSourceRid.
14    #[endpoint(
15        method = POST,
16        path = "/timeseries/archetype/v1/series-archetype/batch-get",
17        name = "batchGet",
18        accept = conjure_http::client::StdResponseDeserializer
19    )]
20    fn batch_get(
21        &self,
22        #[auth]
23        auth_: &conjure_object::BearerToken,
24        #[body(serializer = conjure_http::client::StdRequestSerializer)]
25        request: &super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataRequest,
26    ) -> Result<
27        super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataResponse,
28        conjure_http::private::Error,
29    >;
30    /// Create new series metadata.
31    #[endpoint(
32        method = POST,
33        path = "/timeseries/archetype/v1/series-archetype",
34        name = "create",
35        accept = conjure_http::client::conjure::EmptyResponseDeserializer
36    )]
37    fn create(
38        &self,
39        #[auth]
40        auth_: &conjure_object::BearerToken,
41        #[body(serializer = conjure_http::client::StdRequestSerializer)]
42        request: &super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
43    ) -> Result<(), conjure_http::private::Error>;
44    /// Idempotently creates series metadata.
45    #[endpoint(
46        method = POST,
47        path = "/timeseries/archetype/v1/series-archetype/batch-create",
48        name = "batchCreate",
49        accept = conjure_http::client::conjure::EmptyResponseDeserializer
50    )]
51    fn batch_create(
52        &self,
53        #[auth]
54        auth_: &conjure_object::BearerToken,
55        #[body(serializer = conjure_http::client::StdRequestSerializer)]
56        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
57    ) -> Result<(), conjure_http::private::Error>;
58    /// Upserts series metadata. Creates new series metadata if it does not exist for the given channel and data
59    /// source. If it already exists, updates the locator and any provided unit and description fields while
60    /// preserving existing values for fields not supplied.
61    #[endpoint(
62        method = POST,
63        path = "/timeseries/archetype/v1/series-archetype/create-or-update",
64        name = "createOrUpdate",
65        accept = conjure_http::client::conjure::EmptyResponseDeserializer
66    )]
67    fn create_or_update(
68        &self,
69        #[auth]
70        auth_: &conjure_object::BearerToken,
71        #[body(serializer = conjure_http::client::StdRequestSerializer)]
72        request: &super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
73    ) -> Result<(), conjure_http::private::Error>;
74    /// Batch version of createOrUpdate.
75    #[endpoint(
76        method = POST,
77        path = "/timeseries/archetype/v1/series-archetype/batch-create-or-update",
78        name = "batchCreateOrUpdate",
79        accept = conjure_http::client::conjure::EmptyResponseDeserializer
80    )]
81    fn batch_create_or_update(
82        &self,
83        #[auth]
84        auth_: &conjure_object::BearerToken,
85        #[body(serializer = conjure_http::client::StdRequestSerializer)]
86        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
87    ) -> Result<(), conjure_http::private::Error>;
88    /// Get series metadata from its series metadata rid.
89    #[endpoint(
90        method = GET,
91        path = "/timeseries/archetype/v1/series-archetype/{rid}",
92        name = "get",
93        accept = conjure_http::client::StdResponseDeserializer
94    )]
95    fn get(
96        &self,
97        #[auth]
98        auth_: &conjure_object::BearerToken,
99        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
100        rid: &super::super::super::super::objects::api::SeriesMetadataRid,
101    ) -> Result<
102        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
103        conjure_http::private::Error,
104    >;
105    /// Update existing series metadata.
106    /// Throws SeriesMetadataNotFound if the series metadata does not exist.
107    #[endpoint(
108        method = POST,
109        path = "/timeseries/archetype/v1/series-archetype/{rid}/metadata",
110        name = "updateMetadata",
111        accept = conjure_http::client::StdResponseDeserializer
112    )]
113    fn update_metadata(
114        &self,
115        #[auth]
116        auth_: &conjure_object::BearerToken,
117        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
118        rid: &super::super::super::super::objects::api::SeriesMetadataRid,
119        #[body(serializer = conjure_http::client::StdRequestSerializer)]
120        request: &super::super::super::super::objects::timeseries::metadata::api::UpdateSeriesMetadataRequest,
121    ) -> Result<
122        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
123        conjure_http::private::Error,
124    >;
125    /// Batch creates series metadata for video channels if they don't exist.
126    /// Idempotent - returns existing SeriesMetadataRid if already exists.
127    #[endpoint(
128        method = POST,
129        path = "/timeseries/archetype/v1/series-archetype/video-channel",
130        name = "batchCreateVideoSeries",
131        accept = conjure_http::client::StdResponseDeserializer
132    )]
133    fn batch_create_video_series(
134        &self,
135        #[auth]
136        auth_: &conjure_object::BearerToken,
137        #[body(serializer = conjure_http::client::StdRequestSerializer)]
138        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesRequest,
139    ) -> Result<
140        super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesResponse,
141        conjure_http::private::Error,
142    >;
143}
144/// [INTERNAL]
145/// Series metadata represents the constant information about data in a series - specifically, the name, units, a
146/// description, and the tags. Series metadata can be used to query points from specific series depending on the tag
147/// value selections.
148#[conjure_http::conjure_client(name = "SeriesMetadataService")]
149pub trait AsyncSeriesMetadataService<
150    #[response_body]
151    I: conjure_http::private::Stream<
152            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
153        >,
154> {
155    /// Batch get series metadata by DataSourceRid.
156    #[endpoint(
157        method = POST,
158        path = "/timeseries/archetype/v1/series-archetype/batch-get",
159        name = "batchGet",
160        accept = conjure_http::client::StdResponseDeserializer
161    )]
162    async fn batch_get(
163        &self,
164        #[auth]
165        auth_: &conjure_object::BearerToken,
166        #[body(serializer = conjure_http::client::StdRequestSerializer)]
167        request: &super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataRequest,
168    ) -> Result<
169        super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataResponse,
170        conjure_http::private::Error,
171    >;
172    /// Create new series metadata.
173    #[endpoint(
174        method = POST,
175        path = "/timeseries/archetype/v1/series-archetype",
176        name = "create",
177        accept = conjure_http::client::conjure::EmptyResponseDeserializer
178    )]
179    async fn create(
180        &self,
181        #[auth]
182        auth_: &conjure_object::BearerToken,
183        #[body(serializer = conjure_http::client::StdRequestSerializer)]
184        request: &super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
185    ) -> Result<(), conjure_http::private::Error>;
186    /// Idempotently creates series metadata.
187    #[endpoint(
188        method = POST,
189        path = "/timeseries/archetype/v1/series-archetype/batch-create",
190        name = "batchCreate",
191        accept = conjure_http::client::conjure::EmptyResponseDeserializer
192    )]
193    async fn batch_create(
194        &self,
195        #[auth]
196        auth_: &conjure_object::BearerToken,
197        #[body(serializer = conjure_http::client::StdRequestSerializer)]
198        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
199    ) -> Result<(), conjure_http::private::Error>;
200    /// Upserts series metadata. Creates new series metadata if it does not exist for the given channel and data
201    /// source. If it already exists, updates the locator and any provided unit and description fields while
202    /// preserving existing values for fields not supplied.
203    #[endpoint(
204        method = POST,
205        path = "/timeseries/archetype/v1/series-archetype/create-or-update",
206        name = "createOrUpdate",
207        accept = conjure_http::client::conjure::EmptyResponseDeserializer
208    )]
209    async fn create_or_update(
210        &self,
211        #[auth]
212        auth_: &conjure_object::BearerToken,
213        #[body(serializer = conjure_http::client::StdRequestSerializer)]
214        request: &super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
215    ) -> Result<(), conjure_http::private::Error>;
216    /// Batch version of createOrUpdate.
217    #[endpoint(
218        method = POST,
219        path = "/timeseries/archetype/v1/series-archetype/batch-create-or-update",
220        name = "batchCreateOrUpdate",
221        accept = conjure_http::client::conjure::EmptyResponseDeserializer
222    )]
223    async fn batch_create_or_update(
224        &self,
225        #[auth]
226        auth_: &conjure_object::BearerToken,
227        #[body(serializer = conjure_http::client::StdRequestSerializer)]
228        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
229    ) -> Result<(), conjure_http::private::Error>;
230    /// Get series metadata from its series metadata rid.
231    #[endpoint(
232        method = GET,
233        path = "/timeseries/archetype/v1/series-archetype/{rid}",
234        name = "get",
235        accept = conjure_http::client::StdResponseDeserializer
236    )]
237    async fn get(
238        &self,
239        #[auth]
240        auth_: &conjure_object::BearerToken,
241        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
242        rid: &super::super::super::super::objects::api::SeriesMetadataRid,
243    ) -> Result<
244        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
245        conjure_http::private::Error,
246    >;
247    /// Update existing series metadata.
248    /// Throws SeriesMetadataNotFound if the series metadata does not exist.
249    #[endpoint(
250        method = POST,
251        path = "/timeseries/archetype/v1/series-archetype/{rid}/metadata",
252        name = "updateMetadata",
253        accept = conjure_http::client::StdResponseDeserializer
254    )]
255    async fn update_metadata(
256        &self,
257        #[auth]
258        auth_: &conjure_object::BearerToken,
259        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
260        rid: &super::super::super::super::objects::api::SeriesMetadataRid,
261        #[body(serializer = conjure_http::client::StdRequestSerializer)]
262        request: &super::super::super::super::objects::timeseries::metadata::api::UpdateSeriesMetadataRequest,
263    ) -> Result<
264        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
265        conjure_http::private::Error,
266    >;
267    /// Batch creates series metadata for video channels if they don't exist.
268    /// Idempotent - returns existing SeriesMetadataRid if already exists.
269    #[endpoint(
270        method = POST,
271        path = "/timeseries/archetype/v1/series-archetype/video-channel",
272        name = "batchCreateVideoSeries",
273        accept = conjure_http::client::StdResponseDeserializer
274    )]
275    async fn batch_create_video_series(
276        &self,
277        #[auth]
278        auth_: &conjure_object::BearerToken,
279        #[body(serializer = conjure_http::client::StdRequestSerializer)]
280        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesRequest,
281    ) -> Result<
282        super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesResponse,
283        conjure_http::private::Error,
284    >;
285}
286/// [INTERNAL]
287/// Series metadata represents the constant information about data in a series - specifically, the name, units, a
288/// description, and the tags. Series metadata can be used to query points from specific series depending on the tag
289/// value selections.
290#[conjure_http::conjure_client(name = "SeriesMetadataService", local)]
291pub trait LocalAsyncSeriesMetadataService<
292    #[response_body]
293    I: conjure_http::private::Stream<
294            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
295        >,
296> {
297    /// Batch get series metadata by DataSourceRid.
298    #[endpoint(
299        method = POST,
300        path = "/timeseries/archetype/v1/series-archetype/batch-get",
301        name = "batchGet",
302        accept = conjure_http::client::StdResponseDeserializer
303    )]
304    async fn batch_get(
305        &self,
306        #[auth]
307        auth_: &conjure_object::BearerToken,
308        #[body(serializer = conjure_http::client::StdRequestSerializer)]
309        request: &super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataRequest,
310    ) -> Result<
311        super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataResponse,
312        conjure_http::private::Error,
313    >;
314    /// Create new series metadata.
315    #[endpoint(
316        method = POST,
317        path = "/timeseries/archetype/v1/series-archetype",
318        name = "create",
319        accept = conjure_http::client::conjure::EmptyResponseDeserializer
320    )]
321    async fn create(
322        &self,
323        #[auth]
324        auth_: &conjure_object::BearerToken,
325        #[body(serializer = conjure_http::client::StdRequestSerializer)]
326        request: &super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
327    ) -> Result<(), conjure_http::private::Error>;
328    /// Idempotently creates series metadata.
329    #[endpoint(
330        method = POST,
331        path = "/timeseries/archetype/v1/series-archetype/batch-create",
332        name = "batchCreate",
333        accept = conjure_http::client::conjure::EmptyResponseDeserializer
334    )]
335    async fn batch_create(
336        &self,
337        #[auth]
338        auth_: &conjure_object::BearerToken,
339        #[body(serializer = conjure_http::client::StdRequestSerializer)]
340        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
341    ) -> Result<(), conjure_http::private::Error>;
342    /// Upserts series metadata. Creates new series metadata if it does not exist for the given channel and data
343    /// source. If it already exists, updates the locator and any provided unit and description fields while
344    /// preserving existing values for fields not supplied.
345    #[endpoint(
346        method = POST,
347        path = "/timeseries/archetype/v1/series-archetype/create-or-update",
348        name = "createOrUpdate",
349        accept = conjure_http::client::conjure::EmptyResponseDeserializer
350    )]
351    async fn create_or_update(
352        &self,
353        #[auth]
354        auth_: &conjure_object::BearerToken,
355        #[body(serializer = conjure_http::client::StdRequestSerializer)]
356        request: &super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
357    ) -> Result<(), conjure_http::private::Error>;
358    /// Batch version of createOrUpdate.
359    #[endpoint(
360        method = POST,
361        path = "/timeseries/archetype/v1/series-archetype/batch-create-or-update",
362        name = "batchCreateOrUpdate",
363        accept = conjure_http::client::conjure::EmptyResponseDeserializer
364    )]
365    async fn batch_create_or_update(
366        &self,
367        #[auth]
368        auth_: &conjure_object::BearerToken,
369        #[body(serializer = conjure_http::client::StdRequestSerializer)]
370        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
371    ) -> Result<(), conjure_http::private::Error>;
372    /// Get series metadata from its series metadata rid.
373    #[endpoint(
374        method = GET,
375        path = "/timeseries/archetype/v1/series-archetype/{rid}",
376        name = "get",
377        accept = conjure_http::client::StdResponseDeserializer
378    )]
379    async fn get(
380        &self,
381        #[auth]
382        auth_: &conjure_object::BearerToken,
383        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
384        rid: &super::super::super::super::objects::api::SeriesMetadataRid,
385    ) -> Result<
386        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
387        conjure_http::private::Error,
388    >;
389    /// Update existing series metadata.
390    /// Throws SeriesMetadataNotFound if the series metadata does not exist.
391    #[endpoint(
392        method = POST,
393        path = "/timeseries/archetype/v1/series-archetype/{rid}/metadata",
394        name = "updateMetadata",
395        accept = conjure_http::client::StdResponseDeserializer
396    )]
397    async fn update_metadata(
398        &self,
399        #[auth]
400        auth_: &conjure_object::BearerToken,
401        #[path(name = "rid", encoder = conjure_http::client::conjure::PlainEncoder)]
402        rid: &super::super::super::super::objects::api::SeriesMetadataRid,
403        #[body(serializer = conjure_http::client::StdRequestSerializer)]
404        request: &super::super::super::super::objects::timeseries::metadata::api::UpdateSeriesMetadataRequest,
405    ) -> Result<
406        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
407        conjure_http::private::Error,
408    >;
409    /// Batch creates series metadata for video channels if they don't exist.
410    /// Idempotent - returns existing SeriesMetadataRid if already exists.
411    #[endpoint(
412        method = POST,
413        path = "/timeseries/archetype/v1/series-archetype/video-channel",
414        name = "batchCreateVideoSeries",
415        accept = conjure_http::client::StdResponseDeserializer
416    )]
417    async fn batch_create_video_series(
418        &self,
419        #[auth]
420        auth_: &conjure_object::BearerToken,
421        #[body(serializer = conjure_http::client::StdRequestSerializer)]
422        request: &super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesRequest,
423    ) -> Result<
424        super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesResponse,
425        conjure_http::private::Error,
426    >;
427}