@de./sdk 1.0.0

package/dist/allend/MSI/Controls.js

@@ -0,0 +1,763 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FUNCTION_EVENT_TIMEOUT = 12000, FUNCTION_EVENT_TIMEOUT_MESSAGE = 'Event timeout';
+var Controls = /** @class */ (function () {
+    function Controls(chn, options) {
+        this.chn = chn;
+        this.options = options;
+    }
+    /**
+     * Listen to MSI events
+     */
+    Controls.prototype.on = function (event, listener) {
+        this.chn.on(event, listener);
+    };
+    /**
+     * Remove a listener of MSI events
+     */
+    Controls.prototype.off = function (event, listener) {
+        this.chn.off(event, listener);
+    };
+    /**
+     * Remove all listen of MSI events
+     */
+    Controls.prototype.removeListeners = function (listener) {
+        this.chn.removeListeners(listener);
+    };
+    /**
+     * Refresh access token to remove server
+     *
+     * @param token - Latest access token
+     */
+    Controls.prototype.refreshToken = function (token) {
+        if (!token)
+            return;
+        this.options.accessToken = token;
+    };
+    /**
+     * Update map style
+     *
+     * @param style - Map style ID
+     */
+    Controls.prototype.setMapStyle = function (style) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Set style
+            _this.chn.emit('set:map:style', style, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * @return - User's current GPS location
+     */
+    Controls.prototype.getCurrentLocation = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Get current location
+            _this.chn.emit('get:current:location', function (error, location) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve(location);
+            });
+        });
+    };
+    /**
+     * Pin user's current location on the current active map
+     *
+     * @return - User's current GPS location coordinates or `null` when it failed
+     */
+    Controls.prototype.pinCurrentLocation = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Pin user's current location on the map
+            _this.chn.emit('pin:current:location', function (error, location) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve(location);
+            });
+        });
+    };
+    /**
+     * Set live location tracking options
+     *
+     * @param options - User location tracking options
+     */
+    Controls.prototype.setLiveLocationOptions = function (options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Set live location options
+            _this.chn.emit('set:live:options', options, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Start tracking user's live location
+     */
+    Controls.prototype.trackLiveLocation = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Start live location tracking
+            _this.chn.emit('track:live:location', function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Stop tracking user's live location
+     */
+    Controls.prototype.untrackLiveLocation = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Stop live location tracking
+            _this.chn.emit('untrack:live:location', function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Enable drag pick functionality
+     *
+     * @param location - (Optional) Initial location for drag pick
+     */
+    Controls.prototype.enableDragPickLocation = function (location) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Enable drag pick
+            _this.chn.emit('enable:dragpick:location', location, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Disable drag pick functionality
+     */
+    Controls.prototype.disableDragPickLocation = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Disable drag pick
+            _this.chn.emit('disable:dragpick:location', function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Set drag pick content
+     *
+     * @param type - Content type for drag pick
+     * @param content - Content data for drag pick
+     */
+    Controls.prototype.setDragPickContent = function (type, content) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Set drag pick content
+            _this.chn.emit('set:dragpick:content', { type: type, content: content }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Get a location coordinates of placed that matched this name
+     *
+     * @param name - Place name to resolve
+     * @return - Array list of coordinates
+     */
+    Controls.prototype.resolvePlace = function (name) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Get location coordinates from place name
+            _this.chn.emit('resolve:place', name, function (error, data) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve(data);
+            });
+        });
+    };
+    /**
+     * Get a location details of placed that matched this coordinates
+     *
+     * @param coords - Coordinates
+     * @return - Array list of geocoding data
+     */
+    Controls.prototype.resolveCoordinates = function (coords) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Get location place from coordinates
+            _this.chn.emit('resolve:coordinates', coords, function (error, data) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve(data);
+            });
+        });
+    };
+    /**
+     * Search a location or places
+     *
+     * @param input - Place in string
+     * @return - Autocompletion list matched places
+     */
+    Controls.prototype.searchQuery = function (input) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Launch search query
+            _this.chn.emit('search:query', input, function (error, data) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve(data);
+            });
+        });
+    };
+    /**
+     * Select a suggested place by the search
+     *
+     * @param index - Index of place in suggested list
+     * @return - More details of selected place
+     */
+    Controls.prototype.searchSelect = function (index) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Get place's details
+            _this.chn.emit('search:select', index, function (error, data) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve(data);
+            });
+        });
+    };
+    /**
+     * Show nearby entities around coordinates
+     *
+     * @param list - Array of entity specifications
+     */
+    Controls.prototype.showNearby = function (list) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Show nearby entities
+            _this.chn.emit('show:nearby', list, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Remove all displaying nearby entities
+     */
+    Controls.prototype.removeNearby = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Remove nearby entities
+            _this.chn.emit('remove:nearby', function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Add a new nearby entity
+     *
+     * @param entity - Entity specification
+     */
+    Controls.prototype.addNearbyEntity = function (entity) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Add nearby entity
+            _this.chn.emit('add:nearby:entity', entity, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Update a nearby entity position
+     *
+     * @param activePosition - Entity ID and new position
+     */
+    Controls.prototype.moveNearbyEntity = function (activePosition) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Move nearby entity
+            _this.chn.emit('move:nearby:entity', activePosition, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Remove a nearby entity
+     *
+     * @param id - Entity ID to remove
+     */
+    Controls.prototype.removeNearbyEntity = function (id) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Remove nearby entity
+            _this.chn.emit('remove:nearby:entity', id, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Set complete route with journey specifications
+     *
+     * @param journey - Journey specifications including route ID, origin, destination, waypoints, and options
+     */
+    Controls.prototype.setRoute = function (journey) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Set route
+            _this.chn.emit('set:route', journey, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Set route origin
+     *
+     * @param routeId - Route identifier
+     * @param point - Waypoint specification for origin
+     */
+    Controls.prototype.setRouteOrigin = function (routeId, point) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Set route origin
+            _this.chn.emit('set:route:origin', { routeId: routeId, point: point }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Remove route origin
+     *
+     * @param routeId - Route identifier
+     */
+    Controls.prototype.removeRouteOrigin = function (routeId) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Remove route origin
+            _this.chn.emit('remove:route:origin', { routeId: routeId }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Set route destination
+     *
+     * @param routeId - Route identifier
+     * @param point - Waypoint specification for destination
+     */
+    Controls.prototype.setRouteDestination = function (routeId, point) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Set route destination
+            _this.chn.emit('set:route:destination', { routeId: routeId, point: point }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Remove route destination
+     *
+     * @param routeId - Route identifier
+     */
+    Controls.prototype.removeRouteDestination = function (routeId) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Remove route destination
+            _this.chn.emit('remove:route:destination', { routeId: routeId }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Add a route waypoint
+     *
+     * @param routeId - Route identifier
+     * @param point - Waypoint specification
+     */
+    Controls.prototype.addRouteWaypoint = function (routeId, point) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Add route waypoint
+            _this.chn.emit('add:route:waypoint', { routeId: routeId, point: point }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Update a route waypoint
+     *
+     * @param routeId - Route identifier
+     * @param point - Waypoint specification with index
+     */
+    Controls.prototype.updateRouteWaypoint = function (routeId, point) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Update route waypoint
+            _this.chn.emit('update:route:waypoint', { routeId: routeId, point: point }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Remove a route waypoint
+     *
+     * @param routeId - Route identifier
+     * @param index - Waypoint index to remove
+     */
+    Controls.prototype.removeRouteWaypoint = function (routeId, index) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Remove route waypoint
+            _this.chn.emit('remove:route:waypoint', { routeId: routeId, index: index }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Fit route bounds
+     *
+     * @param routeId - Route identifier
+     * @param margin - Margin in px
+     */
+    Controls.prototype.fitRouteBounds = function (routeId, margin) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            _this.chn.emit('fit:route:bounds', { routeId: routeId, margin: margin }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Fit all/many routes bounds
+     *
+     * @param options - Routes fit bounds options
+     */
+    Controls.prototype.fitRoutesBounds = function (options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            _this.chn.emit('fit:routes:bounds', options, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Set waypoint caption
+     *
+     * @param routeId - Route identifier
+     * @param id - Waypoint identifier (string or number)
+     * @param caption - Caption information to set
+     */
+    Controls.prototype.setWaypointCaption = function (routeId, id, caption) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Set waypoint caption
+            _this.chn.emit('set:waypoint:caption', { routeId: routeId, id: id, caption: caption }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Update waypoint caption
+     *
+     * @param routeId - Route identifier
+     * @param id - Waypoint identifier (string or number)
+     * @param caption - Caption information to update
+     */
+    Controls.prototype.updateWaypointCaption = function (routeId, id, caption) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Update waypoint caption
+            _this.chn.emit('update:waypoint:caption', { routeId: routeId, id: id, caption: caption }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Remove waypoint caption
+     *
+     * @param routeId - Route identifier
+     * @param id - Waypoint identifier (string or number)
+     */
+    Controls.prototype.removeWaypointCaption = function (routeId, id) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Remove waypoint caption
+            _this.chn.emit('remove:waypoint:caption', { routeId: routeId, id: id }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Mount navigation route
+     *
+     * @param routeId - Route identifier for navigation
+     */
+    Controls.prototype.mountNavigation = function (routeId) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Mount navigation
+            _this.chn.emit('mount:navigation', routeId, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Unmount navigation route
+     */
+    Controls.prototype.unmountNavigation = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Unmount navigation
+            _this.chn.emit('unmount:navigation', function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Load navigation direction
+     */
+    Controls.prototype.loadNavigation = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Load navigation
+            _this.chn.emit('load:navigation', function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Set initial navigation position
+     *
+     * @param position - Initial GPS location for navigation
+     */
+    Controls.prototype.setInitialNavigationPosition = function (position) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Set initial navigation position
+            _this.chn.emit('initial:navigation:position', position, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Navigate to new position
+     *
+     * @param position - Current GPS location for navigation update
+     */
+    Controls.prototype.navigate = function (position) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Navigate
+            _this.chn.emit('navigate:navigation:direction', position, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Upsert navigation direction data
+     *
+     * @param routeId - Route identifier for navigation
+     * @param direction - Direction data
+     * @param position - (Optional) Current GPS position
+     * @params options - Route options
+     */
+    Controls.prototype.casting = function (routeId, direction, position, options) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Casting navigation direction
+            _this.chn.emit('casting:navigation:direction', { routeId: routeId, direction: direction, position: position, options: options }, function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    /**
+     * Dismiss navigation
+     */
+    Controls.prototype.dismissNavigation = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            // Set timeout
+            var timeout = setTimeout(function () { return reject(FUNCTION_EVENT_TIMEOUT_MESSAGE); }, FUNCTION_EVENT_TIMEOUT);
+            // Dismiss navigation
+            _this.chn.emit('dismiss:navigation', function (error) {
+                if (error)
+                    return reject(error);
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    };
+    return Controls;
+}());
+exports.default = Controls;
+//# sourceMappingURL=Controls.js.map