ARI: MOH start and stop for a channel
[asterisk/asterisk.git] / res / stasis_http / 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/stasis_http/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/stasis_http_resource.h.mustache
35  */
36
37 #ifndef _ASTERISK_RESOURCE_CHANNELS_H
38 #define _ASTERISK_RESOURCE_CHANNELS_H
39
40 #include "asterisk/stasis_http.h"
41
42 /*! \brief Argument struct for stasis_http_get_channels() */
43 struct ast_get_channels_args {
44 };
45 /*!
46  * \brief List active channels.
47  *
48  * \param headers HTTP headers
49  * \param args Swagger parameters
50  * \param[out] response HTTP response
51  */
52 void stasis_http_get_channels(struct ast_variable *headers, struct ast_get_channels_args *args, struct stasis_http_response *response);
53 /*! \brief Argument struct for stasis_http_originate() */
54 struct ast_originate_args {
55         /*! \brief Endpoint to call. */
56         const char *endpoint;
57         /*! \brief The extension to dial after the endpoint answers */
58         const char *extension;
59         /*! \brief The context to dial after the endpoint answers. If omitted, uses 'default' */
60         const char *context;
61         /*! \brief The priority to dial after the endpoint answers. If omitted, uses 1 */
62         long priority;
63         /*! \brief The application name to pass to the Stasis application. */
64         const char *app;
65         /*! \brief The application arguments to pass to the Stasis application. */
66         const char *app_args;
67         /*! \brief CallerID to use when dialing the endpoint or extension. */
68         const char *caller_id;
69         /*! \brief Timeout (in seconds) before giving up dialing, or -1 for no timeout. */
70         int timeout;
71 };
72 /*!
73  * \brief Create a new channel (originate).
74  *
75  * \param headers HTTP headers
76  * \param args Swagger parameters
77  * \param[out] response HTTP response
78  */
79 void stasis_http_originate(struct ast_variable *headers, struct ast_originate_args *args, struct stasis_http_response *response);
80 /*! \brief Argument struct for stasis_http_get_channel() */
81 struct ast_get_channel_args {
82         /*! \brief Channel's id */
83         const char *channel_id;
84 };
85 /*!
86  * \brief Channel details.
87  *
88  * \param headers HTTP headers
89  * \param args Swagger parameters
90  * \param[out] response HTTP response
91  */
92 void stasis_http_get_channel(struct ast_variable *headers, struct ast_get_channel_args *args, struct stasis_http_response *response);
93 /*! \brief Argument struct for stasis_http_delete_channel() */
94 struct ast_delete_channel_args {
95         /*! \brief Channel's id */
96         const char *channel_id;
97 };
98 /*!
99  * \brief Delete (i.e. hangup) a channel.
100  *
101  * \param headers HTTP headers
102  * \param args Swagger parameters
103  * \param[out] response HTTP response
104  */
105 void stasis_http_delete_channel(struct ast_variable *headers, struct ast_delete_channel_args *args, struct stasis_http_response *response);
106 /*! \brief Argument struct for stasis_http_dial() */
107 struct ast_dial_args {
108         /*! \brief Channel's id */
109         const char *channel_id;
110         /*! \brief Endpoint to call. If not specified, dial is routed via dialplan */
111         const char *endpoint;
112         /*! \brief Extension to dial */
113         const char *extension;
114         /*! \brief When routing via dialplan, the context use. If omitted, uses 'default' */
115         const char *context;
116         /*! \brief Timeout (in seconds) before giving up dialing, or -1 for no timeout. */
117         int timeout;
118 };
119 /*!
120  * \brief Create a new channel (originate) and bridge to this channel.
121  *
122  * \param headers HTTP headers
123  * \param args Swagger parameters
124  * \param[out] response HTTP response
125  */
126 void stasis_http_dial(struct ast_variable *headers, struct ast_dial_args *args, struct stasis_http_response *response);
127 /*! \brief Argument struct for stasis_http_continue_in_dialplan() */
128 struct ast_continue_in_dialplan_args {
129         /*! \brief Channel's id */
130         const char *channel_id;
131         /*! \brief The context to continue to. */
132         const char *context;
133         /*! \brief The extension to continue to. */
134         const char *extension;
135         /*! \brief The priority to continue to. */
136         int priority;
137 };
138 /*!
139  * \brief Exit application; continue execution in the dialplan.
140  *
141  * \param headers HTTP headers
142  * \param args Swagger parameters
143  * \param[out] response HTTP response
144  */
145 void stasis_http_continue_in_dialplan(struct ast_variable *headers, struct ast_continue_in_dialplan_args *args, struct stasis_http_response *response);
146 /*! \brief Argument struct for stasis_http_answer_channel() */
147 struct ast_answer_channel_args {
148         /*! \brief Channel's id */
149         const char *channel_id;
150 };
151 /*!
152  * \brief Answer a channel.
153  *
154  * \param headers HTTP headers
155  * \param args Swagger parameters
156  * \param[out] response HTTP response
157  */
158 void stasis_http_answer_channel(struct ast_variable *headers, struct ast_answer_channel_args *args, struct stasis_http_response *response);
159 /*! \brief Argument struct for stasis_http_mute_channel() */
160 struct ast_mute_channel_args {
161         /*! \brief Channel's id */
162         const char *channel_id;
163         /*! \brief Direction in which to mute audio */
164         const char *direction;
165 };
166 /*!
167  * \brief Mute a channel.
168  *
169  * \param headers HTTP headers
170  * \param args Swagger parameters
171  * \param[out] response HTTP response
172  */
173 void stasis_http_mute_channel(struct ast_variable *headers, struct ast_mute_channel_args *args, struct stasis_http_response *response);
174 /*! \brief Argument struct for stasis_http_unmute_channel() */
175 struct ast_unmute_channel_args {
176         /*! \brief Channel's id */
177         const char *channel_id;
178         /*! \brief Direction in which to unmute audio */
179         const char *direction;
180 };
181 /*!
182  * \brief Unmute a channel.
183  *
184  * \param headers HTTP headers
185  * \param args Swagger parameters
186  * \param[out] response HTTP response
187  */
188 void stasis_http_unmute_channel(struct ast_variable *headers, struct ast_unmute_channel_args *args, struct stasis_http_response *response);
189 /*! \brief Argument struct for stasis_http_hold_channel() */
190 struct ast_hold_channel_args {
191         /*! \brief Channel's id */
192         const char *channel_id;
193 };
194 /*!
195  * \brief Hold a channel.
196  *
197  * \param headers HTTP headers
198  * \param args Swagger parameters
199  * \param[out] response HTTP response
200  */
201 void stasis_http_hold_channel(struct ast_variable *headers, struct ast_hold_channel_args *args, struct stasis_http_response *response);
202 /*! \brief Argument struct for stasis_http_unhold_channel() */
203 struct ast_unhold_channel_args {
204         /*! \brief Channel's id */
205         const char *channel_id;
206 };
207 /*!
208  * \brief Remove a channel from hold.
209  *
210  * \param headers HTTP headers
211  * \param args Swagger parameters
212  * \param[out] response HTTP response
213  */
214 void stasis_http_unhold_channel(struct ast_variable *headers, struct ast_unhold_channel_args *args, struct stasis_http_response *response);
215 /*! \brief Argument struct for stasis_http_moh_start_channel() */
216 struct ast_moh_start_channel_args {
217         /*! \brief Channel's id */
218         const char *channel_id;
219         /*! \brief Music on hold class to use */
220         const char *moh_class;
221 };
222 /*!
223  * \brief Play music on hold to a channel.
224  *
225  * Using media operations such as playOnChannel 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.
226  *
227  * \param headers HTTP headers
228  * \param args Swagger parameters
229  * \param[out] response HTTP response
230  */
231 void stasis_http_moh_start_channel(struct ast_variable *headers, struct ast_moh_start_channel_args *args, struct stasis_http_response *response);
232 /*! \brief Argument struct for stasis_http_moh_stop_channel() */
233 struct ast_moh_stop_channel_args {
234         /*! \brief Channel's id */
235         const char *channel_id;
236 };
237 /*!
238  * \brief Stop playing music on hold to a channel.
239  *
240  * \param headers HTTP headers
241  * \param args Swagger parameters
242  * \param[out] response HTTP response
243  */
244 void stasis_http_moh_stop_channel(struct ast_variable *headers, struct ast_moh_stop_channel_args *args, struct stasis_http_response *response);
245 /*! \brief Argument struct for stasis_http_play_on_channel() */
246 struct ast_play_on_channel_args {
247         /*! \brief Channel's id */
248         const char *channel_id;
249         /*! \brief Media's URI to play. */
250         const char *media;
251         /*! \brief For sounds, selects language for sound. */
252         const char *lang;
253         /*! \brief Number of media to skip before playing. */
254         int offsetms;
255         /*! \brief Number of milliseconds to skip for forward/reverse operations. */
256         int skipms;
257 };
258 /*!
259  * \brief Start playback of media.
260  *
261  * The media URI may be any of a number of URI's. You may use http: and https: URI's, as well as sound: and recording: URI's. This operation creates a playback resource that can be used to control the playback of media (pause, rewind, fast forward, etc.)
262  *
263  * \param headers HTTP headers
264  * \param args Swagger parameters
265  * \param[out] response HTTP response
266  */
267 void stasis_http_play_on_channel(struct ast_variable *headers, struct ast_play_on_channel_args *args, struct stasis_http_response *response);
268 /*! \brief Argument struct for stasis_http_record_channel() */
269 struct ast_record_channel_args {
270         /*! \brief Channel's id */
271         const char *channel_id;
272         /*! \brief Recording's filename */
273         const char *name;
274         /*! \brief Format to encode audio in */
275         const char *format;
276         /*! \brief Maximum duration of the recording, in seconds. 0 for no limit */
277         int max_duration_seconds;
278         /*! \brief Maximum duration of silence, in seconds. 0 for no limit */
279         int max_silence_seconds;
280         /*! \brief Action to take if a recording with the same name already exists. */
281         const char *if_exists;
282         /*! \brief Play beep when recording begins */
283         int beep;
284         /*! \brief DTMF input to terminate recording */
285         const char *terminate_on;
286 };
287 /*!
288  * \brief Start a recording.
289  *
290  * 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.
291  *
292  * \param headers HTTP headers
293  * \param args Swagger parameters
294  * \param[out] response HTTP response
295  */
296 void stasis_http_record_channel(struct ast_variable *headers, struct ast_record_channel_args *args, struct stasis_http_response *response);
297 /*! \brief Argument struct for stasis_http_get_channel_var() */
298 struct ast_get_channel_var_args {
299         /*! \brief Channel's id */
300         const char *channel_id;
301         /*! \brief The channel variable or function to get */
302         const char *variable;
303 };
304 /*!
305  * \brief Get the value of a channel variable or function.
306  *
307  * \param headers HTTP headers
308  * \param args Swagger parameters
309  * \param[out] response HTTP response
310  */
311 void stasis_http_get_channel_var(struct ast_variable *headers, struct ast_get_channel_var_args *args, struct stasis_http_response *response);
312 /*! \brief Argument struct for stasis_http_set_channel_var() */
313 struct ast_set_channel_var_args {
314         /*! \brief Channel's id */
315         const char *channel_id;
316         /*! \brief The channel variable or function to set */
317         const char *variable;
318         /*! \brief The value to set the variable to */
319         const char *value;
320 };
321 /*!
322  * \brief Set the value of a channel variable or function.
323  *
324  * \param headers HTTP headers
325  * \param args Swagger parameters
326  * \param[out] response HTTP response
327  */
328 void stasis_http_set_channel_var(struct ast_variable *headers, struct ast_set_channel_var_args *args, struct stasis_http_response *response);
329
330 #endif /* _ASTERISK_RESOURCE_CHANNELS_H */