@gibme/asterisk-gateway-interface 1.0.1

package/dist/channel.js

@@ -0,0 +1,1033 @@
+"use strict";
+// Copyright (c) 2016-2022 Brandon Lehmann
+//
+// Please see the included LICENSE file for more information.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+const util_1 = require("util");
+const types_1 = require("./types");
+const response_arguments_1 = __importDefault(require("./response_arguments"));
+/**
+ * Represents an AGI Channel
+ */
+class Channel extends events_1.EventEmitter {
+    /**
+     * Creates a new instance of a channel object
+     * @param connection the AGI socket connection
+     */
+    constructor(connection) {
+        super();
+        this.m_message = '';
+        this.m_network = '';
+        this.m_network_script = '';
+        this.m_request = '';
+        this.m_channel = '';
+        this.m_language = '';
+        this.m_type = '';
+        this.m_uniqueid = '';
+        this.m_version = '';
+        this.m_callerid = '';
+        this.m_calleridname = '';
+        this.m_callingpres = '';
+        this.m_callingani2 = '';
+        this.m_callington = '';
+        this.m_callingtns = '';
+        this.m_dnid = '';
+        this.m_rdnis = '';
+        this.m_context = '';
+        this.m_extension = '';
+        this.m_priority = '';
+        this.m_enhanced = '';
+        this.m_accountcode = '';
+        this.m_threadid = '';
+        this.setMaxListeners(10);
+        this.m_connection = connection;
+        this.m_state = types_1.ContextState.INIT;
+        this.m_connection.on('data', (data) => this.read(data));
+        this.m_connection.on('close', () => this.emit('close'));
+        this.m_connection.on('error', (error) => this.emit('error', error));
+        this.m_connection.on('timeout', () => this.emit('timeout'));
+        this.on('hangup', () => this.close());
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    /**
+     * Whether this AGI request is over the network
+     */
+    get network() {
+        return (this.m_network.toLowerCase() === 'yes');
+    }
+    /**
+     * The network path included in the AGI request
+     * ie. agi://127.0.0.1:3000/test
+     * This value would return 'test'
+     */
+    get network_script() {
+        return this.m_network_script;
+    }
+    /**
+     * The version of Asterisk
+     */
+    get version() {
+        return this.m_version;
+    }
+    /**
+     * The filename of your script
+     * ie. agi
+     */
+    get request() {
+        return this.m_request;
+    }
+    /**
+     * The originating channel (your phone)
+     */
+    get channel() {
+        return this.m_channel;
+    }
+    /**
+     * The language code (e.g. “en”)
+     */
+    get language() {
+        return this.m_language;
+    }
+    /**
+     * The originating channel type (e.g. “SIP” or “ZAP”)
+     */
+    get type() {
+        return this.m_type;
+    }
+    /**
+     * A unique ID for the call
+     */
+    get uniqueid() {
+        return this.m_uniqueid;
+    }
+    /**
+     * The caller ID number (or “unknown”)
+     */
+    get callerid() {
+        return this.m_callerid;
+    }
+    /**
+     * The caller ID name (or “unknown”)
+     */
+    get calleridname() {
+        return this.m_calleridname;
+    }
+    /**
+     * The presentation for the callerid in a ZAP channel
+     */
+    get callingpres() {
+        return this.m_callingpres;
+    }
+    /**
+     * The number which is defined in ANI2 see Asterisk Detailed Variable List (only for PRI Channels)
+     */
+    get callingani2() {
+        return this.m_callingani2;
+    }
+    /**
+     *  The type of number used in PRI Channels see Asterisk Detailed Variable List
+     */
+    get callington() {
+        return this.m_callington;
+    }
+    /**
+     * An optional 4 digit number (Transit Network Selector) used in PRI Channels see Asterisk Detailed Variable List
+     */
+    get callingtns() {
+        return this.m_callingtns;
+    }
+    /**
+     * The dialed number id (or “unknown”)
+     */
+    get dnid() {
+        return this.m_dnid;
+    }
+    /**
+     * The referring DNIS number (or “unknown”)
+     */
+    get rdnis() {
+        return this.m_rdnis;
+    }
+    /**
+     * Origin context in extensions.conf
+     */
+    get context() {
+        return this.m_context;
+    }
+    /**
+     * The called number
+     */
+    get extension() {
+        return this.m_extension;
+    }
+    /**
+     * The priority it was executed as in the dial plan
+     */
+    get priority() {
+        return this.m_priority;
+    }
+    /**
+     * The flag value is 1.0 if started as an EAGI script, 0.0 otherwise
+     */
+    get enhanced() {
+        return this.m_enhanced;
+    }
+    /**
+     * Account code of the origin channel
+     */
+    get accountcode() {
+        return this.m_accountcode;
+    }
+    /**
+     * Thread ID of the AGI script
+     */
+    get threadid() {
+        return this.m_threadid;
+    }
+    /**
+     * Answers channel if not already in answer state.
+     */
+    answer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand('ANSWER');
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not answer call');
+            }
+        });
+    }
+    /**
+     * Interrupts expected flow of Async AGI commands and returns control to
+     * previous source (typically, the PBX dialplan).
+     */
+    break() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand('ASYNCAGI BREAK');
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not interrupt processing');
+            }
+            return this.close();
+        });
+    }
+    /**
+     * Returns status of the connected channel.
+     * @param channel
+     */
+    channelStatus(channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('CHANNEL STATUS %s', channel || ''));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not get channel status');
+            }
+            return response.result;
+        });
+    }
+    /**
+     * Sends audio file on channel and allows the listener to control the stream.
+     * @param filename
+     * @param escapeDigits
+     * @param skipms
+     * @param fastForwardCharacter
+     * @param rewindCharacter
+     * @param pauseCharacter
+     */
+    controlStreamFile(filename, escapeDigits = '', skipms, fastForwardCharacter, rewindCharacter, pauseCharacter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('CONTROL STREAM FILE %s "%s" %s %s %s %s', filename, escapeDigits, skipms || '', fastForwardCharacter || '', rewindCharacter || '', pauseCharacter || ''));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not control stream file');
+            }
+            const playbackStatus = yield this.getVariable('CPLAYBACKSTATUS ');
+            const playbackOffset = yield this.getVariable('CPLAYBACKOFFSET ');
+            let status = types_1.PlaybackStatus.ERROR;
+            switch (playbackStatus.toUpperCase()) {
+                case 'SUCCESS':
+                    status = types_1.PlaybackStatus.SUCCESS;
+                    break;
+                case 'USERSTOPPED':
+                    status = types_1.PlaybackStatus.USER_STOPPED;
+                    break;
+                case 'REMOTESTOPPED':
+                    status = types_1.PlaybackStatus.REMOTE_STOPPED;
+                    break;
+            }
+            return {
+                digit: response.arguments.char('result'),
+                playbackStatus: status,
+                playbackOffset: parseInt(playbackOffset, 10)
+            };
+        });
+    }
+    /**
+     * Attempts to establish a new outgoing connection on a channel, and then link it to the calling input channel.
+     * @param target
+     * @param timeout
+     * @param params
+     */
+    dial(target, timeout = 30, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.exec('Dial', (0, util_1.format)('%s,%s,%s', target, timeout, params || ''));
+            const dialstatus = yield this.getVariable('DIALSTATUS');
+            switch (dialstatus.toUpperCase()) {
+                case 'ANSWER':
+                    return types_1.DialStatus.ANSWER;
+                case 'BUSY':
+                    return types_1.DialStatus.BUSY;
+                case 'NOANSWER':
+                    return types_1.DialStatus.NOANSWER;
+                case 'CANCEL':
+                    return types_1.DialStatus.CANCEL;
+                case 'CONGESTION':
+                    return types_1.DialStatus.CONGESTION;
+                case 'CHANUNAVAIL':
+                    return types_1.DialStatus.CHANUNAVAIL;
+                case 'DONTCALL':
+                    return types_1.DialStatus.DONTCALL;
+                case 'TORTURE':
+                    return types_1.DialStatus.TORTURE;
+                case 'INVALIDARGS':
+                    return types_1.DialStatus.INVALIDARGS;
+                default:
+                    throw new Error('Unknown dial status');
+            }
+        });
+    }
+    /**
+     * Deletes an entry in the Asterisk database for a given family and key.
+     * @param family
+     * @param key
+     */
+    databaseDel(family, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('DATABASE DEL %s %s', family, key));
+            if (response.code !== 200 || response.result === 0) {
+                throw new Error('Could not delete from the database');
+            }
+        });
+    }
+    /**
+     * Deletes a family or specific keytree within a family in the Asterisk database.
+     * @param family
+     * @param keyTree
+     */
+    databaseDelTree(family, keyTree) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('DATABASE DELTREE %s %s', family, keyTree || ''));
+            if (response.code !== 200) {
+                throw new Error('Could not delete tree from database');
+            }
+            return (response.result === 0);
+        });
+    }
+    /**
+     * Retrieves an entry in the Asterisk database for a given family and key.
+     * @param family
+     * @param key
+     */
+    databaseGet(family, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('DATABASE GET %s %s', family, key));
+            if (response.code !== 200 || response.result === 0) {
+                throw new Error('Database key not set');
+            }
+            return response.arguments.nokey();
+        });
+    }
+    /**
+     * Adds or updates an entry in the Asterisk database for a given family, key, and value.
+     * @param family
+     * @param key
+     * @param value
+     */
+    databasePut(family, key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('DATABASE PUT %s %s %s', family, key, value));
+            if (response.code !== 200 || response.result === 0) {
+                throw new Error('Database key not set');
+            }
+            return response.arguments.string('value');
+        });
+    }
+    /**
+     * Executes application with given options
+     * @param application.
+     * @param args
+     */
+    exec(application, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('EXEC %s %s', application, args.join(' ')));
+            if (response.code !== 200 || response.result === -2) {
+                throw new Error('Could not execute application');
+            }
+            return response.result;
+        });
+    }
+    /**
+     * Stream the given file, and receive DTMF data.
+     * @param soundFile
+     * @param timeout
+     * @param maxDigits
+     */
+    getData(soundFile, timeout = 5, maxDigits) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('GET DATA %s %s %s', soundFile, timeout * 1000, maxDigits || ''));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not get data from channel');
+            }
+            return {
+                digits: response.arguments.string('result'),
+                timeout: (response.arguments.string('value') === '(timeout)')
+            };
+        });
+    }
+    /**
+     * Evaluates a channel expression
+     * Understands complex variable names and builtin variables, unlike GET VARIABLE.
+     * @param key
+     * @param channel
+     */
+    getFullVariable(key, channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('GET FULL VARIABLE %s %s', key.toUpperCase(), channel || ''));
+            if (response.code !== 200 || response.result === 0) {
+                throw new Error('Variable not set');
+            }
+            return response.arguments.nokey();
+        });
+    }
+    /**
+     * Stream file, prompt for DTMF, with timeout.
+     * Behaves similar to STREAM FILE but used with a timeout option.
+     * @param soundFile
+     * @param escapeDigits
+     * @param timeout
+     */
+    getOption(soundFile, escapeDigits = '#', timeout = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('GET OPTION %s "%s" %s', soundFile, escapeDigits, timeout * 1000));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not get option');
+            }
+            if (response.arguments.number('endpos') === 0) {
+                throw new Error('Could Not play file');
+            }
+            return {
+                digit: response.arguments.char('result'),
+                endpos: response.arguments.number('endpos')
+            };
+        });
+    }
+    /**
+     * Gets a channel variable.
+     * @param key
+     */
+    getVariable(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('GET VARIABLE %s', key.toUpperCase()));
+            if (response.code !== 200 || response.result === 0) {
+                throw new Error('Variable not set');
+            }
+            return response.arguments.nokey();
+        });
+    }
+    /**
+     * Cause the channel to execute the specified dialplan subroutine.
+     * @param context
+     * @param extension
+     * @param priority
+     * @param argument
+     */
+    goSub(context, extension, priority, argument) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('GOSUB %s %s %s %s', context, extension, priority, argument || ''));
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not execute gosub');
+            }
+        });
+    }
+    /**
+     * Hangs up the specified channel. If no channel name is given, hangs up the current channel
+     * @param channel
+     */
+    hangup(channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('HANGUP %s', channel || ''));
+            if (response.code !== 200 || response.result !== 1) {
+                throw new Error('Could not hang up call');
+            }
+        });
+    }
+    /**
+     * Does nothing
+     */
+    noop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand('NOOP');
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not NOOP');
+            }
+        });
+    }
+    /**
+     * Receives one character from channels supporting it.
+     * @param timeout
+     */
+    receiveChar(timeout = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('RECEIVE CHAR %s', timeout * 1000));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not get data from channel');
+            }
+            return {
+                char: response.arguments.char('result'),
+                timeout: response.arguments.boolean('timeout')
+            };
+        });
+    }
+    /**
+     * Receives text from channels supporting it.
+     * @param timeout
+     */
+    receiveText(timeout = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('RECEIVE TEXT %s', timeout * 1000));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not get data from channel');
+            }
+            return response.arguments.string('result');
+        });
+    }
+    /**
+     * Records to a given file.
+     * @param filename
+     * @param fileFormat
+     * @param escapeDigits
+     * @param timeout
+     * @param beep
+     * @param silence
+     * @param offsetSamples
+     */
+    recordFile(filename, fileFormat = 'gsm', escapeDigits = '#', timeout = 10, beep, silence, offsetSamples) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('RECORD FILE %s %s "%s" %s %s %s %s', filename, fileFormat, escapeDigits, timeout * 1000, offsetSamples || '', (beep) ? 'BEEP' : '', (silence) ? (0, util_1.format)('s=%s', silence) : ''));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not record file');
+            }
+            return {
+                digit: response.arguments.char('result'),
+                endpos: response.arguments.number('endpos'),
+                timeout: response.arguments.boolean('timeout')
+            };
+        });
+    }
+    /**
+     * Says a given character string.
+     * @param value
+     * @param escapeDigits
+     */
+    sayAlpha(value, escapeDigits = '#') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SAY ALPHA %s "%s"', value, escapeDigits));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not say alpha');
+            }
+            return response.arguments.char('result');
+        });
+    }
+    /**
+     * Says a given date.
+     * @param value
+     * @param escapeDigits
+     */
+    sayDate(value, escapeDigits = '#') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SAY DATE %s "%s"', (typeof value === 'number') ? value : Math.floor(value.getTime() / 1000), escapeDigits));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not say date');
+            }
+            return response.arguments.char('result');
+        });
+    }
+    /**
+     * Says a given time as specified by the format given.
+     * @param value
+     * @param escapeDigits
+     * @param dateFormat
+     * @param timezone
+     */
+    sayDateTime(value, escapeDigits = '#', dateFormat, timezone) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SAY DATETIME %s "%s" %s %s', (typeof value === 'number') ? value : Math.floor(value.getTime() / 1000), escapeDigits, dateFormat || '', timezone || ''));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not say date time');
+            }
+            return response.arguments.char('result');
+        });
+    }
+    /**
+     * Says a given digit string.
+     * @param value
+     * @param escapeDigits
+     */
+    sayDigits(value, escapeDigits = '#') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SAY DIGITS %s "%s"', value, escapeDigits));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not say digits');
+            }
+            return response.arguments.char('result');
+        });
+    }
+    /**
+     * Says a given number.
+     * @param value
+     * @param escapeDigits
+     */
+    sayNumber(value, escapeDigits = '#') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SAY NUMBER %s "%s"', value, escapeDigits));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not say number');
+            }
+            return response.arguments.char('result');
+        });
+    }
+    /**
+     * Says a given character string with phonetics.
+     * @param value
+     * @param escapeDigits
+     */
+    sayPhonetic(value, escapeDigits = '#') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SAY PHONETIC %s "%s"', value, escapeDigits));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not say phonetic');
+            }
+            return response.arguments.char('result');
+        });
+    }
+    /**
+     * Says a given time.
+     * @param value
+     * @param escapeDigits
+     */
+    sayTime(value, escapeDigits = '#') {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SAY TIME %s "%s"', (typeof value === 'number') ? value : Math.floor(value.getTime() / 1000), escapeDigits));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not say time');
+            }
+            return response.arguments.char('result');
+        });
+    }
+    /**
+     * Sends images to channels supporting it.
+     * @param image
+     */
+    sendImage(image) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SEND IMAGE %s', image));
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not send image');
+            }
+        });
+    }
+    /**
+     * Sends text to channels supporting it.
+     * @param text
+     */
+    sendText(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SEND TEXT "%s"', text));
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not send text');
+            }
+        });
+    }
+    /**
+     * Autohangup channel in some time.
+     * @param timeout
+     */
+    setAutoHangup(timeout = 60) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SET AUTOHANGUP %s', timeout));
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not set auto hangup');
+            }
+        });
+    }
+    /**
+     * Sets callerid for the current channel.
+     * @param callerNumber
+     * @param callerName
+     */
+    setCallerID(callerNumber, callerName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const callerid = (callerName)
+                ? (0, util_1.format)('"%s"<%s>', callerName, callerNumber)
+                : callerNumber;
+            const response = yield this.sendCommand((0, util_1.format)('SET CALLERID %s', callerid));
+            if (response.code !== 200 || response.result !== 1) {
+                throw new Error('Could not set caller id');
+            }
+        });
+    }
+    /**
+     * Sets channel context.
+     * @param context
+     */
+    setContext(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SET CONTEXT %s', context));
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not set context');
+            }
+        });
+    }
+    /**
+     * Changes channel extension.
+     * @param extension
+     */
+    setExtension(extension) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SET EXTENSION %s', extension));
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not set extension');
+            }
+        });
+    }
+    /**
+     * Enable/Disable Music on hold generator
+     * @param status
+     * @param musicClass
+     */
+    setMusic(status = true, musicClass) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SET MUSIC %s %s', (status) ? 'ON' : 'OFF', musicClass || ''));
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not set priority');
+            }
+        });
+    }
+    /**
+     * Set channel dialplan priority.
+     * @param priority
+     */
+    setPriority(priority) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SET PRIORITY %s', priority));
+            if (response.code !== 200 || response.result !== 0) {
+                throw new Error('Could not set priority');
+            }
+        });
+    }
+    /**
+     * Set channel dialplan priority.
+     * @param key
+     * @param value
+     */
+    setVariable(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('SET VARIABLE %s "%s"', key.toUpperCase(), value));
+            if (response.code !== 200 || response.result !== 1) {
+                throw new Error('Could not set variable');
+            }
+        });
+    }
+    speechActivateGrammar(grammar) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Handle the response
+            return this.sendCommand((0, util_1.format)('SPEECH ACTIVATE GRAMMAR %s', grammar));
+        });
+    }
+    speechCreate(engine) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Handle the response
+            return this.sendCommand((0, util_1.format)('SPEECH CREATE ENGINE %s', engine));
+        });
+    }
+    speechDeactivateGrammar(grammar) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Handle the response
+            return this.sendCommand((0, util_1.format)('SPEECH DEACTIVATE GRAMMAR %s', grammar));
+        });
+    }
+    speechDestroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Handle the response
+            return this.sendCommand('SPEECH DESTROY');
+        });
+    }
+    speechLoadGrammar(grammar, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Handle the response
+            return this.sendCommand((0, util_1.format)('SPEECH LOAD GRAMMAR %s %s', grammar, path));
+        });
+    }
+    speechRecognize(soundFile, timeout = 5, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Handle the response
+            return this.sendCommand((0, util_1.format)('SPEECH RECOGNIZE %s %s %s', soundFile, timeout * 1000, offset));
+        });
+    }
+    speechSet(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Handle the response
+            return this.sendCommand((0, util_1.format)('SPEECH SET %s %s', key, value));
+        });
+    }
+    speedUnloadGrammar(grammar) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: Handle the response
+            return this.sendCommand((0, util_1.format)('SPEECH UNLOAD GRAMMAR %s', grammar));
+        });
+    }
+    /**
+     * Sends audio file on channel.
+     * @param filename
+     * @param escapeDigits
+     * @param offset
+     */
+    streamFile(filename, escapeDigits = '#', offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('STREAM FILE %s "%s" %s', filename, escapeDigits, offset || ''));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not stream file');
+            }
+            const status = yield this.getVariable('PLAYBACKSTATUS ');
+            if (status.toUpperCase() !== 'SUCCESS') {
+                throw new Error('Could not stream file');
+            }
+            return {
+                digit: response.arguments.char('result'),
+                endpos: response.arguments.number('endpos')
+            };
+        });
+    }
+    /**
+     * Toggles TDD mode (for the deaf).
+     * @param status
+     */
+    tddMode(status) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('TDD MODE %s', (status) ? 'ON' : 'OFF'));
+            if (response.code !== 200 || response.result !== 1) {
+                throw new Error('Could not set TDD mode');
+            }
+        });
+    }
+    /**
+     * Logs a message to the asterisk verbose log.
+     * @param message
+     * @param level
+     */
+    verbose(message, level) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('VERBOSE "%s" %s', message, level || ''));
+            if (response.code !== 200 || response.result !== 1) {
+                throw new Error('Could not send logging message');
+            }
+        });
+    }
+    /**
+     * Waits for a digit to be pressed.
+     * @param timeout
+     */
+    waitForDigit(timeout = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.sendCommand((0, util_1.format)('WAIT FOR DIGIT %s', timeout * 1000));
+            if (response.code !== 200 || response.result === -1) {
+                throw new Error('Could not wait for digit');
+            }
+            return response.arguments.char('result');
+        });
+    }
+    /* Internal Methods */
+    close() {
+        this.m_connection.destroy();
+    }
+    read(data) {
+        if (data.length === 0) {
+            return;
+        }
+        this.m_message += data.toString();
+        if (this.m_state === types_1.ContextState.INIT) {
+            if (this.m_message.indexOf('\n\n') === -1) {
+                return;
+            }
+            this.readVariables(this.m_message);
+        }
+        else if (this.m_state === types_1.ContextState.WAITING) {
+            if (this.m_message.indexOf('\n') === -1) {
+                return;
+            }
+            this.readResponse(this.m_message);
+        }
+        this.m_message = '';
+    }
+    handleVariable(id, value) {
+        switch (id) {
+            case 'network':
+                this.m_network = value;
+                break;
+            case 'network_script':
+                this.m_network_script = value;
+                break;
+            case 'request':
+                this.m_request = value;
+                break;
+            case 'channel':
+                this.m_channel = value;
+                break;
+            case 'language':
+                this.m_language = value;
+                break;
+            case 'type':
+                this.m_type = value;
+                break;
+            case 'uniqueid':
+                this.m_uniqueid = value;
+                break;
+            case 'version':
+                this.m_version = value;
+                break;
+            case 'callerid':
+                this.m_callerid = value;
+                break;
+            case 'calleridname':
+                this.m_calleridname = value;
+                break;
+            case 'callingpres':
+                this.m_callingpres = value;
+                break;
+            case 'callingani2':
+                this.m_callingani2 = value;
+                break;
+            case 'callington':
+                this.m_callington = value;
+                break;
+            case 'callingtns':
+                this.m_callingtns = value;
+                break;
+            case 'dnid':
+                this.m_dnid = value;
+                break;
+            case 'rdnis':
+                this.m_rdnis = value;
+                break;
+            case 'context':
+                this.m_context = value;
+                break;
+            case 'extension':
+                this.m_extension = value;
+                break;
+            case 'priority':
+                this.m_priority = value;
+                break;
+            case 'enhanced':
+                this.m_enhanced = value;
+                break;
+            case 'accountcode':
+                this.m_accountcode = value;
+                break;
+            case 'threadid':
+                this.m_threadid = value;
+                break;
+            default:
+        }
+    }
+    readVariables(message) {
+        message.split('\n')
+            .forEach(line => {
+            const split = line.split(':');
+            const name = (split[0] || '').trim();
+            const value = (split[1] || '').trim();
+            const id = name.substring(4);
+            this.handleVariable(id, value);
+        });
+        this.m_state = types_1.ContextState.WAITING;
+        this.emit('ready');
+    }
+    readResponse(message) {
+        const lines = message.split('\n');
+        lines.map((line) => this.readResponseLine(line));
+    }
+    readResponseLine(line) {
+        if (!line) {
+            return;
+        }
+        this.emit('recv', line);
+        const parsed = line.split(' ');
+        if (!parsed || parsed[0] === 'HANGUP') {
+            return this.emit('hangup');
+        }
+        const code = parseInt(parsed[0], 10);
+        parsed.shift();
+        const args = new response_arguments_1.default();
+        for (const value of parsed) {
+            if (value.indexOf('=') !== -1) {
+                const parts = value.split('=', 2);
+                const key = parts[0].trim();
+                const val = parts[1].trim();
+                args.addArgument(key, val);
+            }
+            else if (value.indexOf('(') !== -1) {
+                const name = value.substring(1, value.length - 1);
+                args.addArgument(name, true);
+            }
+            else {
+                args.addArgument('value', value);
+            }
+        }
+        const response = {
+            code,
+            result: args.number('result'),
+            arguments: args
+        };
+        this.emit('response', response);
+    }
+    send(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.emit('send', message);
+                this.m_connection.write(message, (error) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    return resolve();
+                });
+            });
+        });
+    }
+    sendCommand(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const handleResponse = (response) => {
+                    this.removeListener('response', handleResponse);
+                    return resolve(response);
+                };
+                this.once('response', handleResponse);
+                this.send((0, util_1.format)('%s\n', command.trim()))
+                    .catch(error => {
+                    this.removeListener('response', handleResponse);
+                    return reject(error);
+                });
+            });
+        });
+    }
+}
+exports.default = Channel;