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