ARI: Add tones playback resource
[asterisk/asterisk.git] / res / ari / resource_channels.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012 - 2013, Digium, Inc.
5  *
6  * David M. Lee, II <dlee@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Generated file - declares stubs to be implemented in
22  * res/ari/resource_channels.c
23  *
24  * Channel resources
25  *
26  * \author David M. Lee, II <dlee@digium.com>
27  */
28
29 /*
30  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
31  * !!!!!                               DO NOT EDIT                        !!!!!
32  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
33  * This file is generated by a mustache template. Please see the original
34  * template in rest-api-templates/ari_resource.h.mustache
35  */
36
37 #ifndef _ASTERISK_RESOURCE_CHANNELS_H
38 #define _ASTERISK_RESOURCE_CHANNELS_H
39
40 #include "asterisk/ari.h"
41
42 /*! \brief Argument struct for ast_ari_channels_list() */
43 struct ast_ari_channels_list_args {
44 };
45 /*!
46  * \brief List all active channels in Asterisk.
47  *
48  * \param headers HTTP headers
49  * \param args Swagger parameters
50  * \param[out] response HTTP response
51  */
52 void ast_ari_channels_list(struct ast_variable *headers, struct ast_ari_channels_list_args *args, struct ast_ari_response *response);
53 /*! \brief Argument struct for ast_ari_channels_originate() */
54 struct ast_ari_channels_originate_args {
55         /*! \brief Endpoint to call. */
56         const char *endpoint;
57         /*! \brief The extension to dial after the endpoint answers */
58         const char *extension;
59         /*! \brief The context to dial after the endpoint answers. If omitted, uses 'default' */
60         const char *context;
61         /*! \brief The priority to dial after the endpoint answers. If omitted, uses 1 */
62         long priority;
63         /*! \brief The application that is subscribed to the originated channel, and passed to the Stasis application. */
64         const char *app;
65         /*! \brief The application arguments to pass to the Stasis application. */
66         const char *app_args;
67         /*! \brief CallerID to use when dialing the endpoint or extension. */
68         const char *caller_id;
69         /*! \brief Timeout (in seconds) before giving up dialing, or -1 for no timeout. */
70         int timeout;
71         /*! \brief The 'variables' key in the body object holds variable key/value pairs to set on the channel on creation. Other keys in the body object are interpreted as query parameters. Ex. { 'endpoint': 'SIP/Alice', 'variables': { 'CALLERID(name)': 'Alice' } } */
72         struct ast_json *variables;
73         /*! \brief The unique id to assign the channel on creation. */
74         const char *channel_id;
75         /*! \brief The unique id to assign the second channel when using local channels. */
76         const char *other_channel_id;
77 };
78 /*!
79  * \brief Body parsing function for /channels.
80  * \param body The JSON body from which to parse parameters.
81  * \param[out] args The args structure to parse into.
82  * \retval zero on success
83  * \retval non-zero on failure
84  */
85 int ast_ari_channels_originate_parse_body(
86         struct ast_json *body,
87         struct ast_ari_channels_originate_args *args);
88
89 /*!
90  * \brief Create a new channel (originate).
91  *
92  * The new channel is created immediately and a snapshot of it returned. If a Stasis application is provided it will be automatically subscribed to the originated channel for further events and updates.
93  *
94  * \param headers HTTP headers
95  * \param args Swagger parameters
96  * \param[out] response HTTP response
97  */
98 void ast_ari_channels_originate(struct ast_variable *headers, struct ast_ari_channels_originate_args *args, struct ast_ari_response *response);
99 /*! \brief Argument struct for ast_ari_channels_get() */
100 struct ast_ari_channels_get_args {
101         /*! \brief Channel's id */
102         const char *channel_id;
103 };
104 /*!
105  * \brief Channel details.
106  *
107  * \param headers HTTP headers
108  * \param args Swagger parameters
109  * \param[out] response HTTP response
110  */
111 void ast_ari_channels_get(struct ast_variable *headers, struct ast_ari_channels_get_args *args, struct ast_ari_response *response);
112 /*! \brief Argument struct for ast_ari_channels_originate_with_id() */
113 struct ast_ari_channels_originate_with_id_args {
114         /*! \brief The unique id to assign the channel on creation. */
115         const char *channel_id;
116         /*! \brief Endpoint to call. */
117         const char *endpoint;
118         /*! \brief The extension to dial after the endpoint answers */
119         const char *extension;
120         /*! \brief The context to dial after the endpoint answers. If omitted, uses 'default' */
121         const char *context;
122         /*! \brief The priority to dial after the endpoint answers. If omitted, uses 1 */
123         long priority;
124         /*! \brief The application that is subscribed to the originated channel, and passed to the Stasis application. */
125         const char *app;
126         /*! \brief The application arguments to pass to the Stasis application. */
127         const char *app_args;
128         /*! \brief CallerID to use when dialing the endpoint or extension. */
129         const char *caller_id;
130         /*! \brief Timeout (in seconds) before giving up dialing, or -1 for no timeout. */
131         int timeout;
132         /*! \brief The 'variables' key in the body object holds variable key/value pairs to set on the channel on creation. Other keys in the body object are interpreted as query parameters. Ex. { 'endpoint': 'SIP/Alice', 'variables': { 'CALLERID(name)': 'Alice' } } */
133         struct ast_json *variables;
134         /*! \brief The unique id to assign the second channel when using local channels. */
135         const char *other_channel_id;
136 };
137 /*!
138  * \brief Body parsing function for /channels/{channelId}.
139  * \param body The JSON body from which to parse parameters.
140  * \param[out] args The args structure to parse into.
141  * \retval zero on success
142  * \retval non-zero on failure
143  */
144 int ast_ari_channels_originate_with_id_parse_body(
145         struct ast_json *body,
146         struct ast_ari_channels_originate_with_id_args *args);
147
148 /*!
149  * \brief Create a new channel (originate with id).
150  *
151  * The new channel is created immediately and a snapshot of it returned. If a Stasis application is provided it will be automatically subscribed to the originated channel for further events and updates.
152  *
153  * \param headers HTTP headers
154  * \param args Swagger parameters
155  * \param[out] response HTTP response
156  */
157 void ast_ari_channels_originate_with_id(struct ast_variable *headers, struct ast_ari_channels_originate_with_id_args *args, struct ast_ari_response *response);
158 /*! \brief Argument struct for ast_ari_channels_hangup() */
159 struct ast_ari_channels_hangup_args {
160         /*! \brief Channel's id */
161         const char *channel_id;
162         /*! \brief Reason for hanging up the channel */
163         const char *reason;
164 };
165 /*!
166  * \brief Body parsing function for /channels/{channelId}.
167  * \param body The JSON body from which to parse parameters.
168  * \param[out] args The args structure to parse into.
169  * \retval zero on success
170  * \retval non-zero on failure
171  */
172 int ast_ari_channels_hangup_parse_body(
173         struct ast_json *body,
174         struct ast_ari_channels_hangup_args *args);
175
176 /*!
177  * \brief Delete (i.e. hangup) a channel.
178  *
179  * \param headers HTTP headers
180  * \param args Swagger parameters
181  * \param[out] response HTTP response
182  */
183 void ast_ari_channels_hangup(struct ast_variable *headers, struct ast_ari_channels_hangup_args *args, struct ast_ari_response *response);
184 /*! \brief Argument struct for ast_ari_channels_continue_in_dialplan() */
185 struct ast_ari_channels_continue_in_dialplan_args {
186         /*! \brief Channel's id */
187         const char *channel_id;
188         /*! \brief The context to continue to. */
189         const char *context;
190         /*! \brief The extension to continue to. */
191         const char *extension;
192         /*! \brief The priority to continue to. */
193         int priority;
194 };
195 /*!
196  * \brief Body parsing function for /channels/{channelId}/continue.
197  * \param body The JSON body from which to parse parameters.
198  * \param[out] args The args structure to parse into.
199  * \retval zero on success
200  * \retval non-zero on failure
201  */
202 int ast_ari_channels_continue_in_dialplan_parse_body(
203         struct ast_json *body,
204         struct ast_ari_channels_continue_in_dialplan_args *args);
205
206 /*!
207  * \brief Exit application; continue execution in the dialplan.
208  *
209  * \param headers HTTP headers
210  * \param args Swagger parameters
211  * \param[out] response HTTP response
212  */
213 void ast_ari_channels_continue_in_dialplan(struct ast_variable *headers, struct ast_ari_channels_continue_in_dialplan_args *args, struct ast_ari_response *response);
214 /*! \brief Argument struct for ast_ari_channels_answer() */
215 struct ast_ari_channels_answer_args {
216         /*! \brief Channel's id */
217         const char *channel_id;
218 };
219 /*!
220  * \brief Answer a channel.
221  *
222  * \param headers HTTP headers
223  * \param args Swagger parameters
224  * \param[out] response HTTP response
225  */
226 void ast_ari_channels_answer(struct ast_variable *headers, struct ast_ari_channels_answer_args *args, struct ast_ari_response *response);
227 /*! \brief Argument struct for ast_ari_channels_ring() */
228 struct ast_ari_channels_ring_args {
229         /*! \brief Channel's id */
230         const char *channel_id;
231 };
232 /*!
233  * \brief Indicate ringing to a channel.
234  *
235  * \param headers HTTP headers
236  * \param args Swagger parameters
237  * \param[out] response HTTP response
238  */
239 void ast_ari_channels_ring(struct ast_variable *headers, struct ast_ari_channels_ring_args *args, struct ast_ari_response *response);
240 /*! \brief Argument struct for ast_ari_channels_ring_stop() */
241 struct ast_ari_channels_ring_stop_args {
242         /*! \brief Channel's id */
243         const char *channel_id;
244 };
245 /*!
246  * \brief Stop ringing indication on a channel if locally generated.
247  *
248  * \param headers HTTP headers
249  * \param args Swagger parameters
250  * \param[out] response HTTP response
251  */
252 void ast_ari_channels_ring_stop(struct ast_variable *headers, struct ast_ari_channels_ring_stop_args *args, struct ast_ari_response *response);
253 /*! \brief Argument struct for ast_ari_channels_send_dtmf() */
254 struct ast_ari_channels_send_dtmf_args {
255         /*! \brief Channel's id */
256         const char *channel_id;
257         /*! \brief DTMF To send. */
258         const char *dtmf;
259         /*! \brief Amount of time to wait before DTMF digits (specified in milliseconds) start. */
260         int before;
261         /*! \brief Amount of time in between DTMF digits (specified in milliseconds). */
262         int between;
263         /*! \brief Length of each DTMF digit (specified in milliseconds). */
264         int duration;
265         /*! \brief Amount of time to wait after DTMF digits (specified in milliseconds) end. */
266         int after;
267 };
268 /*!
269  * \brief Body parsing function for /channels/{channelId}/dtmf.
270  * \param body The JSON body from which to parse parameters.
271  * \param[out] args The args structure to parse into.
272  * \retval zero on success
273  * \retval non-zero on failure
274  */
275 int ast_ari_channels_send_dtmf_parse_body(
276         struct ast_json *body,
277         struct ast_ari_channels_send_dtmf_args *args);
278
279 /*!
280  * \brief Send provided DTMF to a given channel.
281  *
282  * \param headers HTTP headers
283  * \param args Swagger parameters
284  * \param[out] response HTTP response
285  */
286 void ast_ari_channels_send_dtmf(struct ast_variable *headers, struct ast_ari_channels_send_dtmf_args *args, struct ast_ari_response *response);
287 /*! \brief Argument struct for ast_ari_channels_mute() */
288 struct ast_ari_channels_mute_args {
289         /*! \brief Channel's id */
290         const char *channel_id;
291         /*! \brief Direction in which to mute audio */
292         const char *direction;
293 };
294 /*!
295  * \brief Body parsing function for /channels/{channelId}/mute.
296  * \param body The JSON body from which to parse parameters.
297  * \param[out] args The args structure to parse into.
298  * \retval zero on success
299  * \retval non-zero on failure
300  */
301 int ast_ari_channels_mute_parse_body(
302         struct ast_json *body,
303         struct ast_ari_channels_mute_args *args);
304
305 /*!
306  * \brief Mute a channel.
307  *
308  * \param headers HTTP headers
309  * \param args Swagger parameters
310  * \param[out] response HTTP response
311  */
312 void ast_ari_channels_mute(struct ast_variable *headers, struct ast_ari_channels_mute_args *args, struct ast_ari_response *response);
313 /*! \brief Argument struct for ast_ari_channels_unmute() */
314 struct ast_ari_channels_unmute_args {
315         /*! \brief Channel's id */
316         const char *channel_id;
317         /*! \brief Direction in which to unmute audio */
318         const char *direction;
319 };
320 /*!
321  * \brief Body parsing function for /channels/{channelId}/mute.
322  * \param body The JSON body from which to parse parameters.
323  * \param[out] args The args structure to parse into.
324  * \retval zero on success
325  * \retval non-zero on failure
326  */
327 int ast_ari_channels_unmute_parse_body(
328         struct ast_json *body,
329         struct ast_ari_channels_unmute_args *args);
330
331 /*!
332  * \brief Unmute a channel.
333  *
334  * \param headers HTTP headers
335  * \param args Swagger parameters
336  * \param[out] response HTTP response
337  */
338 void ast_ari_channels_unmute(struct ast_variable *headers, struct ast_ari_channels_unmute_args *args, struct ast_ari_response *response);
339 /*! \brief Argument struct for ast_ari_channels_hold() */
340 struct ast_ari_channels_hold_args {
341         /*! \brief Channel's id */
342         const char *channel_id;
343 };
344 /*!
345  * \brief Hold a channel.
346  *
347  * \param headers HTTP headers
348  * \param args Swagger parameters
349  * \param[out] response HTTP response
350  */
351 void ast_ari_channels_hold(struct ast_variable *headers, struct ast_ari_channels_hold_args *args, struct ast_ari_response *response);
352 /*! \brief Argument struct for ast_ari_channels_unhold() */
353 struct ast_ari_channels_unhold_args {
354         /*! \brief Channel's id */
355         const char *channel_id;
356 };
357 /*!
358  * \brief Remove a channel from hold.
359  *
360  * \param headers HTTP headers
361  * \param args Swagger parameters
362  * \param[out] response HTTP response
363  */
364 void ast_ari_channels_unhold(struct ast_variable *headers, struct ast_ari_channels_unhold_args *args, struct ast_ari_response *response);
365 /*! \brief Argument struct for ast_ari_channels_start_moh() */
366 struct ast_ari_channels_start_moh_args {
367         /*! \brief Channel's id */
368         const char *channel_id;
369         /*! \brief Music on hold class to use */
370         const char *moh_class;
371 };
372 /*!
373  * \brief Body parsing function for /channels/{channelId}/moh.
374  * \param body The JSON body from which to parse parameters.
375  * \param[out] args The args structure to parse into.
376  * \retval zero on success
377  * \retval non-zero on failure
378  */
379 int ast_ari_channels_start_moh_parse_body(
380         struct ast_json *body,
381         struct ast_ari_channels_start_moh_args *args);
382
383 /*!
384  * \brief Play music on hold to a channel.
385  *
386  * Using media operations such as /play on a channel playing MOH in this manner will suspend MOH without resuming automatically. If continuing music on hold is desired, the stasis application must reinitiate music on hold.
387  *
388  * \param headers HTTP headers
389  * \param args Swagger parameters
390  * \param[out] response HTTP response
391  */
392 void ast_ari_channels_start_moh(struct ast_variable *headers, struct ast_ari_channels_start_moh_args *args, struct ast_ari_response *response);
393 /*! \brief Argument struct for ast_ari_channels_stop_moh() */
394 struct ast_ari_channels_stop_moh_args {
395         /*! \brief Channel's id */
396         const char *channel_id;
397 };
398 /*!
399  * \brief Stop playing music on hold to a channel.
400  *
401  * \param headers HTTP headers
402  * \param args Swagger parameters
403  * \param[out] response HTTP response
404  */
405 void ast_ari_channels_stop_moh(struct ast_variable *headers, struct ast_ari_channels_stop_moh_args *args, struct ast_ari_response *response);
406 /*! \brief Argument struct for ast_ari_channels_start_silence() */
407 struct ast_ari_channels_start_silence_args {
408         /*! \brief Channel's id */
409         const char *channel_id;
410 };
411 /*!
412  * \brief Play silence to a channel.
413  *
414  * Using media operations such as /play on a channel playing silence in this manner will suspend silence without resuming automatically.
415  *
416  * \param headers HTTP headers
417  * \param args Swagger parameters
418  * \param[out] response HTTP response
419  */
420 void ast_ari_channels_start_silence(struct ast_variable *headers, struct ast_ari_channels_start_silence_args *args, struct ast_ari_response *response);
421 /*! \brief Argument struct for ast_ari_channels_stop_silence() */
422 struct ast_ari_channels_stop_silence_args {
423         /*! \brief Channel's id */
424         const char *channel_id;
425 };
426 /*!
427  * \brief Stop playing silence to a channel.
428  *
429  * \param headers HTTP headers
430  * \param args Swagger parameters
431  * \param[out] response HTTP response
432  */
433 void ast_ari_channels_stop_silence(struct ast_variable *headers, struct ast_ari_channels_stop_silence_args *args, struct ast_ari_response *response);
434 /*! \brief Argument struct for ast_ari_channels_play() */
435 struct ast_ari_channels_play_args {
436         /*! \brief Channel's id */
437         const char *channel_id;
438         /*! \brief Media's URI to play. */
439         const char *media;
440         /*! \brief For sounds, selects language for sound. */
441         const char *lang;
442         /*! \brief Number of media to skip before playing. */
443         int offsetms;
444         /*! \brief Number of milliseconds to skip for forward/reverse operations. */
445         int skipms;
446         /*! \brief Playback ID. */
447         const char *playback_id;
448 };
449 /*!
450  * \brief Body parsing function for /channels/{channelId}/play.
451  * \param body The JSON body from which to parse parameters.
452  * \param[out] args The args structure to parse into.
453  * \retval zero on success
454  * \retval non-zero on failure
455  */
456 int ast_ari_channels_play_parse_body(
457         struct ast_json *body,
458         struct ast_ari_channels_play_args *args);
459
460 /*!
461  * \brief Start playback of media.
462  *
463  * The media URI may be any of a number of URI's. Currently sound:, recording:, number:, digits:, characters:, and tone: URI's are supported. This operation creates a playback resource that can be used to control the playback of media (pause, rewind, fast forward, etc.)
464  *
465  * \param headers HTTP headers
466  * \param args Swagger parameters
467  * \param[out] response HTTP response
468  */
469 void ast_ari_channels_play(struct ast_variable *headers, struct ast_ari_channels_play_args *args, struct ast_ari_response *response);
470 /*! \brief Argument struct for ast_ari_channels_play_with_id() */
471 struct ast_ari_channels_play_with_id_args {
472         /*! \brief Channel's id */
473         const char *channel_id;
474         /*! \brief Playback ID. */
475         const char *playback_id;
476         /*! \brief Media's URI to play. */
477         const char *media;
478         /*! \brief For sounds, selects language for sound. */
479         const char *lang;
480         /*! \brief Number of media to skip before playing. */
481         int offsetms;
482         /*! \brief Number of milliseconds to skip for forward/reverse operations. */
483         int skipms;
484 };
485 /*!
486  * \brief Body parsing function for /channels/{channelId}/play/{playbackId}.
487  * \param body The JSON body from which to parse parameters.
488  * \param[out] args The args structure to parse into.
489  * \retval zero on success
490  * \retval non-zero on failure
491  */
492 int ast_ari_channels_play_with_id_parse_body(
493         struct ast_json *body,
494         struct ast_ari_channels_play_with_id_args *args);
495
496 /*!
497  * \brief Start playback of media and specify the playbackId.
498  *
499  * The media URI may be any of a number of URI's. Currently sound: and recording: URI's are supported. This operation creates a playback resource that can be used to control the playback of media (pause, rewind, fast forward, etc.)
500  *
501  * \param headers HTTP headers
502  * \param args Swagger parameters
503  * \param[out] response HTTP response
504  */
505 void ast_ari_channels_play_with_id(struct ast_variable *headers, struct ast_ari_channels_play_with_id_args *args, struct ast_ari_response *response);
506 /*! \brief Argument struct for ast_ari_channels_record() */
507 struct ast_ari_channels_record_args {
508         /*! \brief Channel's id */
509         const char *channel_id;
510         /*! \brief Recording's filename */
511         const char *name;
512         /*! \brief Format to encode audio in */
513         const char *format;
514         /*! \brief Maximum duration of the recording, in seconds. 0 for no limit */
515         int max_duration_seconds;
516         /*! \brief Maximum duration of silence, in seconds. 0 for no limit */
517         int max_silence_seconds;
518         /*! \brief Action to take if a recording with the same name already exists. */
519         const char *if_exists;
520         /*! \brief Play beep when recording begins */
521         int beep;
522         /*! \brief DTMF input to terminate recording */
523         const char *terminate_on;
524 };
525 /*!
526  * \brief Body parsing function for /channels/{channelId}/record.
527  * \param body The JSON body from which to parse parameters.
528  * \param[out] args The args structure to parse into.
529  * \retval zero on success
530  * \retval non-zero on failure
531  */
532 int ast_ari_channels_record_parse_body(
533         struct ast_json *body,
534         struct ast_ari_channels_record_args *args);
535
536 /*!
537  * \brief Start a recording.
538  *
539  * Record audio from a channel. Note that this will not capture audio sent to the channel. The bridge itself has a record feature if that's what you want.
540  *
541  * \param headers HTTP headers
542  * \param args Swagger parameters
543  * \param[out] response HTTP response
544  */
545 void ast_ari_channels_record(struct ast_variable *headers, struct ast_ari_channels_record_args *args, struct ast_ari_response *response);
546 /*! \brief Argument struct for ast_ari_channels_get_channel_var() */
547 struct ast_ari_channels_get_channel_var_args {
548         /*! \brief Channel's id */
549         const char *channel_id;
550         /*! \brief The channel variable or function to get */
551         const char *variable;
552 };
553 /*!
554  * \brief Body parsing function for /channels/{channelId}/variable.
555  * \param body The JSON body from which to parse parameters.
556  * \param[out] args The args structure to parse into.
557  * \retval zero on success
558  * \retval non-zero on failure
559  */
560 int ast_ari_channels_get_channel_var_parse_body(
561         struct ast_json *body,
562         struct ast_ari_channels_get_channel_var_args *args);
563
564 /*!
565  * \brief Get the value of a channel variable or function.
566  *
567  * \param headers HTTP headers
568  * \param args Swagger parameters
569  * \param[out] response HTTP response
570  */
571 void ast_ari_channels_get_channel_var(struct ast_variable *headers, struct ast_ari_channels_get_channel_var_args *args, struct ast_ari_response *response);
572 /*! \brief Argument struct for ast_ari_channels_set_channel_var() */
573 struct ast_ari_channels_set_channel_var_args {
574         /*! \brief Channel's id */
575         const char *channel_id;
576         /*! \brief The channel variable or function to set */
577         const char *variable;
578         /*! \brief The value to set the variable to */
579         const char *value;
580 };
581 /*!
582  * \brief Body parsing function for /channels/{channelId}/variable.
583  * \param body The JSON body from which to parse parameters.
584  * \param[out] args The args structure to parse into.
585  * \retval zero on success
586  * \retval non-zero on failure
587  */
588 int ast_ari_channels_set_channel_var_parse_body(
589         struct ast_json *body,
590         struct ast_ari_channels_set_channel_var_args *args);
591
592 /*!
593  * \brief Set the value of a channel variable or function.
594  *
595  * \param headers HTTP headers
596  * \param args Swagger parameters
597  * \param[out] response HTTP response
598  */
599 void ast_ari_channels_set_channel_var(struct ast_variable *headers, struct ast_ari_channels_set_channel_var_args *args, struct ast_ari_response *response);
600 /*! \brief Argument struct for ast_ari_channels_snoop_channel() */
601 struct ast_ari_channels_snoop_channel_args {
602         /*! \brief Channel's id */
603         const char *channel_id;
604         /*! \brief Direction of audio to spy on */
605         const char *spy;
606         /*! \brief Direction of audio to whisper into */
607         const char *whisper;
608         /*! \brief Application the snooping channel is placed into */
609         const char *app;
610         /*! \brief The application arguments to pass to the Stasis application */
611         const char *app_args;
612         /*! \brief Unique ID to assign to snooping channel */
613         const char *snoop_id;
614 };
615 /*!
616  * \brief Body parsing function for /channels/{channelId}/snoop.
617  * \param body The JSON body from which to parse parameters.
618  * \param[out] args The args structure to parse into.
619  * \retval zero on success
620  * \retval non-zero on failure
621  */
622 int ast_ari_channels_snoop_channel_parse_body(
623         struct ast_json *body,
624         struct ast_ari_channels_snoop_channel_args *args);
625
626 /*!
627  * \brief Start snooping.
628  *
629  * Snoop (spy/whisper) on a specific channel.
630  *
631  * \param headers HTTP headers
632  * \param args Swagger parameters
633  * \param[out] response HTTP response
634  */
635 void ast_ari_channels_snoop_channel(struct ast_variable *headers, struct ast_ari_channels_snoop_channel_args *args, struct ast_ari_response *response);
636 /*! \brief Argument struct for ast_ari_channels_snoop_channel_with_id() */
637 struct ast_ari_channels_snoop_channel_with_id_args {
638         /*! \brief Channel's id */
639         const char *channel_id;
640         /*! \brief Unique ID to assign to snooping channel */
641         const char *snoop_id;
642         /*! \brief Direction of audio to spy on */
643         const char *spy;
644         /*! \brief Direction of audio to whisper into */
645         const char *whisper;
646         /*! \brief Application the snooping channel is placed into */
647         const char *app;
648         /*! \brief The application arguments to pass to the Stasis application */
649         const char *app_args;
650 };
651 /*!
652  * \brief Body parsing function for /channels/{channelId}/snoop/{snoopId}.
653  * \param body The JSON body from which to parse parameters.
654  * \param[out] args The args structure to parse into.
655  * \retval zero on success
656  * \retval non-zero on failure
657  */
658 int ast_ari_channels_snoop_channel_with_id_parse_body(
659         struct ast_json *body,
660         struct ast_ari_channels_snoop_channel_with_id_args *args);
661
662 /*!
663  * \brief Start snooping.
664  *
665  * Snoop (spy/whisper) on a specific channel.
666  *
667  * \param headers HTTP headers
668  * \param args Swagger parameters
669  * \param[out] response HTTP response
670  */
671 void ast_ari_channels_snoop_channel_with_id(struct ast_variable *headers, struct ast_ari_channels_snoop_channel_with_id_args *args, struct ast_ari_response *response);
672
673 #endif /* _ASTERISK_RESOURCE_CHANNELS_H */