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