Skip to main content

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