ari

type Application interface {

	// List returns the list of applications in Asterisk
	List() ([]*ApplicationHandle, error)

	// Get returns a handle to the application for further interaction
	Get(name string) *ApplicationHandle

	// Data returns the applications data
	Data(name string) (ApplicationData, error)

	// Subscribe subscribes the given application to an event source
	// event source may be one of:
	//  - channel:<channelId>
	//  - bridge:<bridgeId>
	//  - endpoint:<tech>/<resource> (e.g. SIP/102)
	//  - deviceState:<deviceName>
	Subscribe(name string, eventSource string) error

	// Unsubscribe unsubscribes (removes a subscription to) a given
	// ARI application from the provided event source
	// Equivalent to DELETE /applications/{applicationName}/subscription
	Unsubscribe(name string, eventSource string) error
}

type ApplicationData struct {
	BridgeIDs   []string `json:"bridge_ids"`   // Subscribed BridgeIds
	ChannelIDs  []string `json:"channel_ids"`  // Subscribed ChannelIds
	DeviceNames []string `json:"device_names"` // Subscribed Device names
	EndpointIDs []string `json:"endpoint_ids"` // Subscribed Endpoints (tech/resource format)
	Name        string   `json:"name"`         // Name of the application
}

type ApplicationEvent interface {
	GetApplication() string
}

type ApplicationHandle struct {
	// contains filtered or unexported fields
}

type ApplicationReplaced struct {
	EventData
}

type Asterisk interface {

	// Info gets data about the asterisk system
	Info(only string) (*AsteriskInfo, error)

	// Variables returns the global asterisk variables
	Variables() Variables

	// Logging returns the interface for working with asterisk logs
	Logging() Logging

	// Modules returns the interface for working with asterisk modules
	Modules() Modules

	// Config returns the interface for working with dynamic configuration
	Config() Config

	// ReloadModule tells asterisk to load the given module
	ReloadModule(name string) error
}

type AsteriskInfo struct {
	BuildInfo  BuildInfo  `json:"build"`
	ConfigInfo ConfigInfo `json:"config"`
	StatusInfo StatusInfo `json:"status"`
	SystemInfo SystemInfo `json:"system"`
}

type Bridge interface {

	// Create creates a bridge
	Create(id string, btype string, name string) (*BridgeHandle, error)

	// Get gets the BridgeHandle
	Get(id string) *BridgeHandle

	// Lists returns the lists of bridges in asterisk
	List() ([]*BridgeHandle, error)

	// Data gets the bridge data
	Data(id string) (BridgeData, error)

	// AddChannel adds a channel to the bridge
	AddChannel(bridgeID string, channelID string) error

	// RemoveChannel removes a channel from the bridge
	RemoveChannel(bridgeID string, channelID string) error

	// Delete deletes the bridge
	Delete(id string) error

	// Play plays the media URI to the bridge
	Play(id string, playbackID string, mediaURI string) (*PlaybackHandle, error)

	// Record records the bridge
	Record(id string, name string, opts *RecordingOptions) (*LiveRecordingHandle, error)

	// Subscribe subscribes the given bridge events events
	Subscribe(id string, n ...string) Subscription
}

type BridgeAttendedTransfer struct {
	EventData
	DestinationApplication     string      `json:"destination_application"`      // Application that has been transferred into
	DestinationBridge          string      `json:"destination_bridge"`           // Bridge that survived the merge result
	DestinationLinkFirstLeg    ChannelData `json:"destination_link_first_leg"`   // First leg of a link transfer result
	DestinationLinkSecondLeg   ChannelData `json:"destination_link_second_leg"`  // Second leg of a link transfer result
	DestinationThreewayBridge  BridgeData  `json:"destination_threeway_bridge"`  // Bridge that survived the threeway result
	DestinationThreewayChannel ChannelData `json:"destination_threeway_channel"` // Transferer channel that survived the threeway result
	DestinationType            string      `json:"destination_type"`             // How the transfer was accomplished
	IsExternal                 bool        `json:"is_external"`                  // Whether the transfer was externally initiated or not
	ReplaceChannel             ChannelData `json:"replace_channel,omitempty"`    // The channel that is replacing transferer_first_leg in the swap
	Result                     string      `json:"result"`                       // The result of the transfer attempt
	TransferTarget             ChannelData `json:"transfer_target,omitempty"`    // The channel that is being transferred to
	Transferee                 ChannelData `json:"transferee,omitempty"`         // The channel that is being transferred
	TransfererFirstLeg         ChannelData `json:"transferer_first_leg"`         // First leg of the transferer
	TransfererFirstLegBridge   BridgeData  `json:"transferer_first_leg_bridge"`  // Bridge the transferer first leg is in
	TransfererSecondLeg        ChannelData `json:"transferer_second_leg"`        // Second leg of the transferer
	TransfererSecondLegBridge  BridgeData  `json:"transferer_second_leg_bridge"` // Bridge the transferer second leg is in
}

type BridgeBlindTransfer struct {
	EventData
	Bridge         BridgeData  `json:"bridge"`                    // The bridge being transferred
	Channel        ChannelData `json:"channel"`                   // The channel performing the blind transfer
	Context        string      `json:"context"`                   // The context transferred to
	Exten          string      `json:"exten"`                     // The extension transferred to
	IsExternal     bool        `json:"is_external"`               // Whether the transfer was externally initiated or not
	ReplaceChannel ChannelData `json:"replace_channel,omitempty"` // The channel that is replacing transferer when the transferee(s) can not be transferred directly
	Result         string      `json:"result"`                    // The result of the transfer attempt
	Transferee     ChannelData `json:"transferee,omitempty"`      // The channel that is being transferred
}

type BridgeCreated struct {
	EventData
	Bridge BridgeData `json:"bridge"`
}

type BridgeData struct {
	ID         string   `json:"id"`          // Unique Id for this bridge
	Class      string   `json:"bridge"`      // Class of the bridge (TODO: huh?)
	Type       string   `json:"bridge_type"` // Type of bridge (mixing, holding, dtmf_events, proxy_media)
	ChannelIDs []string `json:"channels"`    // List of pariticipating channel ids
	Creator    string   `json:"creator"`     // Creating entity of the bridge
	Name       string   `json:"name"`        // The name of the bridge
	Technology string   `json:"technology"`  // Name of the bridging technology
}

type BridgeDestroyed struct {
	EventData
	Bridge BridgeData `json:"bridge"`
}

type BridgeEvent interface {
	GetBridgeIDs() []string
}

type BridgeHandle struct {
	// contains filtered or unexported fields
}

type BridgeMerged struct {
	EventData
	Bridge     BridgeData `json:"bridge"`
	BridgeFrom BridgeData `json:"bridge_from"`
}

type BuildInfo struct {
	Date    string `json:"date"`
	Kernel  string `json:"kernel"`
	Machine string `json:"machine"`
	Options string `json:"options"`
	Os      string `json:"os"`
	User    string `json:"user"`
}

type Bus interface {
	Sender
	Subscriber
}

type CallerID struct {
	Name   string `json:"name"`
	Number string `json:"number"`
}

type Channel interface {
	// Get returns a handle to a channel for further interaction
	Get(id string) *ChannelHandle

	// List lists the channels in asterisk
	List() ([]*ChannelHandle, error)

	// Create creates a new channel, returning a handle to it or an
	// error, if the creation failed
	Create(OriginateRequest) (*ChannelHandle, error)

	// Data returns the channel data for a given channel
	Data(id string) (ChannelData, error)

	// Continue tells Asterisk to return a channel to the dialplan
	Continue(id, context, extension string, priority int) error

	// Busy hangs up the channel with the "busy" cause code
	Busy(id string) error

	// Congestion hangs up the channel with the "congestion" cause code
	Congestion(id string) error

	// Answer answers the channel
	Answer(id string) error

	// Hangup hangs up the given channel
	Hangup(id string, reason string) error

	// Ring indicates ringing to the channel
	Ring(id string) error

	// StopRing stops ringing on the channel
	StopRing(id string) error

	// SendDTMF sends DTMF to the channel
	SendDTMF(id string, dtmf string, opts *DTMFOptions) error

	// Hold puts the channel on hold
	Hold(id string) error

	// StopHold retrieves the channel from hold
	StopHold(id string) error

	// Mute mutes a channel in the given direction (in,out,both)
	Mute(id string, dir string) error

	// Unmute unmutes a channel in the given direction (in,out,both)
	Unmute(id string, dir string) error

	// MOH plays music on hold
	MOH(id string, moh string) error

	// StopMOH stops music on hold
	StopMOH(id string) error

	// Silence plays silence to the channel
	Silence(id string) error

	// StopSilence stops the silence on the channel
	StopSilence(id string) error

	// Play plays the media URI to the channel
	Play(id string, playbackID string, mediaURI string) (*PlaybackHandle, error)

	// Record records the channel
	Record(id string, name string, opts *RecordingOptions) (*LiveRecordingHandle, error)

	// Dial dials a created channel
	Dial(id string, caller string, timeout time.Duration) error

	// Snoop spies on a specific channel, creating a new snooping channel
	Snoop(id string, snoopID string, app string, opts *SnoopOptions) (*ChannelHandle, error)

	// Subscribe subscribes on the channel events
	Subscribe(id string, n ...string) Subscription
}

type ChannelCallerID struct {
	EventData
	CallerPresentation    int         `json:"caller_presentation"`     // The integer representation of the Caller Presentation value.
	CallerPresentationTxt string      `json:"caller_presentation_txt"` // The text representation of the Caller Presentation value.
	Channel               ChannelData `json:"channel"`                 // The channel that changed Caller ID.
}

type ChannelConnectedLine struct {
	EventData
	Channel ChannelData `json:"channel"` // The channel whose connected line has changed.
}

type ChannelCreated struct {
	EventData
	Channel ChannelData `json:"channel"`
}

type ChannelData struct {
	ID           string      `json:"id"`    // Unique id for this channel (same as for AMI)
	Name         string      `json:"name"`  // Name of this channel (tech/name-id format)
	State        string      `json:"state"` // State of the channel
	Accountcode  string      `json:"accountcode"`
	Caller       CallerID    `json:"caller"`    // CallerId of the calling endpoint
	Connected    CallerID    `json:"connected"` // CallerId of the connected line
	Creationtime DateTime    `json:"creationtime"`
	Dialplan     DialplanCEP `json:"dialplan"` // Current location in the dialplan
}

type ChannelDestroyed struct {
	EventData
	Cause    int         `json:"cause"`     // Integer representation of the cause of the hangup
	CauseTxt string      `json:"cause_txt"` // Text representation of the cause of the hangup
	Channel  ChannelData `json:"channel"`
}

type ChannelDialplan struct {
	EventData
	Channel         ChannelData `json:"channel"`           // The channel that changed dialplan location.
	DialplanApp     string      `json:"dialplan_app"`      // The application about to be executed.
	DialplanAppData string      `json:"dialplan_app_data"` // The data to be passed to the application.
}

type ChannelDtmfReceived struct {
	EventData
	Channel    ChannelData `json:"channel"`     // The channel on which DTMF was received
	Digit      string      `json:"digit"`       // DTMF digit received (0-9, A-E, # or *)
	DurationMs int         `json:"duration_ms"` // Number of milliseconds DTMF was received
}

type ChannelEnteredBridge struct {
	EventData
	Bridge  BridgeData  `json:"bridge"`
	Channel ChannelData `json:"channel"`
}

type ChannelEvent interface {
	GetChannelIDs() []string
}

type ChannelHandle struct {
	// contains filtered or unexported fields
}

type ChannelHangupRequest struct {
	EventData
	Cause   int         `json:"cause"`   // Integer representation of the cause of the hangup.
	Channel ChannelData `json:"channel"` // The channel on which the hangup was requested.
	Soft    bool        `json:"soft"`    // Whether the hangup request was a soft hangup request.
}

type ChannelHold struct {
	EventData
	Channel    ChannelData `json:"channel"`              // The channel that initiated the hold event.
	Musicclass string      `json:"musicclass,omitempty"` // The music on hold class that the initiator requested.
}

type ChannelLeftBridge struct {
	EventData
	Bridge  BridgeData  `json:"bridge"`
	Channel ChannelData `json:"channel"`
}

type ChannelStateChange struct {
	EventData
	Channel ChannelData `json:"channel"`
}

type ChannelTalkingFinished struct {
	EventData
	Channel  ChannelData `json:"channel"`  // The channel on which talking completed.
	Duration int         `json:"duration"` // The length of time, in milliseconds, that talking was detected on the channel
}

type ChannelTalkingStarted struct {
	EventData
	Channel ChannelData `json:"channel"` // The channel on which talking started.
}

type ChannelUnhold struct {
	EventData
	Channel ChannelData `json:"channel"` // The channel that initiated the unhold event.
}

type ChannelUserevent struct {
	EventData
	Bridge    BridgeData   `json:"bridge,omitempty"`   // A bridge that is signaled with the user event.
	Channel   ChannelData  `json:"channel,omitempty"`  // A channel that is signaled with the user event.
	Endpoint  EndpointData `json:"endpoint,omitempty"` // A endpoint that is signaled with the user event.
	Eventname string       `json:"eventname"`          // The name of the user event.
	Userevent interface{}  `json:"userevent"`          // Custom Userevent data
}

type ChannelVarset struct {
	EventData
	Channel  ChannelData `json:"channel,omitempty"` // The channel on which the variable was set.If missing, the variable is a global variable.
	Value    string      `json:"value"`             // The new value of the variable.
	Variable string      `json:"variable"`          // The variable that changed.
}

type Client struct {
	// Namespaced Interfaces
	Application Application
	Asterisk    Asterisk
	Channel     Channel
	Bridge      Bridge
	Playback    Playback
	Mailbox     Mailbox
	Endpoint    Endpoint
	DeviceState DeviceState
	TextMessage TextMessage
	Sound       Sound
	Recording   *Recording
	Bus         Bus

	Cleanup func() error
}

type Config interface {

	// Get gets the reference to a config object
	Get(configClass, objectType, id string) *ConfigHandle

	// Data gets the data for the config object
	Data(configClass, objectType, id string) (ConfigData, error)

	// Update creates or updates the given tuples
	Update(configClass, objectType, id string, tuples []ConfigTuple) error

	// Delete deletes the dynamic configuration object.
	Delete(configClass, objectType, id string) error
}

type ConfigData struct {
	ID     string
	Class  string
	Type   string
	Fields []ConfigTuple
}

type ConfigHandle struct {
	// contains filtered or unexported fields
}

type ConfigInfo struct {
	DefaultLanguage string  `json:"default_language"`
	MaxChannels     int     `json:"max_channels,omitempty"` //omitempty denotes an optional field, meaning the field may not be present if no value is assigned.
	MaxLoad         float64 `json:"max_load,omitempty"`
	MaxOpenFiles    int     `json:"max_open_files,omitempty"`
	Name            string  `json:"name"`  // Asterisk system name
	SetID           SetID   `json:"setid"` // Effective user/group id under which Asterisk is running
}

type ConfigTuple struct {
	Attribute string `json:"attribute"`
	Value     string `json:"value"`
}

type ContactInfo struct {
	EventData
	Aor           string `json:"aor"`                      // The Address of Record this contact belongs to.
	ContactStatus string `json:"contact_status"`           // The current status of the contact.
	RoundtripUsec string `json:"roundtrip_usec,omitempty"` // Current round trip time, in microseconds, for the contact.
	Uri           string `json:"uri"`                      // The location of the contact.
}

type ContactStatusChange struct {
	EventData
	ContactInfo ContactInfo  `json:"contact_info"`
	Endpoint    EndpointData `json:"endpoint"`
}

type DTMFOptions struct {
	Before   time.Duration
	Between  time.Duration
	Duration time.Duration
	After    time.Duration
}

type DTMFSender interface {
	SendDTMF(dtmf string, opts *DTMFOptions)
}

type DateTime time.Time

type DeviceState interface {
	Get(name string) *DeviceStateHandle

	List() ([]*DeviceStateHandle, error)

	Data(name string) (DeviceStateData, error)

	Update(name string, state string) error

	Delete(name string) error
}

type DeviceStateChanged struct {
	EventData
	DeviceState DeviceStateData `json:"device_state"` // Device state object
}

type DeviceStateData string

type DeviceStateHandle struct {
	// contains filtered or unexported fields
}

type Dial struct {
	EventData
	Caller     ChannelData `json:"caller,omitempty"`     // The calling channel.
	Dialstatus string      `json:"dialstatus"`           // Current status of the dialing attempt to the peer.
	Dialstring string      `json:"dialstring,omitempty"` // The dial string for calling the peer channel.
	Forward    string      `json:"forward,omitempty"`    // Forwarding target requested by the original dialed channel.
	Forwarded  ChannelData `json:"forwarded,omitempty"`  // Channel that the caller has been forwarded to.
	Peer       ChannelData `json:"peer"`                 // The dialed channel.
}

type DialplanCEP struct {
	Context  string `json:"context"`
	Exten    string `json:"exten"`
	Priority int64  `json:"priority"` //int64 derived from Java's 'long'
}

type DurationSec time.Duration

type Endpoint interface {

	// List lists the endpoints
	// TODO: associated with the application, or on the entire system?
	List() ([]*EndpointHandle, error)

	// List available endpoints for a given endpoint technology
	ListByTech(tech string) ([]*EndpointHandle, error)

	// Get returns a handle to the endpoint for further operations
	Get(tech string, resource string) *EndpointHandle

	// Data returns the state of the endpoint
	Data(tech string, resource string) (EndpointData, error)
}

type EndpointData struct {
	ChannelIDs []string `json:"channel_ids"`     // List of channel Ids which are associated with this endpoint
	Resource   string   `json:"resource"`        // The endpoint's resource name
	State      string   `json:"state,omitempty"` // The state of the endpoint
	Technology string   `json:"technology"`      // The technology of the endpoint (e.g. SIP, PJSIP, DAHDI, etc)
}

type EndpointEvent interface {
	GetEndpointIDs() []string
}

type EndpointHandle struct {
	// contains filtered or unexported fields
}

type EndpointStateChange struct {
	EventData
	Endpoint EndpointData `json:"endpoint"`
}

type Event interface {
	MessageRawer
	ApplicationEvent
	GetType() string
}

type EventData struct {
	Message
	Application string   `json:"application"`
	Timestamp   DateTime `json:"timestamp,omitempty"`
}

type EventTypes struct {
	All                    string
	ApplicationReplaced    string
	BridgeAttendedTransfer string
	BridgeBlindTransfer    string
	BridgeCreated          string
	BridgeDestroyed        string
	BridgeMerged           string
	ChannelCallerID        string
	ChannelConnectedLine   string
	ChannelCreated         string
	ChannelDestroyed       string
	ChannelDialplan        string
	ChannelDtmfReceived    string
	ChannelEnteredBridge   string
	ChannelHangupRequest   string
	ChannelHold            string
	ChannelLeftBridge      string
	ChannelStateChange     string
	ChannelTalkingFinished string
	ChannelTalkingStarted  string
	ChannelUnhold          string
	ChannelUserevent       string
	ChannelVarset          string
	ContactInfo            string
	ContactStatusChange    string
	DeviceStateChanged     string
	Dial                   string
	EndpointStateChange    string
	MissingParams          string
	Peer                   string
	PeerStatusChange       string
	PlaybackContinuing     string
	PlaybackFinished       string
	PlaybackStarted        string
	RecordingFailed        string
	RecordingFinished      string
	RecordingStarted       string
	StasisEnd              string
	StasisStart            string
	TextMessageReceived    string
}

type FormatLangPair struct {
	Format   string `json:"format"`
	Language string `json:"language"`
}

type LiveRecording interface {

	// Get gets the Recording by type
	Get(name string) *LiveRecordingHandle

	// Data gets the data for the live recording
	Data(name string) (LiveRecordingData, error)

	// Stop stops the live recording
	Stop(name string) error

	// Pause pauses the live recording
	Pause(name string) error

	// Resume resumes the live recording
	Resume(name string) error

	// Mute mutes the live recording
	Mute(name string) error

	// Unmute unmutes the live recording
	Unmute(name string) error

	// Delete deletes the live recording
	Delete(name string) error

	// Scrap Stops and deletes the current LiveRecording
	//TODO: reproduce this error in isolation: does not delete. Cannot delete any recording produced by this.
	Scrap(name string) error
}

type LiveRecordingData struct {
	Cause     string      `json:"cause,omitempty"`            // If failed, the cause of the failure
	Duration  DurationSec `json:"duration,omitempty"`         // Length of recording in seconds
	Format    string      `json:"format"`                     // Format of recording (wav, gsm, etc)
	Name      string      `json:"name"`                       // (base) name for the recording
	Silence   DurationSec `json:"silence_duration,omitempty"` // If silence was detected in the recording, the duration in seconds of that silence (requires that maxSilenceSeconds be non-zero)
	State     string      `json:"state"`                      // Current state of the recording
	Talking   DurationSec `json:"talking_duration,omitempty"` // Duration of talking, in seconds, that has been detected in the recording (requires that maxSilenceSeconds be non-zero)
	TargetURI string      `json:"target_uri"`                 // URI for the channel or bridge which is being recorded (TODO: figure out format for this)
}

type LiveRecordingHandle struct {
	// contains filtered or unexported fields
}

type LogData struct {
	Name          string `json:"channel"`
	Configuration string `json:"configuration"`
	Type          string `json:"type"`
	Status        string `json:"configuration"`
}

type Logging interface {

	// Create creates a new log
	Create(name string, level string) error

	// List the logs
	List() ([]LogData, error)

	// Rotate rotates the log
	Rotate(name string) error

	// Delete deletes the log
	Delete(name string) error
}

type Mailbox interface {

	// Get gets a handle to the mailbox for further operations
	Get(name string) *MailboxHandle

	// List lists the mailboxes in asterisk
	List() ([]*MailboxHandle, error)

	// Data gets the current state of the mailbox
	Data(name string) (MailboxData, error)

	// Update updates the state of the mailbox, or creates if does not exist
	Update(name string, oldMessages int, newMessages int) error

	// Delete deletes the mailbox
	Delete(name string) error
}

type MailboxData struct {
	Name        string `json:"name"`
	NewMessages int    `json:"new_messages"` // Number of new (unread) messages
	OldMessages int    `json:"old_messages"` // Number of old (read) messages
}

type MailboxHandle struct {
	// contains filtered or unexported fields
}

type Matcher interface {
	Match(evt Event) bool
}

type Message struct {
	RawMessage
	Type string `json:"type"`
}

type MessageRawer interface {
	SetRaw(*[]byte)
	GetRaw() *[]byte
}

type MissingParams struct {
	EventData
	Params []string `json:"params"` // A list of the missing parameters
}

type ModuleData struct {
	Name         string `json:"name"`
	Description  string `json:"description"`
	SupportLevel string `json:"support_level"`
	UseCount     int    `json:"use_count"`
	Status       string `json:"status"`
}

type ModuleHandle struct {
	// contains filtered or unexported fields
}

type Modules interface {
	Get(name string) *ModuleHandle

	List() ([]*ModuleHandle, error)

	Load(name string) error

	Reload(name string) error

	Unload(name string) error

	Data(name string) (ModuleData, error)
}

type OriginateRequest struct {
	Endpoint string `json:"endpoint"`           // Endpoint to use (tech/resource notation)
	Timeout  int    `json:"timeout,omitempty"`  // Dial Timeout in seconds (-1 = no limit)
	CallerID string `json:"callerId,omitempty"` // CallerID to set for outgoing call

	// One set of:
	Context   string `json:"context,omitempty"` // Drop the channel into the dialplan
	Extension string `json:"extension,omitempty"`
	Priority  int64  `json:"priority,omitempty"`
	// OR
	App     string `json:"app,omitempty"`     // Associate channel to Stasis (Ari) application
	AppArgs string `json:"appArgs,omitempty"` // Arguments to the application

	// Channel ID declarations
	ChannelID      string `json:"channelId,omitempty"`      // Optionally assign channel id
	OtherChannelID string `json:"otherChannelId,omitempty"` // Optionally assign second channel's id (only for local channels)

	Variables map[string]string `json:"variables,omitempty"` // Channel variables to set
}

type Peer struct {
	EventData
	Address    string `json:"address,omitempty"` // The IP address of the peer.
	Cause      string `json:"cause,omitempty"`   // An optional reason associated with the change in peer_status.
	PeerStatus string `json:"peer_status"`       // The current state of the peer. Note that the values of the status are dependent on the underlying peer technology.
	Port       string `json:"port,omitempty"`    // The port of the peer.
	Time       string `json:"time,omitempty"`    // The last known time the peer was contacted.
}

type PeerStatusChange struct {
	EventData
	Endpoint EndpointData `json:"endpoint"`
	Peer     Peer         `json:"peer"`
}

type Playback interface {

	// Get gets the handle to the given playbacl ID
	Get(id string) *PlaybackHandle

	// Data gets the playback data
	Data(id string) (PlaybackData, error)

	// Control performs the given operation on the current playback
	Control(id string, op string) error

	// Stop stops the playback
	Stop(id string) error

	// Subscribe subscribes on the playback events
	Subscribe(id string, n ...string) Subscription
}

type PlaybackContinuing struct {
	EventData
	Playback PlaybackData `json:"playback"` // Playback control object
}

type PlaybackData struct {
	ID        string `json:"id"` // Unique ID for this playback session
	Language  string `json:"language,omitempty"`
	MediaURI  string `json:"media_uri"`  // URI for the media which is to be played
	State     string `json:"state"`      // State of the playback operation
	TargetURI string `json:"target_uri"` // URI of the channel or bridge on which the media should be played (follows format of 'type':'name')
}

type PlaybackEvent interface {
	GetPlaybackIDs() []string
}

type PlaybackFinished struct {
	EventData
	Playback PlaybackData `json:"playback"` // Playback control object
}

type PlaybackHandle struct {
	// contains filtered or unexported fields
}

type PlaybackStarted struct {
	EventData
	Playback PlaybackData `json:"playback"` // Playback control object
}

type Playbacker interface {
	Playback() Playback
}

type RawMessage struct {
	// contains filtered or unexported fields
}

type Recording struct {
	Stored StoredRecording
	Live   LiveRecording
}

type RecordingEvent interface {
	GetRecordingIDs() []string
}

type RecordingFailed struct {
	EventData
	Recording LiveRecordingData `json:"recording"` // Recording control object
}

type RecordingFinished struct {
	EventData
	Recording LiveRecordingData `json:"recording"` // Recording control object
}

type RecordingOptions struct {
	// Format is the file format/encoding to which the recording should be stored.
	// This will usually be one of: slin, ulaw, alaw, wav, gsm.
	// If not specified, this will default to slin.
	Format string

	// MaxDuration is the maximum duration of the recording, after which the recording will
	// automatically stop.  If not set, there is no maximum.
	MaxDuration time.Duration

	// MaxSilence is the maximum duration of detected to be found before terminating the recording.
	MaxSilence time.Duration

	// Exists determines what should happen if the given recording already exists.
	// Valid values are: "fail", "overwrite", or "append".
	// If not specified, it will default to "fail"
	Exists string

	// Beep indicates whether a beep should be played to the recorded
	// party at the beginning of the recording.
	Beep bool

	// Terminate indicates whether the recording should be terminated on
	// receipt of a DTMF digit.
	// valid options are: "none", "any", "*", and "#"
	// If not specified, it will default to "none" (never terminate on DTMF).
	Terminate string
}

type RecordingStarted struct {
	EventData
	Recording LiveRecordingData `json:"recording"` // Recording control object
}

type Sender interface {
	Send(m *Message)
}

type SetID struct {
	Group string `json:"group"` // group id (not name? why string?)
	User  string `json:"user"`  // user id (not name? why string?)
}

type SnoopOptions struct {
	Direction string // Direction of audio to spy on (in, out, both)
	Whisper   string // Direction of audio to whisper into (in, out, both)
	AppArgs   string // The arguments to pass to the new application.
}

type Sound interface {

	// List returns available sounds limited by the provided filters.
	// Valid filters are "lang", "format", and nil (no filter)
	List(filters map[string]string) ([]*SoundHandle, error)

	// Get returns a handle pointer to the sound for further interaction
	Get(name string) *SoundHandle

	// Data returns the Sound's data
	Data(name string) (SoundData, error)
}

type SoundData struct {
	Formats []FormatLangPair `json:"formats"`
	ID      string           `json:"id"`
	Text    string           `json:"text,omitempty"`
}

type SoundHandle struct {
	// contains filtered or unexported fields
}

type StasisEnd struct {
	EventData
	Channel ChannelData `json:"channel"`
}

type StasisStart struct {
	EventData
	Args           []string    `json:"args"` // Arguments to the application
	Channel        ChannelData `json:"channel"`
	ReplaceChannel ChannelData `json:"replace_channel,omitempty"`
}

type StatusInfo struct {
	LastReloadTime DateTime `json:"last_reload_time"`
	StartupTime    DateTime `json:"startup_time"`
}

type StoredRecording interface {

	// List lists the recordings
	List() ([]*StoredRecordingHandle, error)

	// Get gets the Recording by type
	Get(name string) *StoredRecordingHandle

	// data gets the data for the stored recording
	Data(name string) (StoredRecordingData, error)

	// Copy copies the recording to the destination name
	Copy(name string, dest string) (*StoredRecordingHandle, error)

	// Delete deletes the recording
	Delete(name string) error
}

type StoredRecordingData struct {
	Format string `json:"format"`
	Name   string `json:"name"`
}

type StoredRecordingHandle struct {
	// contains filtered or unexported fields
}

type Subscriber interface {
	Subscribe(n ...string) Subscription
}

type Subscription interface {
	Events() chan Event
	Cancel()
}

type SystemInfo struct {
	EntityID string `json:"entity_id"`
	Version  string `json:"version"`
}

type TextMessage interface {

	// Send() sends a text message to an endpoint
	Send(from, tech, resource, body string, vars map[string]string) error

	// SendByURI sends a text message to an endpoint by free-form URI
	SendByURI(from, to, body string, vars map[string]string) error
}

type TextMessageData struct {
	Body      string                `json:"body"` // The body (text) of the message
	From      string                `json:"from"` // Technology-specific source URI
	To        string                `json:"to"`   // Technology-specific destination URI
	Variables []TextMessageVariable `json:"variables,omitempty"`
}

type TextMessageReceived struct {
	EventData
	Endpoint EndpointData    `json:"endpoint,omitempty"`
	Message  TextMessageData `json:"message"`
}

type TextMessageVariable struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type Variables interface {

	// Get returns the value of the given variable
	Get(variable string) (string, error)

	// Set sets the variable
	Set(variable string, value string) error
}