res_stasis: Add ability to switch applications.
[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         /*! Reason for hanging up the channel */
211         const char *reason;
212 };
213 /*!
214  * \brief Body parsing function for /channels/{channelId}.
215  * \param body The JSON body from which to parse parameters.
216  * \param[out] args The args structure to parse into.
217  * \retval zero on success
218  * \retval non-zero on failure
219  */
220 int ast_ari_channels_hangup_parse_body(
221         struct ast_json *body,
222         struct ast_ari_channels_hangup_args *args);
223
224 /*!
225  * \brief Delete (i.e. hangup) a channel.
226  *
227  * \param headers HTTP headers
228  * \param args Swagger parameters
229  * \param[out] response HTTP response
230  */
231 void ast_ari_channels_hangup(struct ast_variable *headers, struct ast_ari_channels_hangup_args *args, struct ast_ari_response *response);
232 /*! Argument struct for ast_ari_channels_continue_in_dialplan() */
233 struct ast_ari_channels_continue_in_dialplan_args {
234         /*! Channel's id */
235         const char *channel_id;
236         /*! The context to continue to. */
237         const char *context;
238         /*! The extension to continue to. */
239         const char *extension;
240         /*! The priority to continue to. */
241         int priority;
242         /*! The label to continue to - will supersede 'priority' if both are provided. */
243         const char *label;
244 };
245 /*!
246  * \brief Body parsing function for /channels/{channelId}/continue.
247  * \param body The JSON body from which to parse parameters.
248  * \param[out] args The args structure to parse into.
249  * \retval zero on success
250  * \retval non-zero on failure
251  */
252 int ast_ari_channels_continue_in_dialplan_parse_body(
253         struct ast_json *body,
254         struct ast_ari_channels_continue_in_dialplan_args *args);
255
256 /*!
257  * \brief Exit application; continue execution in the dialplan.
258  *
259  * \param headers HTTP headers
260  * \param args Swagger parameters
261  * \param[out] response HTTP response
262  */
263 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);
264 /*! Argument struct for ast_ari_channels_move() */
265 struct ast_ari_channels_move_args {
266         /*! Channel's id */
267         const char *channel_id;
268         /*! The channel will be passed to this Stasis application. */
269         const char *app;
270         /*! The application arguments to pass to the Stasis application provided by 'app'. */
271         const char *app_args;
272 };
273 /*!
274  * \brief Body parsing function for /channels/{channelId}/move.
275  * \param body The JSON body from which to parse parameters.
276  * \param[out] args The args structure to parse into.
277  * \retval zero on success
278  * \retval non-zero on failure
279  */
280 int ast_ari_channels_move_parse_body(
281         struct ast_json *body,
282         struct ast_ari_channels_move_args *args);
283
284 /*!
285  * \brief Move the channel from one Stasis application to another.
286  *
287  * \param headers HTTP headers
288  * \param args Swagger parameters
289  * \param[out] response HTTP response
290  */
291 void ast_ari_channels_move(struct ast_variable *headers, struct ast_ari_channels_move_args *args, struct ast_ari_response *response);
292 /*! Argument struct for ast_ari_channels_redirect() */
293 struct ast_ari_channels_redirect_args {
294         /*! Channel's id */
295         const char *channel_id;
296         /*! The endpoint to redirect the channel to */
297         const char *endpoint;
298 };
299 /*!
300  * \brief Body parsing function for /channels/{channelId}/redirect.
301  * \param body The JSON body from which to parse parameters.
302  * \param[out] args The args structure to parse into.
303  * \retval zero on success
304  * \retval non-zero on failure
305  */
306 int ast_ari_channels_redirect_parse_body(
307         struct ast_json *body,
308         struct ast_ari_channels_redirect_args *args);
309
310 /*!
311  * \brief Redirect the channel to a different location.
312  *
313  * \param headers HTTP headers
314  * \param args Swagger parameters
315  * \param[out] response HTTP response
316  */
317 void ast_ari_channels_redirect(struct ast_variable *headers, struct ast_ari_channels_redirect_args *args, struct ast_ari_response *response);
318 /*! Argument struct for ast_ari_channels_answer() */
319 struct ast_ari_channels_answer_args {
320         /*! Channel's id */
321         const char *channel_id;
322 };
323 /*!
324  * \brief Answer a channel.
325  *
326  * \param headers HTTP headers
327  * \param args Swagger parameters
328  * \param[out] response HTTP response
329  */
330 void ast_ari_channels_answer(struct ast_variable *headers, struct ast_ari_channels_answer_args *args, struct ast_ari_response *response);
331 /*! Argument struct for ast_ari_channels_ring() */
332 struct ast_ari_channels_ring_args {
333         /*! Channel's id */
334         const char *channel_id;
335 };
336 /*!
337  * \brief Indicate ringing to a channel.
338  *
339  * \param headers HTTP headers
340  * \param args Swagger parameters
341  * \param[out] response HTTP response
342  */
343 void ast_ari_channels_ring(struct ast_variable *headers, struct ast_ari_channels_ring_args *args, struct ast_ari_response *response);
344 /*! Argument struct for ast_ari_channels_ring_stop() */
345 struct ast_ari_channels_ring_stop_args {
346         /*! Channel's id */
347         const char *channel_id;
348 };
349 /*!
350  * \brief Stop ringing indication on a channel if locally generated.
351  *
352  * \param headers HTTP headers
353  * \param args Swagger parameters
354  * \param[out] response HTTP response
355  */
356 void ast_ari_channels_ring_stop(struct ast_variable *headers, struct ast_ari_channels_ring_stop_args *args, struct ast_ari_response *response);
357 /*! Argument struct for ast_ari_channels_send_dtmf() */
358 struct ast_ari_channels_send_dtmf_args {
359         /*! Channel's id */
360         const char *channel_id;
361         /*! DTMF To send. */
362         const char *dtmf;
363         /*! Amount of time to wait before DTMF digits (specified in milliseconds) start. */
364         int before;
365         /*! Amount of time in between DTMF digits (specified in milliseconds). */
366         int between;
367         /*! Length of each DTMF digit (specified in milliseconds). */
368         int duration;
369         /*! Amount of time to wait after DTMF digits (specified in milliseconds) end. */
370         int after;
371 };
372 /*!
373  * \brief Body parsing function for /channels/{channelId}/dtmf.
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_send_dtmf_parse_body(
380         struct ast_json *body,
381         struct ast_ari_channels_send_dtmf_args *args);
382
383 /*!
384  * \brief Send provided DTMF to a given channel.
385  *
386  * \param headers HTTP headers
387  * \param args Swagger parameters
388  * \param[out] response HTTP response
389  */
390 void ast_ari_channels_send_dtmf(struct ast_variable *headers, struct ast_ari_channels_send_dtmf_args *args, struct ast_ari_response *response);
391 /*! Argument struct for ast_ari_channels_mute() */
392 struct ast_ari_channels_mute_args {
393         /*! Channel's id */
394         const char *channel_id;
395         /*! Direction in which to mute audio */
396         const char *direction;
397 };
398 /*!
399  * \brief Body parsing function for /channels/{channelId}/mute.
400  * \param body The JSON body from which to parse parameters.
401  * \param[out] args The args structure to parse into.
402  * \retval zero on success
403  * \retval non-zero on failure
404  */
405 int ast_ari_channels_mute_parse_body(
406         struct ast_json *body,
407         struct ast_ari_channels_mute_args *args);
408
409 /*!
410  * \brief Mute a channel.
411  *
412  * \param headers HTTP headers
413  * \param args Swagger parameters
414  * \param[out] response HTTP response
415  */
416 void ast_ari_channels_mute(struct ast_variable *headers, struct ast_ari_channels_mute_args *args, struct ast_ari_response *response);
417 /*! Argument struct for ast_ari_channels_unmute() */
418 struct ast_ari_channels_unmute_args {
419         /*! Channel's id */
420         const char *channel_id;
421         /*! Direction in which to unmute audio */
422         const char *direction;
423 };
424 /*!
425  * \brief Body parsing function for /channels/{channelId}/mute.
426  * \param body The JSON body from which to parse parameters.
427  * \param[out] args The args structure to parse into.
428  * \retval zero on success
429  * \retval non-zero on failure
430  */
431 int ast_ari_channels_unmute_parse_body(
432         struct ast_json *body,
433         struct ast_ari_channels_unmute_args *args);
434
435 /*!
436  * \brief Unmute a channel.
437  *
438  * \param headers HTTP headers
439  * \param args Swagger parameters
440  * \param[out] response HTTP response
441  */
442 void ast_ari_channels_unmute(struct ast_variable *headers, struct ast_ari_channels_unmute_args *args, struct ast_ari_response *response);
443 /*! Argument struct for ast_ari_channels_hold() */
444 struct ast_ari_channels_hold_args {
445         /*! Channel's id */
446         const char *channel_id;
447 };
448 /*!
449  * \brief Hold a channel.
450  *
451  * \param headers HTTP headers
452  * \param args Swagger parameters
453  * \param[out] response HTTP response
454  */
455 void ast_ari_channels_hold(struct ast_variable *headers, struct ast_ari_channels_hold_args *args, struct ast_ari_response *response);
456 /*! Argument struct for ast_ari_channels_unhold() */
457 struct ast_ari_channels_unhold_args {
458         /*! Channel's id */
459         const char *channel_id;
460 };
461 /*!
462  * \brief Remove a channel from hold.
463  *
464  * \param headers HTTP headers
465  * \param args Swagger parameters
466  * \param[out] response HTTP response
467  */
468 void ast_ari_channels_unhold(struct ast_variable *headers, struct ast_ari_channels_unhold_args *args, struct ast_ari_response *response);
469 /*! Argument struct for ast_ari_channels_start_moh() */
470 struct ast_ari_channels_start_moh_args {
471         /*! Channel's id */
472         const char *channel_id;
473         /*! Music on hold class to use */
474         const char *moh_class;
475 };
476 /*!
477  * \brief Body parsing function for /channels/{channelId}/moh.
478  * \param body The JSON body from which to parse parameters.
479  * \param[out] args The args structure to parse into.
480  * \retval zero on success
481  * \retval non-zero on failure
482  */
483 int ast_ari_channels_start_moh_parse_body(
484         struct ast_json *body,
485         struct ast_ari_channels_start_moh_args *args);
486
487 /*!
488  * \brief Play music on hold to a channel.
489  *
490  * 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.
491  *
492  * \param headers HTTP headers
493  * \param args Swagger parameters
494  * \param[out] response HTTP response
495  */
496 void ast_ari_channels_start_moh(struct ast_variable *headers, struct ast_ari_channels_start_moh_args *args, struct ast_ari_response *response);
497 /*! Argument struct for ast_ari_channels_stop_moh() */
498 struct ast_ari_channels_stop_moh_args {
499         /*! Channel's id */
500         const char *channel_id;
501 };
502 /*!
503  * \brief Stop playing music on hold to a channel.
504  *
505  * \param headers HTTP headers
506  * \param args Swagger parameters
507  * \param[out] response HTTP response
508  */
509 void ast_ari_channels_stop_moh(struct ast_variable *headers, struct ast_ari_channels_stop_moh_args *args, struct ast_ari_response *response);
510 /*! Argument struct for ast_ari_channels_start_silence() */
511 struct ast_ari_channels_start_silence_args {
512         /*! Channel's id */
513         const char *channel_id;
514 };
515 /*!
516  * \brief Play silence to a channel.
517  *
518  * Using media operations such as /play on a channel playing silence in this manner will suspend silence without resuming automatically.
519  *
520  * \param headers HTTP headers
521  * \param args Swagger parameters
522  * \param[out] response HTTP response
523  */
524 void ast_ari_channels_start_silence(struct ast_variable *headers, struct ast_ari_channels_start_silence_args *args, struct ast_ari_response *response);
525 /*! Argument struct for ast_ari_channels_stop_silence() */
526 struct ast_ari_channels_stop_silence_args {
527         /*! Channel's id */
528         const char *channel_id;
529 };
530 /*!
531  * \brief Stop playing silence to a channel.
532  *
533  * \param headers HTTP headers
534  * \param args Swagger parameters
535  * \param[out] response HTTP response
536  */
537 void ast_ari_channels_stop_silence(struct ast_variable *headers, struct ast_ari_channels_stop_silence_args *args, struct ast_ari_response *response);
538 /*! Argument struct for ast_ari_channels_play() */
539 struct ast_ari_channels_play_args {
540         /*! Channel's id */
541         const char *channel_id;
542         /*! Array of Media URIs to play. */
543         const char **media;
544         /*! Length of media array. */
545         size_t media_count;
546         /*! Parsing context for media. */
547         char *media_parse;
548         /*! For sounds, selects language for sound. */
549         const char *lang;
550         /*! Number of milliseconds to skip before playing. Only applies to the first URI if multiple media URIs are specified. */
551         int offsetms;
552         /*! Number of milliseconds to skip for forward/reverse operations. */
553         int skipms;
554         /*! Playback ID. */
555         const char *playback_id;
556 };
557 /*!
558  * \brief Body parsing function for /channels/{channelId}/play.
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_play_parse_body(
565         struct ast_json *body,
566         struct ast_ari_channels_play_args *args);
567
568 /*!
569  * \brief Start playback of media.
570  *
571  * 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.)
572  *
573  * \param headers HTTP headers
574  * \param args Swagger parameters
575  * \param[out] response HTTP response
576  */
577 void ast_ari_channels_play(struct ast_variable *headers, struct ast_ari_channels_play_args *args, struct ast_ari_response *response);
578 /*! Argument struct for ast_ari_channels_play_with_id() */
579 struct ast_ari_channels_play_with_id_args {
580         /*! Channel's id */
581         const char *channel_id;
582         /*! Playback ID. */
583         const char *playback_id;
584         /*! Array of Media URIs to play. */
585         const char **media;
586         /*! Length of media array. */
587         size_t media_count;
588         /*! Parsing context for media. */
589         char *media_parse;
590         /*! For sounds, selects language for sound. */
591         const char *lang;
592         /*! Number of milliseconds to skip before playing. Only applies to the first URI if multiple media URIs are specified. */
593         int offsetms;
594         /*! Number of milliseconds to skip for forward/reverse operations. */
595         int skipms;
596 };
597 /*!
598  * \brief Body parsing function for /channels/{channelId}/play/{playbackId}.
599  * \param body The JSON body from which to parse parameters.
600  * \param[out] args The args structure to parse into.
601  * \retval zero on success
602  * \retval non-zero on failure
603  */
604 int ast_ari_channels_play_with_id_parse_body(
605         struct ast_json *body,
606         struct ast_ari_channels_play_with_id_args *args);
607
608 /*!
609  * \brief Start playback of media and specify the playbackId.
610  *
611  * 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.)
612  *
613  * \param headers HTTP headers
614  * \param args Swagger parameters
615  * \param[out] response HTTP response
616  */
617 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);
618 /*! Argument struct for ast_ari_channels_record() */
619 struct ast_ari_channels_record_args {
620         /*! Channel's id */
621         const char *channel_id;
622         /*! Recording's filename */
623         const char *name;
624         /*! Format to encode audio in */
625         const char *format;
626         /*! Maximum duration of the recording, in seconds. 0 for no limit */
627         int max_duration_seconds;
628         /*! Maximum duration of silence, in seconds. 0 for no limit */
629         int max_silence_seconds;
630         /*! Action to take if a recording with the same name already exists. */
631         const char *if_exists;
632         /*! Play beep when recording begins */
633         int beep;
634         /*! DTMF input to terminate recording */
635         const char *terminate_on;
636 };
637 /*!
638  * \brief Body parsing function for /channels/{channelId}/record.
639  * \param body The JSON body from which to parse parameters.
640  * \param[out] args The args structure to parse into.
641  * \retval zero on success
642  * \retval non-zero on failure
643  */
644 int ast_ari_channels_record_parse_body(
645         struct ast_json *body,
646         struct ast_ari_channels_record_args *args);
647
648 /*!
649  * \brief Start a recording.
650  *
651  * 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.
652  *
653  * \param headers HTTP headers
654  * \param args Swagger parameters
655  * \param[out] response HTTP response
656  */
657 void ast_ari_channels_record(struct ast_variable *headers, struct ast_ari_channels_record_args *args, struct ast_ari_response *response);
658 /*! Argument struct for ast_ari_channels_get_channel_var() */
659 struct ast_ari_channels_get_channel_var_args {
660         /*! Channel's id */
661         const char *channel_id;
662         /*! The channel variable or function to get */
663         const char *variable;
664 };
665 /*!
666  * \brief Body parsing function for /channels/{channelId}/variable.
667  * \param body The JSON body from which to parse parameters.
668  * \param[out] args The args structure to parse into.
669  * \retval zero on success
670  * \retval non-zero on failure
671  */
672 int ast_ari_channels_get_channel_var_parse_body(
673         struct ast_json *body,
674         struct ast_ari_channels_get_channel_var_args *args);
675
676 /*!
677  * \brief Get the value of a channel variable or function.
678  *
679  * \param headers HTTP headers
680  * \param args Swagger parameters
681  * \param[out] response HTTP response
682  */
683 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);
684 /*! Argument struct for ast_ari_channels_set_channel_var() */
685 struct ast_ari_channels_set_channel_var_args {
686         /*! Channel's id */
687         const char *channel_id;
688         /*! The channel variable or function to set */
689         const char *variable;
690         /*! The value to set the variable to */
691         const char *value;
692 };
693 /*!
694  * \brief Body parsing function for /channels/{channelId}/variable.
695  * \param body The JSON body from which to parse parameters.
696  * \param[out] args The args structure to parse into.
697  * \retval zero on success
698  * \retval non-zero on failure
699  */
700 int ast_ari_channels_set_channel_var_parse_body(
701         struct ast_json *body,
702         struct ast_ari_channels_set_channel_var_args *args);
703
704 /*!
705  * \brief Set the value of a channel variable or function.
706  *
707  * \param headers HTTP headers
708  * \param args Swagger parameters
709  * \param[out] response HTTP response
710  */
711 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);
712 /*! Argument struct for ast_ari_channels_snoop_channel() */
713 struct ast_ari_channels_snoop_channel_args {
714         /*! Channel's id */
715         const char *channel_id;
716         /*! Direction of audio to spy on */
717         const char *spy;
718         /*! Direction of audio to whisper into */
719         const char *whisper;
720         /*! Application the snooping channel is placed into */
721         const char *app;
722         /*! The application arguments to pass to the Stasis application */
723         const char *app_args;
724         /*! Unique ID to assign to snooping channel */
725         const char *snoop_id;
726 };
727 /*!
728  * \brief Body parsing function for /channels/{channelId}/snoop.
729  * \param body The JSON body from which to parse parameters.
730  * \param[out] args The args structure to parse into.
731  * \retval zero on success
732  * \retval non-zero on failure
733  */
734 int ast_ari_channels_snoop_channel_parse_body(
735         struct ast_json *body,
736         struct ast_ari_channels_snoop_channel_args *args);
737
738 /*!
739  * \brief Start snooping.
740  *
741  * Snoop (spy/whisper) on a specific channel.
742  *
743  * \param headers HTTP headers
744  * \param args Swagger parameters
745  * \param[out] response HTTP response
746  */
747 void ast_ari_channels_snoop_channel(struct ast_variable *headers, struct ast_ari_channels_snoop_channel_args *args, struct ast_ari_response *response);
748 /*! Argument struct for ast_ari_channels_snoop_channel_with_id() */
749 struct ast_ari_channels_snoop_channel_with_id_args {
750         /*! Channel's id */
751         const char *channel_id;
752         /*! Unique ID to assign to snooping channel */
753         const char *snoop_id;
754         /*! Direction of audio to spy on */
755         const char *spy;
756         /*! Direction of audio to whisper into */
757         const char *whisper;
758         /*! Application the snooping channel is placed into */
759         const char *app;
760         /*! The application arguments to pass to the Stasis application */
761         const char *app_args;
762 };
763 /*!
764  * \brief Body parsing function for /channels/{channelId}/snoop/{snoopId}.
765  * \param body The JSON body from which to parse parameters.
766  * \param[out] args The args structure to parse into.
767  * \retval zero on success
768  * \retval non-zero on failure
769  */
770 int ast_ari_channels_snoop_channel_with_id_parse_body(
771         struct ast_json *body,
772         struct ast_ari_channels_snoop_channel_with_id_args *args);
773
774 /*!
775  * \brief Start snooping.
776  *
777  * Snoop (spy/whisper) on a specific channel.
778  *
779  * \param headers HTTP headers
780  * \param args Swagger parameters
781  * \param[out] response HTTP response
782  */
783 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);
784 /*! Argument struct for ast_ari_channels_dial() */
785 struct ast_ari_channels_dial_args {
786         /*! Channel's id */
787         const char *channel_id;
788         /*! Channel ID of caller */
789         const char *caller;
790         /*! Dial timeout */
791         int timeout;
792 };
793 /*!
794  * \brief Body parsing function for /channels/{channelId}/dial.
795  * \param body The JSON body from which to parse parameters.
796  * \param[out] args The args structure to parse into.
797  * \retval zero on success
798  * \retval non-zero on failure
799  */
800 int ast_ari_channels_dial_parse_body(
801         struct ast_json *body,
802         struct ast_ari_channels_dial_args *args);
803
804 /*!
805  * \brief Dial a created channel.
806  *
807  * \param headers HTTP headers
808  * \param args Swagger parameters
809  * \param[out] response HTTP response
810  */
811 void ast_ari_channels_dial(struct ast_variable *headers, struct ast_ari_channels_dial_args *args, struct ast_ari_response *response);
812
813 #endif /* _ASTERISK_RESOURCE_CHANNELS_H */