Skip to main content

nominal_api/conjure/clients/scout/channel/api/
channel_search_service.rs

1use conjure_http::endpoint;
2/// Channel search over a `DataFrame`, which can expand to multiple locators.
3#[conjure_http::conjure_client(name = "ChannelSearchService")]
4pub trait ChannelSearchService<
5    #[response_body]
6    I: Iterator<
7            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
8        >,
9> {
10    /// Returns the expanded locator topology for a frame plus per-locator delimiter
11    /// info.
12    #[endpoint(
13        method = POST,
14        path = "/channels/v1/delimiters",
15        name = "getLocatorDelimiters",
16        accept = conjure_http::client::StdResponseDeserializer
17    )]
18    fn get_locator_delimiters(
19        &self,
20        #[auth]
21        auth_: &conjure_object::BearerToken,
22        #[body(serializer = conjure_http::client::StdRequestSerializer)]
23        request: &super::super::super::super::super::objects::scout::channel::api::GetLocatorDelimitersRequest,
24    ) -> Result<
25        super::super::super::super::super::objects::scout::channel::api::GetLocatorDelimitersResponse,
26        conjure_http::private::Error,
27    >;
28    /// Lazy one-level hierarchical expansion under `parent`. Returns a mix of leaf
29    /// channels and prefix nodes, each labelled with the set of locators where
30    /// they exist.
31    #[endpoint(
32        method = POST,
33        path = "/channels/v1/browse",
34        name = "listChannelChildren",
35        accept = conjure_http::client::StdResponseDeserializer
36    )]
37    fn list_channel_children(
38        &self,
39        #[auth]
40        auth_: &conjure_object::BearerToken,
41        #[body(serializer = conjure_http::client::StdRequestSerializer)]
42        request: &super::super::super::super::super::objects::scout::channel::api::ListChannelChildrenRequest,
43    ) -> Result<
44        super::super::super::super::super::objects::scout::channel::api::ListChannelChildrenResponse,
45        conjure_http::private::Error,
46    >;
47    /// Flat text search across the frame. Returns matching channels, each labelled
48    /// with the set of locators in which they exist.
49    #[endpoint(
50        method = POST,
51        path = "/channels/v1/search",
52        name = "searchChannels",
53        accept = conjure_http::client::StdResponseDeserializer
54    )]
55    fn search_channels(
56        &self,
57        #[auth]
58        auth_: &conjure_object::BearerToken,
59        #[body(serializer = conjure_http::client::StdRequestSerializer)]
60        request: &super::super::super::super::super::objects::scout::channel::api::SearchChannelsRequest,
61    ) -> Result<
62        super::super::super::super::super::objects::scout::channel::api::SearchChannelsResponse,
63        conjure_http::private::Error,
64    >;
65    /// Batched form of `getLocatorDelimiters`.
66    #[endpoint(
67        method = POST,
68        path = "/channels/v1/delimiters/batch",
69        name = "batchGetLocatorDelimiters",
70        accept = conjure_http::client::StdResponseDeserializer
71    )]
72    fn batch_get_locator_delimiters(
73        &self,
74        #[auth]
75        auth_: &conjure_object::BearerToken,
76        #[body(serializer = conjure_http::client::StdRequestSerializer)]
77        request: &super::super::super::super::super::objects::scout::channel::api::BatchGetLocatorDelimitersRequest,
78    ) -> Result<
79        super::super::super::super::super::objects::scout::channel::api::BatchGetLocatorDelimitersResponse,
80        conjure_http::private::Error,
81    >;
82    /// Batched form of `searchChannels`. The channel search is performed across the
83    /// union of all entry scopes and so is the limit and top-n selection by relevance.
84    #[endpoint(
85        method = POST,
86        path = "/channels/v1/search/batch",
87        name = "batchSearchChannels",
88        accept = conjure_http::client::StdResponseDeserializer
89    )]
90    fn batch_search_channels(
91        &self,
92        #[auth]
93        auth_: &conjure_object::BearerToken,
94        #[body(serializer = conjure_http::client::StdRequestSerializer)]
95        request: &super::super::super::super::super::objects::scout::channel::api::BatchSearchChannelsRequest,
96    ) -> Result<
97        super::super::super::super::super::objects::scout::channel::api::BatchSearchChannelsResponse,
98        conjure_http::private::Error,
99    >;
100    /// Batched form of `listChannelChildren`. The hierarchical expansion is performed
101    /// across the union of all entry scopes for the shared `parent` path.
102    #[endpoint(
103        method = POST,
104        path = "/channels/v1/browse/batch",
105        name = "batchListChannelChildren",
106        accept = conjure_http::client::StdResponseDeserializer
107    )]
108    fn batch_list_channel_children(
109        &self,
110        #[auth]
111        auth_: &conjure_object::BearerToken,
112        #[body(serializer = conjure_http::client::StdRequestSerializer)]
113        request: &super::super::super::super::super::objects::scout::channel::api::BatchListChannelChildrenRequest,
114    ) -> Result<
115        super::super::super::super::super::objects::scout::channel::api::BatchListChannelChildrenResponse,
116        conjure_http::private::Error,
117    >;
118}
119/// Channel search over a `DataFrame`, which can expand to multiple locators.
120#[conjure_http::conjure_client(name = "ChannelSearchService")]
121pub trait AsyncChannelSearchService<
122    #[response_body]
123    I: conjure_http::private::Stream<
124            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
125        >,
126> {
127    /// Returns the expanded locator topology for a frame plus per-locator delimiter
128    /// info.
129    #[endpoint(
130        method = POST,
131        path = "/channels/v1/delimiters",
132        name = "getLocatorDelimiters",
133        accept = conjure_http::client::StdResponseDeserializer
134    )]
135    async fn get_locator_delimiters(
136        &self,
137        #[auth]
138        auth_: &conjure_object::BearerToken,
139        #[body(serializer = conjure_http::client::StdRequestSerializer)]
140        request: &super::super::super::super::super::objects::scout::channel::api::GetLocatorDelimitersRequest,
141    ) -> Result<
142        super::super::super::super::super::objects::scout::channel::api::GetLocatorDelimitersResponse,
143        conjure_http::private::Error,
144    >;
145    /// Lazy one-level hierarchical expansion under `parent`. Returns a mix of leaf
146    /// channels and prefix nodes, each labelled with the set of locators where
147    /// they exist.
148    #[endpoint(
149        method = POST,
150        path = "/channels/v1/browse",
151        name = "listChannelChildren",
152        accept = conjure_http::client::StdResponseDeserializer
153    )]
154    async fn list_channel_children(
155        &self,
156        #[auth]
157        auth_: &conjure_object::BearerToken,
158        #[body(serializer = conjure_http::client::StdRequestSerializer)]
159        request: &super::super::super::super::super::objects::scout::channel::api::ListChannelChildrenRequest,
160    ) -> Result<
161        super::super::super::super::super::objects::scout::channel::api::ListChannelChildrenResponse,
162        conjure_http::private::Error,
163    >;
164    /// Flat text search across the frame. Returns matching channels, each labelled
165    /// with the set of locators in which they exist.
166    #[endpoint(
167        method = POST,
168        path = "/channels/v1/search",
169        name = "searchChannels",
170        accept = conjure_http::client::StdResponseDeserializer
171    )]
172    async fn search_channels(
173        &self,
174        #[auth]
175        auth_: &conjure_object::BearerToken,
176        #[body(serializer = conjure_http::client::StdRequestSerializer)]
177        request: &super::super::super::super::super::objects::scout::channel::api::SearchChannelsRequest,
178    ) -> Result<
179        super::super::super::super::super::objects::scout::channel::api::SearchChannelsResponse,
180        conjure_http::private::Error,
181    >;
182    /// Batched form of `getLocatorDelimiters`.
183    #[endpoint(
184        method = POST,
185        path = "/channels/v1/delimiters/batch",
186        name = "batchGetLocatorDelimiters",
187        accept = conjure_http::client::StdResponseDeserializer
188    )]
189    async fn batch_get_locator_delimiters(
190        &self,
191        #[auth]
192        auth_: &conjure_object::BearerToken,
193        #[body(serializer = conjure_http::client::StdRequestSerializer)]
194        request: &super::super::super::super::super::objects::scout::channel::api::BatchGetLocatorDelimitersRequest,
195    ) -> Result<
196        super::super::super::super::super::objects::scout::channel::api::BatchGetLocatorDelimitersResponse,
197        conjure_http::private::Error,
198    >;
199    /// Batched form of `searchChannels`. The channel search is performed across the
200    /// union of all entry scopes and so is the limit and top-n selection by relevance.
201    #[endpoint(
202        method = POST,
203        path = "/channels/v1/search/batch",
204        name = "batchSearchChannels",
205        accept = conjure_http::client::StdResponseDeserializer
206    )]
207    async fn batch_search_channels(
208        &self,
209        #[auth]
210        auth_: &conjure_object::BearerToken,
211        #[body(serializer = conjure_http::client::StdRequestSerializer)]
212        request: &super::super::super::super::super::objects::scout::channel::api::BatchSearchChannelsRequest,
213    ) -> Result<
214        super::super::super::super::super::objects::scout::channel::api::BatchSearchChannelsResponse,
215        conjure_http::private::Error,
216    >;
217    /// Batched form of `listChannelChildren`. The hierarchical expansion is performed
218    /// across the union of all entry scopes for the shared `parent` path.
219    #[endpoint(
220        method = POST,
221        path = "/channels/v1/browse/batch",
222        name = "batchListChannelChildren",
223        accept = conjure_http::client::StdResponseDeserializer
224    )]
225    async fn batch_list_channel_children(
226        &self,
227        #[auth]
228        auth_: &conjure_object::BearerToken,
229        #[body(serializer = conjure_http::client::StdRequestSerializer)]
230        request: &super::super::super::super::super::objects::scout::channel::api::BatchListChannelChildrenRequest,
231    ) -> Result<
232        super::super::super::super::super::objects::scout::channel::api::BatchListChannelChildrenResponse,
233        conjure_http::private::Error,
234    >;
235}
236/// Channel search over a `DataFrame`, which can expand to multiple locators.
237#[conjure_http::conjure_client(name = "ChannelSearchService", local)]
238pub trait LocalAsyncChannelSearchService<
239    #[response_body]
240    I: conjure_http::private::Stream<
241            Item = Result<conjure_http::private::Bytes, conjure_http::private::Error>,
242        >,
243> {
244    /// Returns the expanded locator topology for a frame plus per-locator delimiter
245    /// info.
246    #[endpoint(
247        method = POST,
248        path = "/channels/v1/delimiters",
249        name = "getLocatorDelimiters",
250        accept = conjure_http::client::StdResponseDeserializer
251    )]
252    async fn get_locator_delimiters(
253        &self,
254        #[auth]
255        auth_: &conjure_object::BearerToken,
256        #[body(serializer = conjure_http::client::StdRequestSerializer)]
257        request: &super::super::super::super::super::objects::scout::channel::api::GetLocatorDelimitersRequest,
258    ) -> Result<
259        super::super::super::super::super::objects::scout::channel::api::GetLocatorDelimitersResponse,
260        conjure_http::private::Error,
261    >;
262    /// Lazy one-level hierarchical expansion under `parent`. Returns a mix of leaf
263    /// channels and prefix nodes, each labelled with the set of locators where
264    /// they exist.
265    #[endpoint(
266        method = POST,
267        path = "/channels/v1/browse",
268        name = "listChannelChildren",
269        accept = conjure_http::client::StdResponseDeserializer
270    )]
271    async fn list_channel_children(
272        &self,
273        #[auth]
274        auth_: &conjure_object::BearerToken,
275        #[body(serializer = conjure_http::client::StdRequestSerializer)]
276        request: &super::super::super::super::super::objects::scout::channel::api::ListChannelChildrenRequest,
277    ) -> Result<
278        super::super::super::super::super::objects::scout::channel::api::ListChannelChildrenResponse,
279        conjure_http::private::Error,
280    >;
281    /// Flat text search across the frame. Returns matching channels, each labelled
282    /// with the set of locators in which they exist.
283    #[endpoint(
284        method = POST,
285        path = "/channels/v1/search",
286        name = "searchChannels",
287        accept = conjure_http::client::StdResponseDeserializer
288    )]
289    async fn search_channels(
290        &self,
291        #[auth]
292        auth_: &conjure_object::BearerToken,
293        #[body(serializer = conjure_http::client::StdRequestSerializer)]
294        request: &super::super::super::super::super::objects::scout::channel::api::SearchChannelsRequest,
295    ) -> Result<
296        super::super::super::super::super::objects::scout::channel::api::SearchChannelsResponse,
297        conjure_http::private::Error,
298    >;
299    /// Batched form of `getLocatorDelimiters`.
300    #[endpoint(
301        method = POST,
302        path = "/channels/v1/delimiters/batch",
303        name = "batchGetLocatorDelimiters",
304        accept = conjure_http::client::StdResponseDeserializer
305    )]
306    async fn batch_get_locator_delimiters(
307        &self,
308        #[auth]
309        auth_: &conjure_object::BearerToken,
310        #[body(serializer = conjure_http::client::StdRequestSerializer)]
311        request: &super::super::super::super::super::objects::scout::channel::api::BatchGetLocatorDelimitersRequest,
312    ) -> Result<
313        super::super::super::super::super::objects::scout::channel::api::BatchGetLocatorDelimitersResponse,
314        conjure_http::private::Error,
315    >;
316    /// Batched form of `searchChannels`. The channel search is performed across the
317    /// union of all entry scopes and so is the limit and top-n selection by relevance.
318    #[endpoint(
319        method = POST,
320        path = "/channels/v1/search/batch",
321        name = "batchSearchChannels",
322        accept = conjure_http::client::StdResponseDeserializer
323    )]
324    async fn batch_search_channels(
325        &self,
326        #[auth]
327        auth_: &conjure_object::BearerToken,
328        #[body(serializer = conjure_http::client::StdRequestSerializer)]
329        request: &super::super::super::super::super::objects::scout::channel::api::BatchSearchChannelsRequest,
330    ) -> Result<
331        super::super::super::super::super::objects::scout::channel::api::BatchSearchChannelsResponse,
332        conjure_http::private::Error,
333    >;
334    /// Batched form of `listChannelChildren`. The hierarchical expansion is performed
335    /// across the union of all entry scopes for the shared `parent` path.
336    #[endpoint(
337        method = POST,
338        path = "/channels/v1/browse/batch",
339        name = "batchListChannelChildren",
340        accept = conjure_http::client::StdResponseDeserializer
341    )]
342    async fn batch_list_channel_children(
343        &self,
344        #[auth]
345        auth_: &conjure_object::BearerToken,
346        #[body(serializer = conjure_http::client::StdRequestSerializer)]
347        request: &super::super::super::super::super::objects::scout::channel::api::BatchListChannelChildrenRequest,
348    ) -> Result<
349        super::super::super::super::super::objects::scout::channel::api::BatchListChannelChildrenResponse,
350        conjure_http::private::Error,
351    >;
352}