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)]
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(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
94        rid: conjure_object::ResourceIdentifier,
95    ) -> Result<
96        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
97        conjure_http::private::Error,
98    >;
99    /// Update existing series metadata.
100    /// Throws SeriesMetadataNotFound if the series metadata does not exist.
101    #[endpoint(
102        method = POST,
103        path = "/timeseries/archetype/v1/series-archetype/{rid}/metadata",
104        name = "updateMetadata",
105        produces = conjure_http::server::StdResponseSerializer
106    )]
107    fn update_metadata(
108        &self,
109        #[auth]
110        auth_: conjure_object::BearerToken,
111        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
112        rid: conjure_object::ResourceIdentifier,
113        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
114        request: super::super::super::super::objects::timeseries::metadata::api::UpdateSeriesMetadataRequest,
115    ) -> Result<
116        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
117        conjure_http::private::Error,
118    >;
119    /// Batch creates series metadata for video channels if they don't exist.
120    /// Idempotent - returns existing SeriesMetadataRid if already exists.
121    #[endpoint(
122        method = POST,
123        path = "/timeseries/archetype/v1/series-archetype/video-channel",
124        name = "batchCreateVideoSeries",
125        produces = conjure_http::server::StdResponseSerializer
126    )]
127    fn batch_create_video_series(
128        &self,
129        #[auth]
130        auth_: conjure_object::BearerToken,
131        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
132        request: super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesRequest,
133    ) -> Result<
134        super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesResponse,
135        conjure_http::private::Error,
136    >;
137}
138/// [INTERNAL]
139/// Series metadata represents the constant information about data in a series - specifically, the name, units, a
140/// description, and the tags. Series metadata can be used to query points from specific series depending on the tag
141/// value selections.
142#[conjure_http::conjure_endpoints(
143    name = "SeriesMetadataService",
144    use_legacy_error_serialization
145)]
146pub trait AsyncSeriesMetadataService {
147    /// Batch get series metadata by DataSourceRid.
148    #[endpoint(
149        method = POST,
150        path = "/timeseries/archetype/v1/series-archetype/batch-get",
151        name = "batchGet",
152        produces = conjure_http::server::StdResponseSerializer
153    )]
154    async fn batch_get(
155        &self,
156        #[auth]
157        auth_: conjure_object::BearerToken,
158        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
159        request: super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataRequest,
160    ) -> Result<
161        super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataResponse,
162        conjure_http::private::Error,
163    >;
164    /// Create new series metadata.
165    #[endpoint(
166        method = POST,
167        path = "/timeseries/archetype/v1/series-archetype",
168        name = "create"
169    )]
170    async fn create(
171        &self,
172        #[auth]
173        auth_: conjure_object::BearerToken,
174        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
175        request: super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
176    ) -> Result<(), conjure_http::private::Error>;
177    /// Idempotently creates series metadata.
178    #[endpoint(
179        method = POST,
180        path = "/timeseries/archetype/v1/series-archetype/batch-create",
181        name = "batchCreate"
182    )]
183    async fn batch_create(
184        &self,
185        #[auth]
186        auth_: conjure_object::BearerToken,
187        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
188        request: super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
189    ) -> Result<(), conjure_http::private::Error>;
190    /// Upserts series metadata. Creates new series metadata if it does not exist for the given channel and data
191    /// source. If it already exists, updates the locator and any provided unit and description fields while
192    /// preserving existing values for fields not supplied.
193    #[endpoint(
194        method = POST,
195        path = "/timeseries/archetype/v1/series-archetype/create-or-update",
196        name = "createOrUpdate"
197    )]
198    async fn create_or_update(
199        &self,
200        #[auth]
201        auth_: conjure_object::BearerToken,
202        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
203        request: super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
204    ) -> Result<(), conjure_http::private::Error>;
205    /// Batch version of createOrUpdate.
206    #[endpoint(
207        method = POST,
208        path = "/timeseries/archetype/v1/series-archetype/batch-create-or-update",
209        name = "batchCreateOrUpdate"
210    )]
211    async fn batch_create_or_update(
212        &self,
213        #[auth]
214        auth_: conjure_object::BearerToken,
215        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
216        request: super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
217    ) -> Result<(), conjure_http::private::Error>;
218    /// Get series metadata from its series metadata rid.
219    #[endpoint(
220        method = GET,
221        path = "/timeseries/archetype/v1/series-archetype/{rid}",
222        name = "get",
223        produces = conjure_http::server::StdResponseSerializer
224    )]
225    async fn get(
226        &self,
227        #[auth]
228        auth_: conjure_object::BearerToken,
229        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
230        rid: conjure_object::ResourceIdentifier,
231    ) -> Result<
232        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
233        conjure_http::private::Error,
234    >;
235    /// Update existing series metadata.
236    /// Throws SeriesMetadataNotFound if the series metadata does not exist.
237    #[endpoint(
238        method = POST,
239        path = "/timeseries/archetype/v1/series-archetype/{rid}/metadata",
240        name = "updateMetadata",
241        produces = conjure_http::server::StdResponseSerializer
242    )]
243    async fn update_metadata(
244        &self,
245        #[auth]
246        auth_: conjure_object::BearerToken,
247        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
248        rid: conjure_object::ResourceIdentifier,
249        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
250        request: super::super::super::super::objects::timeseries::metadata::api::UpdateSeriesMetadataRequest,
251    ) -> Result<
252        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
253        conjure_http::private::Error,
254    >;
255    /// Batch creates series metadata for video channels if they don't exist.
256    /// Idempotent - returns existing SeriesMetadataRid if already exists.
257    #[endpoint(
258        method = POST,
259        path = "/timeseries/archetype/v1/series-archetype/video-channel",
260        name = "batchCreateVideoSeries",
261        produces = conjure_http::server::StdResponseSerializer
262    )]
263    async fn batch_create_video_series(
264        &self,
265        #[auth]
266        auth_: conjure_object::BearerToken,
267        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
268        request: super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesRequest,
269    ) -> Result<
270        super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesResponse,
271        conjure_http::private::Error,
272    >;
273}
274/// [INTERNAL]
275/// Series metadata represents the constant information about data in a series - specifically, the name, units, a
276/// description, and the tags. Series metadata can be used to query points from specific series depending on the tag
277/// value selections.
278#[conjure_http::conjure_endpoints(
279    name = "SeriesMetadataService",
280    use_legacy_error_serialization,
281    local
282)]
283pub trait LocalAsyncSeriesMetadataService {
284    /// Batch get series metadata by DataSourceRid.
285    #[endpoint(
286        method = POST,
287        path = "/timeseries/archetype/v1/series-archetype/batch-get",
288        name = "batchGet",
289        produces = conjure_http::server::StdResponseSerializer
290    )]
291    async fn batch_get(
292        &self,
293        #[auth]
294        auth_: conjure_object::BearerToken,
295        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
296        request: super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataRequest,
297    ) -> Result<
298        super::super::super::super::objects::timeseries::metadata::api::BatchGetSeriesMetadataResponse,
299        conjure_http::private::Error,
300    >;
301    /// Create new series metadata.
302    #[endpoint(
303        method = POST,
304        path = "/timeseries/archetype/v1/series-archetype",
305        name = "create"
306    )]
307    async fn create(
308        &self,
309        #[auth]
310        auth_: conjure_object::BearerToken,
311        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
312        request: super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
313    ) -> Result<(), conjure_http::private::Error>;
314    /// Idempotently creates series metadata.
315    #[endpoint(
316        method = POST,
317        path = "/timeseries/archetype/v1/series-archetype/batch-create",
318        name = "batchCreate"
319    )]
320    async fn batch_create(
321        &self,
322        #[auth]
323        auth_: conjure_object::BearerToken,
324        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
325        request: super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
326    ) -> Result<(), conjure_http::private::Error>;
327    /// Upserts series metadata. Creates new series metadata if it does not exist for the given channel and data
328    /// source. If it already exists, updates the locator and any provided unit and description fields while
329    /// preserving existing values for fields not supplied.
330    #[endpoint(
331        method = POST,
332        path = "/timeseries/archetype/v1/series-archetype/create-or-update",
333        name = "createOrUpdate"
334    )]
335    async fn create_or_update(
336        &self,
337        #[auth]
338        auth_: conjure_object::BearerToken,
339        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
340        request: super::super::super::super::objects::timeseries::metadata::api::CreateSeriesMetadataRequest,
341    ) -> Result<(), conjure_http::private::Error>;
342    /// Batch version of createOrUpdate.
343    #[endpoint(
344        method = POST,
345        path = "/timeseries/archetype/v1/series-archetype/batch-create-or-update",
346        name = "batchCreateOrUpdate"
347    )]
348    async fn batch_create_or_update(
349        &self,
350        #[auth]
351        auth_: conjure_object::BearerToken,
352        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
353        request: super::super::super::super::objects::timeseries::metadata::api::BatchCreateSeriesMetadataRequest,
354    ) -> Result<(), conjure_http::private::Error>;
355    /// Get series metadata from its series metadata rid.
356    #[endpoint(
357        method = GET,
358        path = "/timeseries/archetype/v1/series-archetype/{rid}",
359        name = "get",
360        produces = conjure_http::server::StdResponseSerializer
361    )]
362    async fn get(
363        &self,
364        #[auth]
365        auth_: conjure_object::BearerToken,
366        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
367        rid: conjure_object::ResourceIdentifier,
368    ) -> Result<
369        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
370        conjure_http::private::Error,
371    >;
372    /// Update existing series metadata.
373    /// Throws SeriesMetadataNotFound if the series metadata does not exist.
374    #[endpoint(
375        method = POST,
376        path = "/timeseries/archetype/v1/series-archetype/{rid}/metadata",
377        name = "updateMetadata",
378        produces = conjure_http::server::StdResponseSerializer
379    )]
380    async fn update_metadata(
381        &self,
382        #[auth]
383        auth_: conjure_object::BearerToken,
384        #[path(name = "rid", decoder = conjure_http::server::conjure::FromPlainDecoder)]
385        rid: conjure_object::ResourceIdentifier,
386        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
387        request: super::super::super::super::objects::timeseries::metadata::api::UpdateSeriesMetadataRequest,
388    ) -> Result<
389        super::super::super::super::objects::timeseries::metadata::api::SeriesMetadata,
390        conjure_http::private::Error,
391    >;
392    /// Batch creates series metadata for video channels if they don't exist.
393    /// Idempotent - returns existing SeriesMetadataRid if already exists.
394    #[endpoint(
395        method = POST,
396        path = "/timeseries/archetype/v1/series-archetype/video-channel",
397        name = "batchCreateVideoSeries",
398        produces = conjure_http::server::StdResponseSerializer
399    )]
400    async fn batch_create_video_series(
401        &self,
402        #[auth]
403        auth_: conjure_object::BearerToken,
404        #[body(deserializer = conjure_http::server::StdRequestDeserializer)]
405        request: super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesRequest,
406    ) -> Result<
407        super::super::super::super::objects::timeseries::metadata::api::BatchCreateVideoSeriesResponse,
408        conjure_http::private::Error,
409    >;
410}