@gibme/mikrotik 1.1.2 → 2.0.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import SSH from '@gibme/ssh';
 import { BandwidthTest, Response } from './types';
 import Cache from '@gibme/cache/memory';
-export { ConnectConfig } from '@gibme/ssh';
+export type { ConnectConfig } from '@gibme/ssh';
 export type Direction = BandwidthTest.Direction;
 export type Protocol = BandwidthTest.Protocol;
 export type Status = BandwidthTest.Status;
@@ -9,10 +9,14 @@ export type Update = BandwidthTest.Update;
 export type Options = BandwidthTest.Options;
 export type Address = Response.Address;
 export type Interface = Response.Interface;
+export type Tunnel = Response.Tunnel;
 export type Route = Response.Route;
 export type RouteCount = Response.RouteCount;
 export type Ping = Response.Ping;
 export type Traceroute = Response.Traceroute;
+export type RouterBoard = Response.Routerboard;
+export type Resource = Response.Resource;
+export type Health = Response.Health;
 export default class Mikrotik extends SSH {
     protected static cache: Cache;
     /**
@@ -20,16 +24,21 @@ export default class Mikrotik extends SSH {
      *
      * @param min_distance
      * @param vrf
+     * @param active_only
      */
-    get_ip_routes(min_distance?: number, vrf?: string): Promise<Route[]>;
+    get_ip_routes(min_distance?: number, vrf?: string, active_only?: boolean): Promise<Route[]>;
     /**
      * Retrieves the IP addresses active on the system
+     *
+     * @param active_only
      */
-    get_ip_addresses(): Promise<Address[]>;
+    get_ip_addresses(active_only?: boolean): Promise<Address[]>;
     /**
      * Retrieves the interfaces active on the system
+     *
+     * @param active_only
      */
-    get_interfaces(): Promise<Interface[]>;
+    get_interfaces(active_only?: boolean): Promise<Interface[]>;
     /**
      * For all device IP addresses, counts the routes that exit (either directly or tunneled)
      * the device using each IP address
@@ -65,6 +74,34 @@ export default class Mikrotik extends SSH {
      * @param source
      */
     traceroute(target: string, source?: string): Promise<Traceroute[]>;
+    /**
+     * Fetches routerboard information from the device
+     */
+    routerboard(): Promise<Response.Routerboard>;
+    /**
+     * Fetches the identity of the device
+     */
+    identity(): Promise<string>;
+    /**
+     * Fetches the resource information of the device
+     */
+    resource(): Promise<Response.Resource>;
+    /**
+     * Fetches the current RouterOS version
+     */
+    version(): Promise<string>;
+    /**
+     * Fetches the semantic RouterOS version
+     */
+    semantic_version(): Promise<{
+        major: number;
+        minor: number;
+        patch: number;
+    }>;
+    /**
+     * Fetches the current health information
+     */
+    health(): Promise<Response.Health>;
     /**
      * Executes a command with expected terse response and parses it accordingly
      *
@@ -72,4 +109,11 @@ export default class Mikrotik extends SSH {
      * @protected
      */
     protected terse<Type extends object = any>(command: string): Promise<Type[]>;
+    /**
+     * Executes a command that expects the result as a 'table' of key-value pairs separated by a colon (:)
+     *
+     * @param command
+     * @protected
+     */
+    protected kvs<Type extends object = any>(command: string): Promise<Type>;
 }

package/dist/index.js

@@ -33,73 +33,99 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const ssh_1 = __importDefault(require("@gibme/ssh"));
 const types_1 = require("./types");
-const ip_1 = __importDefault(require("ip"));
+const ip_address_1 = require("ip-address");
 const memory_1 = __importDefault(require("@gibme/cache/memory"));
 const dns_1 = require("dns");
+const semver_1 = require("semver");
+/** @ignore */
+const toVersion = (version) => (0, semver_1.valid)((0, semver_1.coerce)(version)) || version;
+/** @ignore */
+const toIP4 = (address) => {
+    try {
+        return new ip_address_1.Address4(address);
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
 class Mikrotik extends ssh_1.default {
     /**
      * Retrieves the routes in the routing table
      *
      * @param min_distance
      * @param vrf
+     * @param active_only
      */
     get_ip_routes() {
-        return __awaiter(this, arguments, void 0, function* (min_distance = 0, vrf) {
-            const ifaces = yield this.get_interfaces();
-            const ips = yield this.get_ip_addresses();
-            const routes = yield this.terse('/ip route print terse without-paging where active');
+        return __awaiter(this, arguments, void 0, function* (min_distance = 0, vrf, active_only = true) {
+            const [ifaces, ips] = yield Promise.all([
+                this.get_interfaces(),
+                this.get_ip_addresses()
+            ]);
+            const command = `/ip route print terse without-paging${active_only ? ' where active' : ''}`;
+            const routes = yield this.terse(command);
             return routes.map(route => {
                 var _a;
                 const _network = route['dst-address'].split('/');
                 const address = _network[0];
                 const cidr = parseInt(_network[1]);
                 const [gateway, iface] = (() => {
-                    if (route.gateway) {
-                        if (route.gateway.includes('%')) {
-                            return route.gateway.split('%', 2);
-                        }
-                        else if (ip_1.default.isV4Format(route.gateway)) {
-                            const ip = ips.filter(ip => ip.isLocal(route.gateway)).shift();
-                            return [route.gateway, ip === null || ip === void 0 ? void 0 : ip.iface];
-                        }
-                        else {
-                            const ip = ips.filter(ip => ip.iface === route.gateway).shift();
-                            return [ip === null || ip === void 0 ? void 0 : ip.ipaddress, route.gateway];
-                        }
+                    if (!route.gateway)
+                        return [undefined, undefined];
+                    const gw = toIP4(route.gateway);
+                    if (route.gateway.includes('%')) {
+                        const [gateway, ...iface] = route.gateway.split('%');
+                        return [gateway, iface.join('%')];
+                    }
+                    else if (gw) {
+                        const ip = ips.filter(ip => ip.includes(route.gateway)).shift();
+                        return [route.gateway, ip === null || ip === void 0 ? void 0 : ip.iface];
                     }
                     else {
-                        return [undefined, undefined];
+                        const ip = ips.filter(ip => ip.iface === route.gateway).shift();
+                        return [ip === null || ip === void 0 ? void 0 : ip.ipaddress, route.gateway];
                     }
                 })();
                 const distance = parseInt(route.distance);
                 const scope = parseInt(route.scope);
                 const target_scope = parseInt(route.target_scope) || undefined;
                 // this does not account for if a device has multiple addresses in the same network
-                const preferred_source = (_a = ips.filter(ip => gateway ? ip.isLocal(gateway) : false).shift()) === null || _a === void 0 ? void 0 : _a.ipaddress;
-                const _vrf = route['routing-mark'] || 'main';
+                const preferred_source = (_a = ips.filter(ip => gateway ? ip.includes(gateway) : false).shift()) === null || _a === void 0 ? void 0 : _a.ipaddress;
+                const _vrf = route['routing-table'] || route['routing-mark'] || 'main';
                 const tunnel = (() => {
                     const tunnel = ifaces.filter(_iface => _iface.name === iface).shift();
-                    if (!tunnel)
+                    const parent = ips.filter(ip => ip.ipaddress === (tunnel === null || tunnel === void 0 ? void 0 : tunnel.local_address)).shift();
+                    if (!tunnel || !parent)
                         return undefined;
-                    const root = ips.filter(ip => ip.ipaddress === tunnel.local_address).shift();
-                    if (!root)
-                        return undefined;
-                    return Object.assign(Object.assign({}, tunnel), { root });
+                    return Object.assign(Object.assign({}, tunnel), { parent });
                 })();
-                return {
-                    network: {
-                        address,
-                        cidr
-                    },
-                    preferred_source,
-                    gateway,
-                    iface,
-                    tunnel,
+                const result = {
+                    network: address,
+                    cidr,
                     distance,
                     scope,
-                    target_scope,
-                    vrf: _vrf
+                    vrf: _vrf,
+                    includes: (ipaddress) => {
+                        const temp_address = toIP4(ipaddress);
+                        const temp_network = toIP4(`${address}/${cidr}`);
+                        if (!temp_address || !temp_network)
+                            return false;
+                        return temp_address.isInSubnet(temp_network);
+                    }
                 };
+                if (preferred_source)
+                    result.preferred_source = preferred_source;
+                if (gateway)
+                    result.gateway = gateway;
+                if (iface)
+                    result.iface = iface;
+                if (tunnel)
+                    result.tunnel = tunnel;
+                if (target_scope)
+                    result.target_scope = target_scope;
+                if (route.comment)
+                    result.comment = route.comment;
+                return result;
             })
                 .filter(route => route.distance >= min_distance)
                 .filter(route => vrf ? route.vrf === vrf : true);
@@ -107,76 +133,84 @@ class Mikrotik extends ssh_1.default {
     }
     /**
      * Retrieves the IP addresses active on the system
+     *
+     * @param active_only
      */
     get_ip_addresses() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const addresses = yield this.terse('/ip address print terse without-paging where !disabled');
+        return __awaiter(this, arguments, void 0, function* (active_only = true) {
+            const command = `/ip address print terse without-paging${active_only ? ' where !disabled' : ''}`;
+            const addresses = yield this.terse(command);
             return addresses.map(line => {
                 const _address = line.address.split('/');
                 const ipaddress = _address[0];
                 const cidr = parseInt(_address[1]);
-                return {
+                const result = {
                     ipaddress,
                     network: line.network,
                     cidr,
                     iface: line.interface,
-                    isLocal: (ipaddress) => ip_1.default.cidrSubnet(`${line.network}/${cidr}`).contains(ipaddress)
+                    includes: (ipaddress) => {
+                        const temp_address = toIP4(ipaddress);
+                        const temp_network = toIP4(`${line.network}/${cidr}`);
+                        if (!temp_address || !temp_network)
+                            return false;
+                        return temp_address.isInSubnet(temp_network);
+                    }
                 };
+                if (line.comment)
+                    result.comment = line.comment;
+                return result;
             });
         });
     }
     /**
      * Retrieves the interfaces active on the system
+     *
+     * @param active_only
      */
     get_interfaces() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ifaces = yield this.terse('/interface print terse without-paging where !disabled');
-            const gre = yield this.terse('/interface gre print terse without-paging where !disabled');
-            const ipip = yield this.terse('/interface ipip print terse without-paging where !disabled');
-            const eoip = yield this.terse('/interface eoip print terse without-paging where !disabled');
+        return __awaiter(this, arguments, void 0, function* (active_only = true) {
+            const filter = active_only ? ' where !disabled' : '';
+            const [ifaces, gre, ipip, eoip] = yield Promise.all([
+                this.terse(`/interface print terse without-paging${filter}`),
+                this.terse(`/interface gre print terse without-paging${filter}`),
+                this.terse(`/interface ipip print terse without-paging${filter}`),
+                this.terse(`/interface eoip print terse without-paging${filter}`)
+            ]);
+            const tunnels = [...gre, ...ipip, ...eoip];
             return ifaces.map(line => {
                 const _type = (() => {
                     switch (line.type) {
+                        case 'ether':
+                            return 'ethernet';
+                        case 'lo':
+                            return 'loopback';
                         case 'gre-tunnel':
                             return 'gre';
                         case 'ipip-tunnel':
                             return 'ipip';
                         case 'eoip-tunnel':
                             return 'eoip';
+                        case 'wg':
+                            return 'wireguard';
                         default:
                             return line.type;
                     }
                 })();
-                const local_address = (() => {
-                    switch (line.type) {
-                        case 'gre-tunnel':
-                            return gre.filter(tunnel => tunnel.name === line.name)[0]['local-address'];
-                        case 'ipip':
-                            return ipip.filter(tunnel => tunnel.name === line.name)[0]['local-address'];
-                        case 'eoip':
-                            return eoip.filter(tunnel => tunnel.name === line.name)[0]['local-address'];
-                        default:
-                            return undefined;
-                    }
-                })();
-                const remote_address = (() => {
-                    switch (line.type) {
-                        case 'gre-tunnel':
-                            return gre.filter(tunnel => tunnel.name === line.name)[0]['remote-address'];
-                        case 'ipip':
-                            return ipip.filter(tunnel => tunnel.name === line.name)[0]['remote-address'];
-                        case 'eoip':
-                            return eoip.filter(tunnel => tunnel.name === line.name)[0]['remote-address'];
-                        default:
-                            return undefined;
-                    }
-                })();
-                return {
+                const tunnel = tunnels.filter(tunnel => tunnel.name === line.name).shift();
+                const local_address = tunnel === null || tunnel === void 0 ? void 0 : tunnel['local-address'];
+                const remote_address = tunnel === null || tunnel === void 0 ? void 0 : tunnel['remote-address'];
+                const result = {
                     name: line.name,
-                    type: _type,
-                    local_address,
-                    remote_address
+                    type: _type
                 };
+                if (local_address)
+                    result.local_address = local_address;
+                if (remote_address)
+                    result.remote_address = remote_address;
+                if (line.comment)
+                    result.comment = line.comment;
+                return result;
             });
         });
     }
@@ -189,8 +223,10 @@ class Mikrotik extends ssh_1.default {
      */
     get_route_counts() {
         return __awaiter(this, arguments, void 0, function* (min_distance = 0, vrf) {
-            const routes = yield this.get_ip_routes(min_distance, vrf);
-            const ips = yield this.get_ip_addresses();
+            const [routes, ips] = yield Promise.all([
+                this.get_ip_routes(min_distance, vrf),
+                this.get_ip_addresses()
+            ]);
             const results = {};
             ips.forEach(ip => {
                 results[ip.ipaddress] = {
@@ -203,12 +239,12 @@ class Mikrotik extends ssh_1.default {
                 ip: '',
                 count: 0
             };
-            for (const key of Object.keys(results)) {
+            Object.keys(results).forEach(key => {
                 if (results[key].count > best.count) {
                     best.count = results[key].count;
                     best.ip = key;
                 }
-            }
+            });
             if (results[best.ip]) {
                 results[best.ip].active = true;
             }
@@ -228,13 +264,7 @@ class Mikrotik extends ssh_1.default {
      * @param options
      */
     bandwidth_test(target_1, username_1, password_1) {
-        return __awaiter(this, arguments, void 0, function* (target, username, password, options = {
-            duration: 15,
-            direction: 'both',
-            protocol: 'udp',
-            random_data: false,
-            callback: () => { }
-        }) {
+        return __awaiter(this, arguments, void 0, function* (target, username, password, options = {}) {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const $ = this;
             const sleep = (timeout) => __awaiter(this, void 0, void 0, function* () { return new Promise(resolve => setTimeout(resolve, timeout)); });
@@ -370,10 +400,7 @@ class Mikrotik extends ssh_1.default {
             };
             if (source)
                 result.source = source;
-            let command = `/ping address=${target} count=1`;
-            if (source) {
-                command += ` src-address=${source}`;
-            }
+            const command = `/ping address=${target} count=1${source ? ` src-address=${source}` : ''}`;
             try {
                 const response = (yield this.exec(command))
                     .toString()
@@ -402,10 +429,7 @@ class Mikrotik extends ssh_1.default {
      */
     traceroute(target, source) {
         return __awaiter(this, void 0, void 0, function* () {
-            let command = `/tool traceroute address=${target} count=1`;
-            if (source) {
-                command += ` src-address=${source}`;
-            }
+            const command = `/tool traceroute address=${target} count=1${source ? ` src-address=${source}` : ''}`;
             const response = (yield this.exec(command))
                 .toString()
                 .split('\r\n\r\n')
@@ -420,7 +444,7 @@ class Mikrotik extends ssh_1.default {
             if (!response)
                 throw new Error(`Could not perform traceroute to ${target}`);
             const results = [];
-            const resolve = (ip) => __awaiter(this, void 0, void 0, function* () {
+            const resolveDNS = (ip) => __awaiter(this, void 0, void 0, function* () {
                 return new Promise(resolve => {
                     (0, dns_1.reverse)(ip, (error, addresses) => {
                         if (error)
@@ -445,7 +469,7 @@ class Mikrotik extends ssh_1.default {
                 results.push(result);
             }
             (yield Promise.all(results.filter(result => result.address)
-                .map(result => resolve(result.address || ''))))
+                .map(result => resolveDNS(result.address || ''))))
                 .forEach(result => {
                 for (let i = 0; i < results.length; i++) {
                     if (result[0] === results[i].address && result[1]) {
@@ -456,6 +480,161 @@ class Mikrotik extends ssh_1.default {
             return results;
         });
     }
+    /**
+     * Fetches routerboard information from the device
+     */
+    routerboard() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.kvs('/system routerboard print');
+            return {
+                routerboard: result.routerboard === 'yes',
+                board_name: result['board-name'],
+                model: result.model,
+                serial_number: result['serial-number'],
+                firmware_type: result['firmware-type'],
+                factory_firmware: toVersion(result['factory-firmware']),
+                current_firmware: toVersion(result['current-firmware']),
+                upgrade_firmware: toVersion(result['upgrade-firmware'])
+            };
+        });
+    }
+    /**
+     * Fetches the identity of the device
+     */
+    identity() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.kvs('/system identity print');
+            return response.name;
+        });
+    }
+    /**
+     * Fetches the resource information of the device
+     */
+    resource() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.kvs('/system resource print');
+            const result = {
+                uptime: response.uptime,
+                version: toVersion(response.version),
+                build_time: new Date(`${response['build-time']}Z`),
+                factory_sofware: response['factory-software'],
+                free_memory: response['free-memory'],
+                total_memory: response['total-memory'],
+                cpu: response.cpu,
+                cpu_count: parseInt(response['cpu-count']) || 0,
+                cpu_frequency: parseInt(response['cpu-frequency']) || 0,
+                cpu_load: (parseInt(response['cpu-load']) || 0) / 100,
+                hdd_space: {
+                    free: response['free-hdd-space'],
+                    total: response['total-hdd-space']
+                },
+                architecture_name: response['architecture-name'],
+                board_name: response['board-name'],
+                platform: response.platform
+            };
+            if (response.version.includes('long-term')) {
+                result.lts = true;
+            }
+            else if (response.version.includes('stable')) {
+                result.stable = true;
+            }
+            else if (response.version.includes('testing')) {
+                result.testing = true;
+            }
+            else if (response.version.includes('development')) {
+                result.development = true;
+            }
+            if (response['write-sect-since-reboot'] && response['write-sect-total'] && response['bad-blocks']) {
+                result.nvram = {
+                    write_since_reboot: parseInt(response['write-sect-since-reboot']) || 0,
+                    write_total: parseInt(response['write-sect-total']) || 0,
+                    bad_blocks: parseInt(response['bad-blocks']) || 0
+                };
+            }
+            return result;
+        });
+    }
+    /**
+     * Fetches the current RouterOS version
+     */
+    version() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.resource()).version;
+        });
+    }
+    /**
+     * Fetches the semantic RouterOS version
+     */
+    semantic_version() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const version = yield this.version();
+            const [major, minor, patch] = version.split('.')
+                .map(elem => parseInt(elem) || 0);
+            return {
+                major,
+                minor,
+                patch
+            };
+        });
+    }
+    /**
+     * Fetches the current health information
+     */
+    health() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { major } = yield this.semantic_version();
+            const result = {};
+            if (major === 6) {
+                const response = yield this.kvs('/system health print');
+                result.voltage = parseFloat(response.voltage) || 0;
+                result.current = parseFloat(response.current) || 0;
+                result.temperature = parseFloat(response.temperature) || 0;
+                result.power_consumption = parseFloat(response['power-consumption']) || 0;
+                if (response['psu-voltage']) {
+                    result.psu_voltage = parseFloat(response['psu-voltage']);
+                }
+                if (response['psu1-voltage']) {
+                    result.psu1_voltage = parseFloat(response['psu1-voltage']);
+                }
+                if (response['psu2-voltage']) {
+                    result.psu2_voltage = parseFloat(response['psu2-voltage']);
+                }
+                return result;
+            }
+            else if (major === 7) {
+                const response = yield this.terse('/system health print terse');
+                for (const { name, value, type } of response) {
+                    const num = parseFloat(value) || 0;
+                    switch (name) {
+                        case 'voltage':
+                            result.voltage = num;
+                            break;
+                        case 'temperature':
+                            result.temperature = num;
+                            break;
+                        case 'power-consumption':
+                            result.power_consumption = num;
+                            break;
+                        case 'current':
+                            result.current = type === 'A' ? num * 1000 : num;
+                            break;
+                        case 'psu-voltage':
+                            result.psu_voltage = num;
+                            break;
+                        case 'psu1-voltage':
+                            result.psu1_voltage = num;
+                            break;
+                        case 'psu2-voltage':
+                            result.psu2_voltage = num;
+                    }
+                }
+                return result;
+            }
+            else {
+                throw new Error('RouterOS version is not supported for this command');
+            }
+        });
+    }
     /**
      * Executes a command with expected terse response and parses it accordingly
      *
@@ -469,15 +648,19 @@ class Mikrotik extends ssh_1.default {
                 .toString()
                 .split('\r\n')
                 .map(line => line.trim())
-                .filter(line => line.split(/\s+/)
-                .length !== 0 && line.length !== 0);
+                .filter(line => line.split(/\s+/).length !== 0 && line.length !== 0);
             lines.forEach(line => {
                 const result = {};
                 line.split(/\s+/)
-                    .filter(col => col.includes('='))
+                    .map(col => col.trim())
                     .forEach(col => {
-                    const [key, value] = col.split('=', 2);
-                    result[key] = value;
+                    if (col.includes('=')) {
+                        const [key, ...value] = col.split('=');
+                        result[key] = value.join('=');
+                    }
+                    else {
+                        result[col] = col;
+                    }
                 });
                 if (Object.keys(result).length !== 0)
                     results.push(result);
@@ -485,6 +668,28 @@ class Mikrotik extends ssh_1.default {
             return results;
         });
     }
+    /**
+     * Executes a command that expects the result as a 'table' of key-value pairs separated by a colon (:)
+     *
+     * @param command
+     * @protected
+     */
+    kvs(command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            const lines = (yield this.exec(command))
+                .toString()
+                .split('\r\n')
+                .map(line => line.trim())
+                .filter(line => line.length !== 0)
+                .map(line => line.split(':')
+                .map(col => col.trim()));
+            for (const [key, ...value] of lines) {
+                result[key] = value.join(':');
+            }
+            return result;
+        });
+    }
 }
 Mikrotik.cache = new memory_1.default({
     stdTTL: 15,

package/dist/types.d.ts

@@ -38,51 +38,142 @@ export declare namespace BandwidthTest {
     }
     export {};
 }
+export declare namespace CommandResponses {
+    type YesNo = 'yes' | 'no';
+    interface Comment {
+        comment?: string;
+    }
+    interface Route extends Comment {
+        'dst-address': string;
+        gateway: string;
+        distance: string;
+        scope: string;
+        target_scope: string;
+        'routing-table'?: string;
+        'routing-mark'?: string;
+        'bgp-as-path'?: string;
+        'bgp-origin'?: string;
+        'bgp-local-pref'?: string;
+        'received-from'?: string;
+        'check-gateway'?: string;
+        'suppress-hw-offload'?: string;
+        'blackhole'?: string;
+        'immediate-gw'?: string;
+        reachable?: string;
+        'gateway-status'?: string;
+    }
+    interface Address extends Comment {
+        address: string;
+        network: string;
+        interface: string;
+        'actual-interface': string;
+    }
+    interface Interface extends Comment {
+        name: string;
+        type: string;
+        mtu: string;
+        'default-name'?: string;
+        'actual-mtu': string;
+        'mac-address'?: string;
+        'link-downs'?: string;
+        l2mtu?: string;
+    }
+    interface TunnelInterface extends Omit<Interface, 'type'>, Comment {
+        'local-address': string;
+        'remote-address': string;
+        'clamp-tcp-mss': YesNo;
+        'dont-fragment': YesNo;
+        'allow-fast-path': YesNo;
+    }
+    interface Routeboard {
+        routerboard: YesNo;
+        'board-name': string;
+        model: string;
+        'serial-number': string;
+        'firmware-type': string;
+        'factory-firmware': string;
+        'current-firmware': string;
+        'upgrade-firmware': string;
+    }
+    interface Identity {
+        name: string;
+    }
+    interface Resource {
+        uptime: string;
+        version: string;
+        'build-time': string;
+        'factory-software': string;
+        'free-memory': string;
+        'total-memory': string;
+        cpu: string;
+        'cpu-count': string;
+        'cpu-frequency': string;
+        'cpu-load': string;
+        'free-hdd-space': string;
+        'total-hdd-space': string;
+        'architecture-name': string;
+        'board-name': string;
+        platform: string;
+        'write-sect-since-reboot'?: string;
+        'write-sect-total'?: string;
+        'bad-blocks'?: string;
+    }
+    interface Health {
+        voltage: string;
+        current: string;
+        temperature: string;
+        'power-consumption': string;
+        'psu-voltage'?: string;
+        'psu1-voltage'?: string;
+        'psu2-voltage'?: string;
+    }
+}
 export declare namespace Response {
-    interface Address {
+    interface includesAddress {
+        includes(ipaddress: string): boolean;
+    }
+    interface Comment {
+        comment?: string;
+    }
+    export interface Address extends includesAddress, Comment {
         ipaddress: string;
         network: string;
         cidr: number;
         iface: string;
-        isLocal(ipaddress: string): boolean;
     }
-    interface Interface {
+    export interface Interface extends Comment {
         name: string;
         type: string;
         local_address?: string;
         remote_address?: string;
     }
-    interface Tunnel extends Interface {
-        root: Address;
+    export interface Tunnel extends Interface {
+        parent: Address;
     }
-    interface Route {
-        network: {
-            address: string;
-            cidr: number;
-        };
+    export interface Route extends includesAddress, Comment {
+        network: string;
+        cidr: number;
+        distance: number;
+        scope: number;
+        vrf: string;
         preferred_source?: string;
         gateway?: string;
         iface?: string;
         tunnel?: Tunnel;
-        distance: number;
-        scope: number;
         target_scope?: number;
-        vrf: string;
     }
-    interface RouteCount {
+    export interface RouteCount {
         interface: string;
         count: number;
         active: boolean;
     }
-    interface Ping {
-        source?: string;
+    export interface Ping {
         target: string;
         latency: number;
+        source?: string;
     }
-    interface Traceroute {
+    export interface Traceroute {
         hop: number;
-        address?: string;
-        hostname?: string;
         loss: number;
         sent: number;
         last: number;
@@ -90,5 +181,55 @@ export declare namespace Response {
         best: number;
         worst: number;
         timeout: boolean;
+        address?: string;
+        hostname?: string;
+    }
+    export interface Routerboard {
+        routerboard: boolean;
+        board_name: string;
+        model: string;
+        serial_number: string;
+        firmware_type: string;
+        factory_firmware: string;
+        current_firmware: string;
+        upgrade_firmware: string;
     }
+    export interface Resource {
+        uptime: string;
+        version: string;
+        build_time: Date;
+        factory_sofware: string;
+        free_memory: string;
+        total_memory: string;
+        cpu: string;
+        cpu_count: number;
+        cpu_frequency: number;
+        cpu_load: number;
+        hdd_space: {
+            free: string;
+            total: string;
+        };
+        architecture_name: string;
+        board_name: string;
+        platform: string;
+        lts?: boolean;
+        stable?: boolean;
+        testing?: boolean;
+        development?: boolean;
+        nvram?: {
+            write_since_reboot: number;
+            write_total: number;
+            bad_blocks: number;
+        };
+    }
+    export interface Health {
+        voltage: number;
+        current: number;
+        temperature: number;
+        power_consumption: number;
+        psu_voltage?: number;
+        psu1_voltage?: number;
+        psu2_voltage?: number;
+    }
+    export {};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gibme/mikrotik",
-  "version": "1.1.2",
+  "version": "2.0.0",
   "description": "A simple mikrotik helper/wrapper",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,7 +57,8 @@
   "dependencies": {
     "@gibme/cache": "^1.1.5",
     "@gibme/ssh": "^1.0.2",
-    "@types/ip": "^1.1.3",
-    "ip": "^2.0.1"
+    "@types/jsbn": "^1.2.33",
+    "ip-address": "^9.0.5",
+    "semver": "^7.6.2"
   }
 }