@ecobridge.xyz/devicemanager 3.0.2

package/dist_ts/discovery/discovery.classes.mdns.js

@@ -0,0 +1,291 @@
+import * as plugins from '../plugins.js';
+/**
+ * Service type definitions for mDNS discovery
+ */
+const SERVICE_TYPES = {
+    // Scanners
+    ESCL: '_uscan._tcp', // eSCL/AirScan scanners
+    ESCL_SECURE: '_uscans._tcp', // eSCL over TLS
+    SANE: '_scanner._tcp', // SANE network scanners
+    // Printers
+    IPP: '_ipp._tcp', // IPP printers
+    IPPS: '_ipps._tcp', // IPP over TLS
+    PDL: '_pdl-datastream._tcp', // Raw/JetDirect printers
+    // Speakers / Audio
+    AIRPLAY: '_airplay._tcp', // AirPlay devices (Apple TV, HomePod, etc.)
+    RAOP: '_raop._tcp', // Remote Audio Output Protocol (AirPlay audio)
+    SONOS: '_sonos._tcp', // Sonos speakers
+    GOOGLECAST: '_googlecast._tcp', // Chromecast / Google Cast devices
+    SPOTIFY: '_spotify-connect._tcp', // Spotify Connect devices
+};
+/**
+ * Default discovery options
+ */
+const DEFAULT_OPTIONS = {
+    serviceTypes: [
+        // Scanners
+        SERVICE_TYPES.ESCL,
+        SERVICE_TYPES.ESCL_SECURE,
+        SERVICE_TYPES.SANE,
+        // Printers
+        SERVICE_TYPES.IPP,
+        SERVICE_TYPES.IPPS,
+        // Speakers
+        SERVICE_TYPES.AIRPLAY,
+        SERVICE_TYPES.RAOP,
+        SERVICE_TYPES.SONOS,
+        SERVICE_TYPES.GOOGLECAST,
+    ],
+    timeout: 10000,
+};
+/**
+ * mDNS/Bonjour discovery service for network devices
+ */
+export class MdnsDiscovery extends plugins.events.EventEmitter {
+    bonjour = null;
+    browsers = [];
+    discoveredDevices = new Map();
+    options;
+    isRunning = false;
+    constructor(options) {
+        super();
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    /**
+     * Check if discovery is currently running
+     */
+    get running() {
+        return this.isRunning;
+    }
+    /**
+     * Get all discovered devices
+     */
+    getDevices() {
+        return Array.from(this.discoveredDevices.values());
+    }
+    /**
+     * Get discovered scanners only
+     */
+    getScanners() {
+        return this.getDevices().filter((d) => d.type === 'scanner');
+    }
+    /**
+     * Get discovered printers only
+     */
+    getPrinters() {
+        return this.getDevices().filter((d) => d.type === 'printer');
+    }
+    /**
+     * Start mDNS discovery
+     */
+    async start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.bonjour = new plugins.bonjourService.Bonjour();
+        this.isRunning = true;
+        this.emit('started');
+        for (const serviceType of this.options.serviceTypes) {
+            this.browseService(serviceType);
+        }
+    }
+    /**
+     * Stop mDNS discovery
+     */
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        // Stop all browsers
+        for (const browser of this.browsers) {
+            browser.stop();
+        }
+        this.browsers = [];
+        // Destroy bonjour instance
+        if (this.bonjour) {
+            this.bonjour.destroy();
+            this.bonjour = null;
+        }
+        this.isRunning = false;
+        this.emit('stopped');
+    }
+    /**
+     * Clear discovered devices
+     */
+    clear() {
+        this.discoveredDevices.clear();
+    }
+    /**
+     * Browse for a specific service type
+     */
+    browseService(serviceType) {
+        if (!this.bonjour) {
+            return;
+        }
+        const browser = this.bonjour.find({ type: serviceType }, (service) => {
+            this.handleServiceFound(service, serviceType);
+        });
+        browser.on('down', (service) => {
+            this.handleServiceLost(service, serviceType);
+        });
+        this.browsers.push(browser);
+    }
+    /**
+     * Handle discovered service
+     */
+    handleServiceFound(service, serviceType) {
+        const device = this.parseService(service, serviceType);
+        if (!device) {
+            return;
+        }
+        const existingDevice = this.discoveredDevices.get(device.id);
+        if (existingDevice) {
+            // Update existing device
+            this.discoveredDevices.set(device.id, device);
+            this.emit('device:updated', device);
+        }
+        else {
+            // New device found
+            this.discoveredDevices.set(device.id, device);
+            this.emit('device:found', device);
+            if (device.type === 'scanner') {
+                this.emit('scanner:found', device);
+            }
+            else if (device.type === 'printer') {
+                this.emit('printer:found', device);
+            }
+        }
+    }
+    /**
+     * Handle lost service
+     */
+    handleServiceLost(service, serviceType) {
+        const deviceId = this.generateDeviceId(service, serviceType);
+        const device = this.discoveredDevices.get(deviceId);
+        if (device) {
+            this.discoveredDevices.delete(deviceId);
+            this.emit('device:lost', device);
+            if (device.type === 'scanner') {
+                this.emit('scanner:lost', deviceId);
+            }
+            else if (device.type === 'printer') {
+                this.emit('printer:lost', deviceId);
+            }
+        }
+    }
+    /**
+     * Parse Bonjour service into device info
+     */
+    parseService(service, serviceType) {
+        const addresses = service.addresses ?? [];
+        // Prefer IPv4 address
+        const address = addresses.find((a) => !a.includes(':')) ?? addresses[0] ?? service.host;
+        if (!address) {
+            return null;
+        }
+        const txtRecords = this.parseTxtRecords(service.txt);
+        const deviceType = this.getDeviceType(serviceType);
+        const protocol = this.getProtocol(serviceType);
+        const deviceId = this.generateDeviceId(service, serviceType);
+        return {
+            id: deviceId,
+            name: service.name || txtRecords['ty'] || txtRecords['product'] || 'Unknown Device',
+            type: deviceType,
+            protocol: protocol,
+            address: address,
+            port: service.port,
+            txtRecords: txtRecords,
+            serviceType: serviceType,
+        };
+    }
+    /**
+     * Generate unique device ID
+     */
+    generateDeviceId(service, serviceType) {
+        const addresses = service.addresses ?? [];
+        const address = addresses.find((a) => !a.includes(':')) ?? addresses[0] ?? service.host;
+        return `${serviceType}:${address}:${service.port}`;
+    }
+    /**
+     * Parse TXT records from service
+     */
+    parseTxtRecords(txt) {
+        const records = {};
+        if (!txt) {
+            return records;
+        }
+        for (const [key, value] of Object.entries(txt)) {
+            if (typeof value === 'string') {
+                records[key] = value;
+            }
+            else if (Buffer.isBuffer(value)) {
+                records[key] = value.toString('utf-8');
+            }
+            else if (value !== undefined && value !== null) {
+                records[key] = String(value);
+            }
+        }
+        return records;
+    }
+    /**
+     * Determine device type from service type
+     */
+    getDeviceType(serviceType) {
+        switch (serviceType) {
+            case SERVICE_TYPES.ESCL:
+            case SERVICE_TYPES.ESCL_SECURE:
+            case SERVICE_TYPES.SANE:
+                return 'scanner';
+            case SERVICE_TYPES.IPP:
+            case SERVICE_TYPES.IPPS:
+            case SERVICE_TYPES.PDL:
+                return 'printer';
+            case SERVICE_TYPES.AIRPLAY:
+            case SERVICE_TYPES.RAOP:
+            case SERVICE_TYPES.SONOS:
+            case SERVICE_TYPES.GOOGLECAST:
+            case SERVICE_TYPES.SPOTIFY:
+                return 'speaker';
+            default:
+                // Check if it's a scanner or printer based on service type pattern
+                if (serviceType.includes('scan') || serviceType.includes('scanner')) {
+                    return 'scanner';
+                }
+                if (serviceType.includes('airplay') || serviceType.includes('raop') ||
+                    serviceType.includes('sonos') || serviceType.includes('cast') ||
+                    serviceType.includes('spotify')) {
+                    return 'speaker';
+                }
+                return 'printer';
+        }
+    }
+    /**
+     * Determine protocol from service type
+     */
+    getProtocol(serviceType) {
+        switch (serviceType) {
+            case SERVICE_TYPES.ESCL:
+            case SERVICE_TYPES.ESCL_SECURE:
+                return 'escl';
+            case SERVICE_TYPES.SANE:
+                return 'sane';
+            case SERVICE_TYPES.IPP:
+            case SERVICE_TYPES.IPPS:
+            case SERVICE_TYPES.PDL:
+                return 'ipp';
+            case SERVICE_TYPES.AIRPLAY:
+            case SERVICE_TYPES.RAOP:
+                return 'airplay';
+            case SERVICE_TYPES.SONOS:
+                return 'sonos';
+            case SERVICE_TYPES.GOOGLECAST:
+                return 'chromecast';
+            case SERVICE_TYPES.SPOTIFY:
+                return 'spotify';
+            default:
+                return 'unknown';
+        }
+    }
+}
+export { SERVICE_TYPES };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discovery.classes.mdns.js","sourceRoot":"","sources":["../../ts/discovery/discovery.classes.mdns.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AAQzC;;GAEG;AACH,MAAM,aAAa,GAAG;IACpB,WAAW;IACX,IAAI,EAAE,aAAa,EAAY,wBAAwB;IACvD,WAAW,EAAE,cAAc,EAAI,gBAAgB;IAC/C,IAAI,EAAE,eAAe,EAAU,wBAAwB;IAEvD,WAAW;IACX,GAAG,EAAE,WAAW,EAAe,eAAe;IAC9C,IAAI,EAAE,YAAY,EAAa,eAAe;IAC9C,GAAG,EAAE,sBAAsB,EAAI,yBAAyB;IAExD,mBAAmB;IACnB,OAAO,EAAE,eAAe,EAAO,4CAA4C;IAC3E,IAAI,EAAE,YAAY,EAAa,+CAA+C;IAC9E,KAAK,EAAE,aAAa,EAAW,iBAAiB;IAChD,UAAU,EAAE,kBAAkB,EAAE,mCAAmC;IACnE,OAAO,EAAE,uBAAuB,EAAE,0BAA0B;CACpD,CAAC;AAEX;;GAEG;AACH,MAAM,eAAe,GAAgC;IACnD,YAAY,EAAE;QACZ,WAAW;QACX,aAAa,CAAC,IAAI;QAClB,aAAa,CAAC,WAAW;QACzB,aAAa,CAAC,IAAI;QAClB,WAAW;QACX,aAAa,CAAC,GAAG;QACjB,aAAa,CAAC,IAAI;QAClB,WAAW;QACX,aAAa,CAAC,OAAO;QACrB,aAAa,CAAC,IAAI;QAClB,aAAa,CAAC,KAAK;QACnB,aAAa,CAAC,UAAU;KACzB;IACD,OAAO,EAAE,KAAK;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,OAAO,aAAc,SAAQ,OAAO,CAAC,MAAM,CAAC,YAAY;IACpD,OAAO,GAA0C,IAAI,CAAC;IACtD,QAAQ,GAAqC,EAAE,CAAC;IAChD,iBAAiB,GAAmC,IAAI,GAAG,EAAE,CAAC;IAC9D,OAAO,CAA8B;IACrC,SAAS,GAAY,KAAK,CAAC;IAEnC,YAAY,OAA2B;QACrC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,eAAe,EAAE,GAAG,OAAO,EAAE,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACI,UAAU;QACf,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,KAAK;QAChB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;QACpD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAErB,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YACpD,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,OAAO;QACT,CAAC;QAED,oBAAoB;QACpB,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACpC,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QAEnB,2BAA2B;QAC3B,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACvB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACvB,CAAC;IAED;;OAEG;IACI,KAAK;QACV,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACK,aAAa,CAAC,WAAmB;QACvC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC,OAAO,EAAE,EAAE;YACnE,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE;YAC7B,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED;;OAEG;IACK,kBAAkB,CACxB,OAAuC,EACvC,WAAmB;QAEnB,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO;QACT,CAAC;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC7D,IAAI,cAAc,EAAE,CAAC;YACnB,yBAAyB;YACzB,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;YAC9C,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;QACtC,CAAC;aAAM,CAAC;YACN,mBAAmB;YACnB,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;YAC9C,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;YAElC,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC9B,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;YACrC,CAAC;iBAAM,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBACrC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,iBAAiB,CACvB,OAAuC,EACvC,WAAmB;QAEnB,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAEpD,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACxC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;YAEjC,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC9B,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;YACtC,CAAC;iBAAM,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBACrC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,YAAY,CAClB,OAAuC,EACvC,WAAmB;QAEnB,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;QAC1C,sBAAsB;QACtB,MAAM,OAAO,GACX,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;QAE1E,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACrD,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QAE/C,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAE7D,OAAO;YACL,EAAE,EAAE,QAAQ;YACZ,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,SAAS,CAAC,IAAI,gBAAgB;YACnF,IAAI,EAAE,UAAU;YAChB,QAAQ,EAAE,QAAQ;YAClB,OAAO,EAAE,OAAO;YAChB,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,UAAU,EAAE,UAAU;YACtB,WAAW,EAAE,WAAW;SACzB,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,gBAAgB,CACtB,OAAuC,EACvC,WAAmB;QAEnB,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;QAC1C,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;QACxF,OAAO,GAAG,WAAW,IAAI,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IACrD,CAAC;IAED;;OAEG;IACK,eAAe,CACrB,GAAwC;QAExC,MAAM,OAAO,GAA2B,EAAE,CAAC;QAE3C,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC9B,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YACvB,CAAC;iBAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBAClC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;YACzC,CAAC;iBAAM,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACjD,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,aAAa,CAAC,WAAmB;QACvC,QAAQ,WAAW,EAAE,CAAC;YACpB,KAAK,aAAa,CAAC,IAAI,CAAC;YACxB,KAAK,aAAa,CAAC,WAAW,CAAC;YAC/B,KAAK,aAAa,CAAC,IAAI;gBACrB,OAAO,SAAS,CAAC;YACnB,KAAK,aAAa,CAAC,GAAG,CAAC;YACvB,KAAK,aAAa,CAAC,IAAI,CAAC;YACxB,KAAK,aAAa,CAAC,GAAG;gBACpB,OAAO,SAAS,CAAC;YACnB,KAAK,aAAa,CAAC,OAAO,CAAC;YAC3B,KAAK,aAAa,CAAC,IAAI,CAAC;YACxB,KAAK,aAAa,CAAC,KAAK,CAAC;YACzB,KAAK,aAAa,CAAC,UAAU,CAAC;YAC9B,KAAK,aAAa,CAAC,OAAO;gBACxB,OAAO,SAAS,CAAC;YACnB;gBACE,mEAAmE;gBACnE,IAAI,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;oBACpE,OAAO,SAAS,CAAC;gBACnB,CAAC;gBACD,IAAI,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC;oBAC/D,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC;oBAC7D,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;oBACpC,OAAO,SAAS,CAAC;gBACnB,CAAC;gBACD,OAAO,SAAS,CAAC;QACrB,CAAC;IACH,CAAC;IAED;;OAEG;IACK,WAAW,CAAC,WAAmB;QACrC,QAAQ,WAAW,EAAE,CAAC;YACpB,KAAK,aAAa,CAAC,IAAI,CAAC;YACxB,KAAK,aAAa,CAAC,WAAW;gBAC5B,OAAO,MAAM,CAAC;YAChB,KAAK,aAAa,CAAC,IAAI;gBACrB,OAAO,MAAM,CAAC;YAChB,KAAK,aAAa,CAAC,GAAG,CAAC;YACvB,KAAK,aAAa,CAAC,IAAI,CAAC;YACxB,KAAK,aAAa,CAAC,GAAG;gBACpB,OAAO,KAAK,CAAC;YACf,KAAK,aAAa,CAAC,OAAO,CAAC;YAC3B,KAAK,aAAa,CAAC,IAAI;gBACrB,OAAO,SAAS,CAAC;YACnB,KAAK,aAAa,CAAC,KAAK;gBACtB,OAAO,OAAO,CAAC;YACjB,KAAK,aAAa,CAAC,UAAU;gBAC3B,OAAO,YAAY,CAAC;YACtB,KAAK,aAAa,CAAC,OAAO;gBACxB,OAAO,SAAS,CAAC;YACnB;gBACE,OAAO,SAAS,CAAC;QACrB,CAAC;IACH,CAAC;CACF;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist_ts/discovery/discovery.classes.networkscanner.d.ts

@@ -0,0 +1,64 @@
+import * as plugins from '../plugins.js';
+import type { INetworkScanOptions, INetworkScanResult } from '../interfaces/index.js';
+/**
+ * Network Scanner - scans IP ranges for scanners and printers
+ */
+export declare class NetworkScanner extends plugins.events.EventEmitter {
+    private cancelled;
+    private scanning;
+    /**
+     * Check if a scan is currently in progress
+     */
+    get isScanning(): boolean;
+    /**
+     * Scan a network range for devices
+     */
+    scan(options: INetworkScanOptions): Promise<INetworkScanResult[]>;
+    /**
+     * Cancel an ongoing scan
+     */
+    cancel(): Promise<void>;
+    /**
+     * Resolve IPs from options (CIDR or start/end range)
+     */
+    private resolveIps;
+    /**
+     * Probe a single IP address for devices
+     */
+    private probeIp;
+    /**
+     * Quick TCP port scan
+     */
+    private scanPorts;
+    /**
+     * Check if a TCP port is open
+     */
+    private isPortOpen;
+    /**
+     * Probe for IPP printer using a simple HTTP check
+     * We avoid using the full ipp library for probing since it can hang and produce noisy output
+     */
+    private probeIpp;
+    /**
+     * Probe for eSCL scanner
+     */
+    private probeEscl;
+    /**
+     * Probe for SANE scanner (quick check)
+     */
+    private probeSane;
+    /**
+     * Probe for AirPlay speaker on port 7000
+     * Tries HTTP endpoints to identify the device. If no HTTP response,
+     * but port 7000 is open, it's still likely an AirPlay device.
+     */
+    private probeAirplay;
+    /**
+     * Probe for Sonos speaker
+     */
+    private probeSonos;
+    /**
+     * Probe for Chromecast device
+     */
+    private probeChromecast;
+}