Merge "func_jitterbuffer: Add audio/video sync support."
[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. Mutually exclusive with 'app'. */
58         const char *extension;
59         /*! The context to dial after the endpoint answers. If omitted, uses 'default'. Mutually exclusive with 'app'. */
60         const char *context;
61         /*! The priority to dial after the endpoint answers. If omitted, uses 1. Mutually exclusive with 'app'. */
62         long priority;
63         /*! The label to dial after the endpoint answers. Will supersede 'priority' if provided. Mutually exclusive with 'app'. */
64         const char *label;
65         /*! The application that is subscribed to the originated channel. When the channel is answered, it will be passed to this Stasis application. Mutually exclusive with 'context', 'extension', 'priority', and 'label'. */
66         const char *app;
67         /*! The application arguments to pass to the Stasis application provided by 'app'. Mutually exclusive with 'context', 'extension', 'priority', and 'label'. */
68         const char *app_args;
69         /*! CallerID to use when dialing the endpoint or extension. */
70         const char *caller_id;
71         /*! Timeout (in seconds) before giving up dialing, or -1 for no timeout. */
72         int timeout;
73         /*! 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" } } */
74         struct ast_json *variables;
75         /*! The unique id to assign the channel on creation. */
76         const char *channel_id;
77         /*! The unique id to assign the second channel when using local channels. */
78         const char *other_channel_id;
79         /*! The unique id of the channel which is originating this one. */
80         const char *originator;
81         /*! The format name capability list to use if originator is not specified. Ex. "ulaw,slin16".  Format names can be found with "core show codecs". */
82         const char *formats;
83 };
84 /*!
85  * \brief Body parsing function for /channels.
86  * \param body The JSON body from which to parse parameters.
87  * \param[out] args The args structure to parse into.
88  * \retval zero on success
89  * \retval non-zero on failure
90  */
91 int ast_ari_channels_originate_parse_body(
92         struct ast_json *body,
93         struct ast_ari_channels_originate_args *args);
94
95 /*!
96  * \brief Create a new channel (originate).
97  *
98  * 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.
99  *
100  * \param headers HTTP headers
101  * \param args Swagger parameters
102  * \param[out] response HTTP response
103  */
104 void ast_ari_channels_originate(struct ast_variable *headers, struct ast_ari_channels_originate_args *args, struct ast_ari_response *response);
105 /*! Argument struct for ast_ari_channels_create() */
106 struct ast_ari_channels_create_args {
107         /*! Endpoint for channel communication */
108         const char *endpoint;
109         /*! Stasis Application to place channel into */
110         const char *app;
111         /*! The application arguments to pass to the Stasis application provided by 'app'. Mutually exclusive with 'context', 'extension', 'priority', and 'label'. */
112         const char *app_args;
113         /*! The unique id to assign the channel on creation. */
114         const char *channel_id;
115         /*! The unique id to assign the second channel when using local channels. */
116         const char *other_channel_id;
117         /*! Unique ID of the calling channel */
118         const char *originator;
119         /*! The format name capability list to use if originator is not specified. Ex. "ulaw,slin16".  Format names can be found with "core show codecs". */
120         const char *formats;
121 };
122 /*!
123  * \brief Body parsing function for /channels/create.
124  * \param body The JSON body from which to parse parameters.
125  * \param[out] args The args structure to parse into.
126  * \retval zero on success
127  * \retval non-zero on failure
128  */
129 int ast_ari_channels_create_parse_body(
130         struct ast_json *body,
131         struct ast_ari_channels_create_args *args);
132
133 /*!
134  * \brief Create channel.
135  *
136  * \param headers HTTP headers
137  * \param args Swagger parameters
138  * \param[out] response HTTP response
139  */
140 void ast_ari_channels_create(struct ast_variable *headers, struct ast_ari_channels_create_args *args, struct ast_ari_response *response);
141 /*! Argument struct for ast_ari_channels_get() */
142 struct ast_ari_channels_get_args {
143         /*! Channel's id */
144         const char *channel_id;
145 };
146 /*!
147  * \brief Channel details.
148  *
149  * \param headers HTTP headers
150  * \param args Swagger parameters
151  * \param[out] response HTTP response
152  */
153 void ast_ari_channels_get(struct ast_variable *headers, struct ast_ari_channels_get_args *args, struct ast_ari_response *response);
154 /*! Argument struct for ast_ari_channels_originate_with_id() */
155 struct ast_ari_channels_originate_with_id_args {
156         /*! The unique id to assign the channel on creation. */
157         const char *channel_id;
158         /*! Endpoint to call. */
159         const char *endpoint;
160         /*! The extension to dial after the endpoint answers. Mutually exclusive with 'app'. */
161         const char *extension;
162         /*! The context to dial after the endpoint answers. If omitted, uses 'default'. Mutually exclusive with 'app'. */
163         const char *context;
164         /*! The priority to dial after the endpoint answers. If omitted, uses 1. Mutually exclusive with 'app'. */
165         long priority;
166         /*! The label to dial after the endpoint answers. Will supersede 'priority' if provided. Mutually exclusive with 'app'. */
167         const char *label;
168         /*! The application that is subscribed to the originated channel. When the channel is answered, it will be passed to this Stasis application. Mutually exclusive with 'context', 'extension', 'priority', and 'label'. */
169         const char *app;
170         /*! The application arguments to pass to the Stasis application provided by 'app'. Mutually exclusive with 'context', 'extension', 'priority', and 'label'. */
171         const char *app_args;
172         /*! CallerID to use when dialing the endpoint or extension. */
173         const char *caller_id;
174         /*! Timeout (in seconds) before giving up dialing, or -1 for no timeout. */
175         int timeout;
176         /*! 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" } } */
177         struct ast_json *variables;
178         /*! The unique id to assign the second channel when using local channels. */
179         const char *other_channel_id;
180         /*! The unique id of the channel which is originating this one. */
181         const char *originator;
182         /*! The format name capability list to use if originator is not specified. Ex. "ulaw,slin16".  Format names can be found with "core show codecs". */
183         const char *formats;
184 };
185 /*!
186  * \brief Body parsing function for /channels/{channelId}.
187  * \param body The JSON body from which to parse parameters.
188  * \param[out] args The args structure to parse into.
189  * \retval zero on success
190  * \retval non-zero on failure
191  */
192 int ast_ari_channels_originate_with_id_parse_body(
193         struct ast_json *body,
194         struct ast_ari_channels_originate_with_id_args *args);
195
196 /*!
197  * \brief Create a new channel (originate with id).
198  *
199  * 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.
200  *
201  * \param headers HTTP headers
202  * \param args Swagger parameters
203  * \param[out] response HTTP response
204  */
205 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);
206 /*! Argument struct for ast_ari_channels_hangup() */
207 struct ast_ari_channels_hangup_args {
208         /*! Channel's id */
209         const char *channel_id;
210         /*! The reason code for hanging up the channel for detail use. Mutually exclusive with 'reason'. See detail hangup codes at here. https://wiki.asterisk.org/wiki/display/AST/Hangup+Cause+Mappings */
211         const char *reason_code;
212         /*! Reason for hanging up the channel for simple use. Mutually exclusive with 'reason_code'. */
213         const char *reason;
214 };
215 /*!
216  * \brief Body parsing function for /channels/{channelId}.
217  * \param body The JSON body from which to parse parameters.
218  * \param[out] args The args structure to parse into.
219  * \retval zero on success
220  * \retval non-zero on failure
221  */
222 int ast_ari_channels_hangup_parse_body(
223         struct ast_json *body,
224         struct ast_ari_channels_hangup_args *args);
225
226 /*!
227  * \brief Delete (i.e. hangup) a channel.
228  *
229  * \param headers HTTP headers
230  * \param args Swagger parameters
231  * \param[out] response HTTP response
232  */
233 void ast_ari_channels_hangup(struct ast_variable *headers, struct ast_ari_channels_hangup_args *args, struct ast_ari_response *response);
234 /*! Argument struct for ast_ari_channels_continue_in_dialplan() */
235 struct ast_ari_channels_continue_in_dialplan_args {
236         /*! Channel's id */
237         const char *channel_id;
238         /*! The context to continue to. */
239         const char *context;
240         /*! The extension to continue to. */
241         const char *extension;
242         /*! The priority to continue to. */
243         int priority;
244         /*! The label to continue to - will supersede 'priority' if both are provided. */
245         const char *label;
246 };
247 /*!
248  * \brief Body parsing function for /channels/{channelId}/continue.
249  * \param body The JSON body from which to parse parameters.
250  * \param[out] args The args structure to parse into.
251  * \retval zero on success
252  * \retval non-zero on failure
253  */
254 int ast_ari_channels_continue_in_dialplan_parse_body(
255         struct ast_json *body,
256         struct ast_ari_channels_continue_in_dialplan_args *args);
257
258 /*!
259  * \brief Exit application; continue execution in the dialplan.
260  *
261  * \param headers HTTP headers
262  * \param args Swagger parameters
263  * \param[out] response HTTP response
264  */
265 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);
266 /*! Argument struct for ast_ari_channels_move() */
267 struct ast_ari_channels_move_args {
268         /*! Channel's id */
269         const char *channel_id;
270         /*! The channel will be passed to this Stasis application. */
271         const char *app;
272         /*! The application arguments to pass to the Stasis application provided by 'app'. */
273         const char *app_args;
274 };
275 /*!
276  * \brief Body parsing function for /channels/{channelId}/move.
277  * \param body The JSON body from which to parse parameters.
278  * \param[out] args The args structure to parse into.
279  * \retval zero on success
280  * \retval non-zero on failure
281  */
282 int ast_ari_channels_move_parse_body(
283         struct ast_json *body,
284         struct ast_ari_channels_move_args *args);
285
286 /*!
287  * \brief Move the channel from one Stasis application to another.
288  *
289  * \param headers HTTP headers
290  * \param args Swagger parameters
291  * \param[out] response HTTP response
292  */
293 void ast_ari_channels_move(struct ast_variable *headers, struct ast_ari_channels_move_args *args, struct ast_ari_response *response);
294 /*! Argument struct for ast_ari_channels_redirect() */
295 struct ast_ari_channels_redirect_args {
296         /*! Channel's id */
297         const char *channel_id;
298         /*! The endpoint to redirect the channel to */
299         const char *endpoint;
300 };
301 /*!
302  * \brief Body parsing function for /channels/{channelId}/redirect.
303  * \param body The JSON body from which to parse parameters.
304  * \param[out] args The args structure to parse into.
305  * \retval zero on success
306  * \retval non-zero on failure
307  */
308 int ast_ari_channels_redirect_parse_body(
309         struct ast_json *body,
310         struct ast_ari_channels_redirect_args *args);
311
312 /*!
313  * \brief Redirect the channel to a different location.
314  *
315  * \param headers HTTP headers
316  * \param args Swagger parameters
317  * \param[out] response HTTP response
318  */
319 void ast_ari_channels_redirect(struct ast_variable *headers, struct ast_ari_channels_redirect_args *args, struct ast_ari_response *response);
320 /*! Argument struct for ast_ari_channels_answer() */
321 struct ast_ari_channels_answer_args {
322         /*! Channel's id */
323         const char *channel_id;
324 };
325 /*!
326  * \brief Answer a channel.
327  *
328  * \param headers HTTP headers
329  * \param args Swagger parameters
330  * \param[out] response HTTP response
331  */
332 void ast_ari_channels_answer(struct ast_variable *headers, struct ast_ari_channels_answer_args *args, struct ast_ari_response *response);
333 /*! Argument struct for ast_ari_channels_ring() */
334 struct ast_ari_channels_ring_args {
335         /*! Channel's id */
336         const char *channel_id;
337 };
338 /*!
339  * \brief Indicate ringing to a channel.
340  *
341  * \param headers HTTP headers
342  * \param args Swagger parameters
343  * \param[out] response HTTP response
344  */
345 void ast_ari_channels_ring(struct ast_variable *headers, struct ast_ari_channels_ring_args *args, struct ast_ari_response *response);
346 /*! Argument struct for ast_ari_channels_ring_stop() */
347 struct ast_ari_channels_ring_stop_args {
348         /*! Channel's id */
349         const char *channel_id;
350 };
351 /*!
352  * \brief Stop ringing indication on a channel if locally generated.
353  *
354  * \param headers HTTP headers
355  * \param args Swagger parameters
356  * \param[out] response HTTP response
357  */
358 void ast_ari_channels_ring_stop(struct ast_variable *headers, struct ast_ari_channels_ring_stop_args *args, struct ast_ari_response *response);
359 /*! Argument struct for ast_ari_channels_send_dtmf() */
360 struct ast_ari_channels_send_dtmf_args {
361         /*! Channel's id */
362         const char *channel_id;
363         /*! DTMF To send. */
364         const char *dtmf;
365         /*! Amount of time to wait before DTMF digits (specified in milliseconds) start. */
366         int before;
367         /*! Amount of time in between DTMF digits (specified in milliseconds). */
368         int between;
369         /*! Length of each DTMF digit (specified in milliseconds). */
370         int duration;
371         /*! Amount of time to wait after DTMF digits (specified in milliseconds) end. */
372         int after;
373 };
374 /*!
375  * \brief Body parsing function for /channels/{channelId}/dtmf.
376  * \param body The JSON body from which to parse parameters.
377  * \param[out] args The args structure to parse into.
378  * \retval zero on success
379  * \retval non-zero on failure
380  */
381 int ast_ari_channels_send_dtmf_parse_body(
382         struct ast_json *body,
383         struct ast_ari_channels_send_dtmf_args *args);
384
385 /*!
386  * \brief Send provided DTMF to a given channel.
387  *
388  * \param headers HTTP headers
389  * \param args Swagger parameters
390  * \param[out] response HTTP response
391  */
392 void ast_ari_channels_send_dtmf(struct ast_variable *headers, struct ast_ari_channels_send_dtmf_args *args, struct ast_ari_response *response);
393 /*! Argument struct for ast_ari_channels_mute() */
394 struct ast_ari_channels_mute_args {
395         /*! Channel's id */
396         const char *channel_id;
397         /*! Direction in which to mute audio */
398         const char *direction;
399 };
400 /*!
401  * \brief Body parsing function for /channels/{channelId}/mute.
402  * \param body The JSON body from which to parse parameters.
403  * \param[out] args The args structure to parse into.
404  * \retval zero on success
405  * \retval non-zero on failure
406  */
407 int ast_ari_channels_mute_parse_body(
408         struct ast_json *body,
409         struct ast_ari_channels_mute_args *args);
410
411 /*!
412  * \brief Mute a channel.
413  *
414  * \param headers HTTP headers
415  * \param args Swagger parameters
416  * \param[out] response HTTP response
417  */
418 void ast_ari_channels_mute(struct ast_variable *headers, struct ast_ari_channels_mute_args *args, struct ast_ari_response *response);
419 /*! Argument struct for ast_ari_channels_unmute() */
420 struct ast_ari_channels_unmute_args {
421         /*! Channel's id */
422         const char *channel_id;
423         /*! Direction in which to unmute audio */
424         const char *direction;
425 };
426 /*!
427  * \brief Body parsing function for /channels/{channelId}/mute.
428  * \param body The JSON body from which to parse parameters.
429  * \param[out] args The args structure to parse into.
430  * \retval zero on success
431  * \retval non-zero on failure
432  */
433 int ast_ari_channels_unmute_parse_body(
434         struct ast_json *body,
435         struct ast_ari_channels_unmute_args *args);
436
437 /*!
438  * \brief Unmute a channel.
439  *
440  * \param headers HTTP headers
441  * \param args Swagger parameters
442  * \param[out] response HTTP response
443  */
444 void ast_ari_channels_unmute(struct ast_variable *headers, struct ast_ari_channels_unmute_args *args, struct ast_ari_response *response);
445 /*! Argument struct for ast_ari_channels_hold() */
446 struct ast_ari_channels_hold_args {
447         /*! Channel's id */
448         const char *channel_id;
449 };
450 /*!
451  * \brief Hold a channel.
452  *
453  * \param headers HTTP headers
454  * \param args Swagger parameters
455  * \param[out] response HTTP response
456  */
457 void ast_ari_channels_hold(struct ast_variable *headers, struct ast_ari_channels_hold_args *args, struct ast_ari_response *response);
458 /*! Argument struct for ast_ari_channels_unhold() */
459 struct ast_ari_channels_unhold_args {
460         /*! Channel's id */
461         const char *channel_id;
462 };
463 /*!
464  * \brief Remove a channel from hold.
465  *
466  * \param headers HTTP headers
467  * \param args Swagger parameters
468  * \param[out] response HTTP response
469  */
470 void ast_ari_channels_unhold(struct ast_variable *headers, struct ast_ari_channels_unhold_args *args, struct ast_ari_response *response);
471 /*! Argument struct for ast_ari_channels_start_moh() */
472 struct ast_ari_channels_start_moh_args {
473         /*! Channel's id */
474         const char *channel_id;
475         /*! Music on hold class to use */
476         const char *moh_class;
477 };
478 /*!
479  * \brief Body parsing function for /channels/{channelId}/moh.
480  * \param body The JSON body from which to parse parameters.
481  * \param[out] args The args structure to parse into.
482  * \retval zero on success
483  * \retval non-zero on failure
484  */
485 int ast_ari_channels_start_moh_parse_body(
486         struct ast_json *body,
487         struct ast_ari_channels_start_moh_args *args);
488
489 /*!
490  * \brief Play music on hold to a channel.
491  *
492  * 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.
493  *
494  * \param headers HTTP headers
495  * \param args Swagger parameters
496  * \param[out] response HTTP response
497  */
498 void ast_ari_channels_start_moh(struct ast_variable *headers, struct ast_ari_channels_start_moh_args *args, struct ast_ari_response *response);
499 /*! Argument struct for ast_ari_channels_stop_moh() */
500 struct ast_ari_channels_stop_moh_args {
501         /*! Channel's id */
502         const char *channel_id;
503 };
504 /*!
505  * \brief Stop playing music on hold to a channel.
506  *
507  * \param headers HTTP headers
508  * \param args Swagger parameters
509  * \param[out] response HTTP response
510  */
511 void ast_ari_channels_stop_moh(struct ast_variable *headers, struct ast_ari_channels_stop_moh_args *args, struct ast_ari_response *response);
512 /*! Argument struct for ast_ari_channels_start_silence() */
513 struct ast_ari_channels_start_silence_args {
514         /*! Channel's id */
515         const char *channel_id;
516 };
517 /*!
518  * \brief Play silence to a channel.
519  *
520  * Using media operations such as /play on a channel playing silence in this manner will suspend silence without resuming automatically.
521  *
522  * \param headers HTTP headers
523  * \param args Swagger parameters
524  * \param[out] response HTTP response
525  */
526 void ast_ari_channels_start_silence(struct ast_variable *headers, struct ast_ari_channels_start_silence_args *args, struct ast_ari_response *response);
527 /*! Argument struct for ast_ari_channels_stop_silence() */
528 struct ast_ari_channels_stop_silence_args {
529         /*! Channel's id */
530         const char *channel_id;
531 };
532 /*!
533  * \brief Stop playing silence to a channel.
534  *
535  * \param headers HTTP headers
536  * \param args Swagger parameters
537  * \param[out] response HTTP response
538  */
539 void ast_ari_channels_stop_silence(struct ast_variable *headers, struct ast_ari_channels_stop_silence_args *args, struct ast_ari_response *response);
540 /*! Argument struct for ast_ari_channels_play() */
541 struct ast_ari_channels_play_args {
542         /*! Channel's id */
543         const char *channel_id;
544         /*! Array of Media URIs to play. */
545         const char **media;
546         /*! Length of media array. */
547         size_t media_count;
548         /*! Parsing context for media. */
549         char *media_parse;
550         /*! For sounds, selects language for sound. */
551         const char *lang;
552         /*! Number of milliseconds to skip before playing. Only applies to the first URI if multiple media URIs are specified. */
553         int offsetms;
554         /*! Number of milliseconds to skip for forward/reverse operations. */
555         int skipms;
556         /*! Playback ID. */
557         const char *playback_id;
558 };
559 /*!
560  * \brief Body parsing function for /channels/{channelId}/play.
561  * \param body The JSON body from which to parse parameters.
562  * \param[out] args The args structure to parse into.
563  * \retval zero on success
564  * \retval non-zero on failure
565  */
566 int ast_ari_channels_play_parse_body(
567         struct ast_json *body,
568         struct ast_ari_channels_play_args *args);
569
570 /*!
571  * \brief Start playback of media.
572  *
573  * 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.)
574  *
575  * \param headers HTTP headers
576  * \param args Swagger parameters
577  * \param[out] response HTTP response
578  */
579 void ast_ari_channels_play(struct ast_variable *headers, struct ast_ari_channels_play_args *args, struct ast_ari_response *response);
580 /*! Argument struct for ast_ari_channels_play_with_id() */
581 struct ast_ari_channels_play_with_id_args {
582         /*! Channel's id */
583         const char *channel_id;
584         /*! Playback ID. */
585         const char *playback_id;
586         /*! Array of Media URIs to play. */
587         const char **media;
588         /*! Length of media array. */
589         size_t media_count;
590         /*! Parsing context for media. */
591         char *media_parse;
592         /*! For sounds, selects language for sound. */
593         const char *lang;
594         /*! Number of milliseconds to skip before playing. Only applies to the first URI if multiple media URIs are specified. */
595         int offsetms;
596         /*! Number of milliseconds to skip for forward/reverse operations. */
597         int skipms;
598 };
599 /*!
600  * \brief Body parsing function for /channels/{channelId}/play/{playbackId}.
601  * \param body The JSON body from which to parse parameters.
602  * \param[out] args The args structure to parse into.
603  * \retval zero on success
604  * \retval non-zero on failure
605  */
606 int ast_ari_channels_play_with_id_parse_body(
607         struct ast_json *body,
608         struct ast_ari_channels_play_with_id_args *args);
609
610 /*!
611  * \brief Start playback of media and specify the playbackId.
612  *
613  * 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.)
614  *
615  * \param headers HTTP headers
616  * \param args Swagger parameters
617  * \param[out] response HTTP response
618  */
619 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);
620 /*! Argument struct for ast_ari_channels_record() */
621 struct ast_ari_channels_record_args {
622         /*! Channel's id */
623         const char *channel_id;
624         /*! Recording's filename */
625         const char *name;
626         /*! Format to encode audio in */
627         const char *format;
628         /*! Maximum duration of the recording, in seconds. 0 for no limit */
629         int max_duration_seconds;
630         /*! Maximum duration of silence, in seconds. 0 for no limit */
631         int max_silence_seconds;
632         /*! Action to take if a recording with the same name already exists. */
633         const char *if_exists;
634         /*! Play beep when recording begins */
635         int beep;
636         /*! DTMF input to terminate recording */
637         const char *terminate_on;
638 };
639 /*!
640  * \brief Body parsing function for /channels/{channelId}/record.
641  * \param body The JSON body from which to parse parameters.
642  * \param[out] args The args structure to parse into.
643  * \retval zero on success
644  * \retval non-zero on failure
645  */
646 int ast_ari_channels_record_parse_body(
647         struct ast_json *body,
648         struct ast_ari_channels_record_args *args);
649
650 /*!
651  * \brief Start a recording.
652  *
653  * 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.
654  *
655  * \param headers HTTP headers
656  * \param args Swagger parameters
657  * \param[out] response HTTP response
658  */
659 void ast_ari_channels_record(struct ast_variable *headers, struct ast_ari_channels_record_args *args, struct ast_ari_response *response);
660 /*! Argument struct for ast_ari_channels_get_channel_var() */
661 struct ast_ari_channels_get_channel_var_args {
662         /*! Channel's id */
663         const char *channel_id;
664         /*! The channel variable or function to get */
665         const char *variable;
666 };
667 /*!
668  * \brief Body parsing function for /channels/{channelId}/variable.
669  * \param body The JSON body from which to parse parameters.
670  * \param[out] args The args structure to parse into.
671  * \retval zero on success
672  * \retval non-zero on failure
673  */
674 int ast_ari_channels_get_channel_var_parse_body(
675         struct ast_json *body,
676         struct ast_ari_channels_get_channel_var_args *args);
677
678 /*!
679  * \brief Get the value of a channel variable or function.
680  *
681  * \param headers HTTP headers
682  * \param args Swagger parameters
683  * \param[out] response HTTP response
684  */
685 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);
686 /*! Argument struct for ast_ari_channels_set_channel_var() */
687 struct ast_ari_channels_set_channel_var_args {
688         /*! Channel's id */
689         const char *channel_id;
690         /*! The channel variable or function to set */
691         const char *variable;
692         /*! The value to set the variable to */
693         const char *value;
694 };
695 /*!
696  * \brief Body parsing function for /channels/{channelId}/variable.
697  * \param body The JSON body from which to parse parameters.
698  * \param[out] args The args structure to parse into.
699  * \retval zero on success
700  * \retval non-zero on failure
701  */
702 int ast_ari_channels_set_channel_var_parse_body(
703         struct ast_json *body,
704         struct ast_ari_channels_set_channel_var_args *args);
705
706 /*!
707  * \brief Set the value of a channel variable or function.
708  *
709  * \param headers HTTP headers
710  * \param args Swagger parameters
711  * \param[out] response HTTP response
712  */
713 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);
714 /*! Argument struct for ast_ari_channels_snoop_channel() */
715 struct ast_ari_channels_snoop_channel_args {
716         /*! Channel's id */
717         const char *channel_id;
718         /*! Direction of audio to spy on */
719         const char *spy;
720         /*! Direction of audio to whisper into */
721         const char *whisper;
722         /*! Application the snooping channel is placed into */
723         const char *app;
724         /*! The application arguments to pass to the Stasis application */
725         const char *app_args;
726         /*! Unique ID to assign to snooping channel */
727         const char *snoop_id;
728 };
729 /*!
730  * \brief Body parsing function for /channels/{channelId}/snoop.
731  * \param body The JSON body from which to parse parameters.
732  * \param[out] args The args structure to parse into.
733  * \retval zero on success
734  * \retval non-zero on failure
735  */
736 int ast_ari_channels_snoop_channel_parse_body(
737         struct ast_json *body,
738         struct ast_ari_channels_snoop_channel_args *args);
739
740 /*!
741  * \brief Start snooping.
742  *
743  * Snoop (spy/whisper) on a specific channel.
744  *
745  * \param headers HTTP headers
746  * \param args Swagger parameters
747  * \param[out] response HTTP response
748  */
749 void ast_ari_channels_snoop_channel(struct ast_variable *headers, struct ast_ari_channels_snoop_channel_args *args, struct ast_ari_response *response);
750 /*! Argument struct for ast_ari_channels_snoop_channel_with_id() */
751 struct ast_ari_channels_snoop_channel_with_id_args {
752         /*! Channel's id */
753         const char *channel_id;
754         /*! Unique ID to assign to snooping channel */
755         const char *snoop_id;
756         /*! Direction of audio to spy on */
757         const char *spy;
758         /*! Direction of audio to whisper into */
759         const char *whisper;
760         /*! Application the snooping channel is placed into */
761         const char *app;
762         /*! The application arguments to pass to the Stasis application */
763         const char *app_args;
764 };
765 /*!
766  * \brief Body parsing function for /channels/{channelId}/snoop/{snoopId}.
767  * \param body The JSON body from which to parse parameters.
768  * \param[out] args The args structure to parse into.
769  * \retval zero on success
770  * \retval non-zero on failure
771  */
772 int ast_ari_channels_snoop_channel_with_id_parse_body(
773         struct ast_json *body,
774         struct ast_ari_channels_snoop_channel_with_id_args *args);
775
776 /*!
777  * \brief Start snooping.
778  *
779  * Snoop (spy/whisper) on a specific channel.
780  *
781  * \param headers HTTP headers
782  * \param args Swagger parameters
783  * \param[out] response HTTP response
784  */
785 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);
786 /*! Argument struct for ast_ari_channels_dial() */
787 struct ast_ari_channels_dial_args {
788         /*! Channel's id */
789         const char *channel_id;
790         /*! Channel ID of caller */
791         const char *caller;
792         /*! Dial timeout */
793         int timeout;
794 };
795 /*!
796  * \brief Body parsing function for /channels/{channelId}/dial.
797  * \param body The JSON body from which to parse parameters.
798  * \param[out] args The args structure to parse into.
799  * \retval zero on success
800  * \retval non-zero on failure
801  */
802 int ast_ari_channels_dial_parse_body(
803         struct ast_json *body,
804         struct ast_ari_channels_dial_args *args);
805
806 /*!
807  * \brief Dial a created channel.
808  *
809  * \param headers HTTP headers
810  * \param args Swagger parameters
811  * \param[out] response HTTP response
812  */
813 void ast_ari_channels_dial(struct ast_variable *headers, struct ast_ari_channels_dial_args *args, struct ast_ari_response *response);
814 /*! Argument struct for ast_ari_channels_rtpstatistics() */
815 struct ast_ari_channels_rtpstatistics_args {
816         /*! Channel's id */
817         const char *channel_id;
818 };
819 /*!
820  * \brief RTP stats on a channel.
821  *
822  * \param headers HTTP headers
823  * \param args Swagger parameters
824  * \param[out] response HTTP response
825  */
826 void ast_ari_channels_rtpstatistics(struct ast_variable *headers, struct ast_ari_channels_rtpstatistics_args *args, struct ast_ari_response *response);
827
828 #endif /* _ASTERISK_RESOURCE_CHANNELS_H */