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