@push.rocks/smartproxy 13.1.2 → 15.0.0

package/dist_ts/proxies/smart-proxy/route-manager.js

@@ -0,0 +1,483 @@
+import * as plugins from '../../plugins.js';
+import { isRoutedOptions, isLegacyOptions } from './models/interfaces.js';
+/**
+ * The RouteManager handles all routing decisions based on connections and attributes
+ */
+export class RouteManager extends plugins.EventEmitter {
+    constructor(options) {
+        super();
+        this.routes = [];
+        this.portMap = new Map();
+        // We no longer support legacy options, always use provided options
+        this.options = options;
+        // Initialize routes from either source
+        this.updateRoutes(this.options.routes);
+    }
+    /**
+     * Update routes with new configuration
+     */
+    updateRoutes(routes = []) {
+        // Sort routes by priority (higher first)
+        this.routes = [...(routes || [])].sort((a, b) => {
+            const priorityA = a.priority ?? 0;
+            const priorityB = b.priority ?? 0;
+            return priorityB - priorityA;
+        });
+        // Rebuild port mapping for fast lookups
+        this.rebuildPortMap();
+    }
+    /**
+     * Rebuild the port mapping for fast lookups
+     */
+    rebuildPortMap() {
+        this.portMap.clear();
+        for (const route of this.routes) {
+            const ports = this.expandPortRange(route.match.ports);
+            for (const port of ports) {
+                if (!this.portMap.has(port)) {
+                    this.portMap.set(port, []);
+                }
+                this.portMap.get(port).push(route);
+            }
+        }
+    }
+    /**
+     * Expand a port range specification into an array of individual ports
+     */
+    expandPortRange(portRange) {
+        if (typeof portRange === 'number') {
+            return [portRange];
+        }
+        if (Array.isArray(portRange)) {
+            // Handle array of port objects or numbers
+            return portRange.flatMap(item => {
+                if (typeof item === 'number') {
+                    return [item];
+                }
+                else if (typeof item === 'object' && 'from' in item && 'to' in item) {
+                    // Handle port range object
+                    const ports = [];
+                    for (let p = item.from; p <= item.to; p++) {
+                        ports.push(p);
+                    }
+                    return ports;
+                }
+                return [];
+            });
+        }
+        return [];
+    }
+    /**
+     * Get all ports that should be listened on
+     */
+    getListeningPorts() {
+        return Array.from(this.portMap.keys());
+    }
+    /**
+     * Get all routes for a given port
+     */
+    getRoutesForPort(port) {
+        return this.portMap.get(port) || [];
+    }
+    /**
+     * Test if a pattern matches a domain using glob matching
+     */
+    matchDomain(pattern, domain) {
+        // Convert glob pattern to regex
+        const regexPattern = pattern
+            .replace(/\./g, '\\.') // Escape dots
+            .replace(/\*/g, '.*'); // Convert * to .*
+        const regex = new RegExp(`^${regexPattern}$`, 'i');
+        return regex.test(domain);
+    }
+    /**
+     * Match a domain against all patterns in a route
+     */
+    matchRouteDomain(route, domain) {
+        if (!route.match.domains) {
+            // If no domains specified, match all domains
+            return true;
+        }
+        const patterns = Array.isArray(route.match.domains)
+            ? route.match.domains
+            : [route.match.domains];
+        return patterns.some(pattern => this.matchDomain(pattern, domain));
+    }
+    /**
+     * Check if a client IP is allowed by a route's security settings
+     */
+    isClientIpAllowed(route, clientIp) {
+        const security = route.action.security;
+        if (!security) {
+            return true; // No security settings means allowed
+        }
+        // Check blocked IPs first
+        if (security.blockedIps && security.blockedIps.length > 0) {
+            for (const pattern of security.blockedIps) {
+                if (this.matchIpPattern(pattern, clientIp)) {
+                    return false; // IP is blocked
+                }
+            }
+        }
+        // If there are allowed IPs, check them
+        if (security.allowedIps && security.allowedIps.length > 0) {
+            for (const pattern of security.allowedIps) {
+                if (this.matchIpPattern(pattern, clientIp)) {
+                    return true; // IP is allowed
+                }
+            }
+            return false; // IP not in allowed list
+        }
+        // No allowed IPs specified, so IP is allowed
+        return true;
+    }
+    /**
+     * Match an IP against a pattern
+     */
+    matchIpPattern(pattern, ip) {
+        // Handle exact match
+        if (pattern === ip) {
+            return true;
+        }
+        // Handle CIDR notation (e.g., 192.168.1.0/24)
+        if (pattern.includes('/')) {
+            return this.matchIpCidr(pattern, ip);
+        }
+        // Handle glob pattern (e.g., 192.168.1.*)
+        if (pattern.includes('*')) {
+            const regexPattern = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
+            const regex = new RegExp(`^${regexPattern}$`);
+            return regex.test(ip);
+        }
+        return false;
+    }
+    /**
+     * Match an IP against a CIDR pattern
+     */
+    matchIpCidr(cidr, ip) {
+        try {
+            // In a real implementation, you'd use a proper IP library
+            // This is a simplified implementation
+            const [subnet, bits] = cidr.split('/');
+            const mask = parseInt(bits, 10);
+            // Convert IP addresses to numeric values
+            const ipNum = this.ipToNumber(ip);
+            const subnetNum = this.ipToNumber(subnet);
+            // Calculate subnet mask
+            const maskNum = ~(2 ** (32 - mask) - 1);
+            // Check if IP is in subnet
+            return (ipNum & maskNum) === (subnetNum & maskNum);
+        }
+        catch (e) {
+            console.error(`Error matching IP ${ip} against CIDR ${cidr}:`, e);
+            return false;
+        }
+    }
+    /**
+     * Convert an IP address to a numeric value
+     */
+    ipToNumber(ip) {
+        const parts = ip.split('.').map(part => parseInt(part, 10));
+        return (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3];
+    }
+    /**
+     * Find the matching route for a connection
+     */
+    findMatchingRoute(options) {
+        const { port, domain, clientIp, path, tlsVersion } = options;
+        // Get all routes for this port
+        const routesForPort = this.getRoutesForPort(port);
+        // Find the first matching route based on priority order
+        for (const route of routesForPort) {
+            // Check domain match if specified
+            if (domain && !this.matchRouteDomain(route, domain)) {
+                continue;
+            }
+            // Check path match if specified in both route and request
+            if (path && route.match.path) {
+                if (!this.matchPath(route.match.path, path)) {
+                    continue;
+                }
+            }
+            // Check client IP match
+            if (route.match.clientIp && !route.match.clientIp.some(pattern => this.matchIpPattern(pattern, clientIp))) {
+                continue;
+            }
+            // Check TLS version match
+            if (tlsVersion && route.match.tlsVersion &&
+                !route.match.tlsVersion.includes(tlsVersion)) {
+                continue;
+            }
+            // Check security settings
+            if (!this.isClientIpAllowed(route, clientIp)) {
+                continue;
+            }
+            // All checks passed, this route matches
+            return { route };
+        }
+        return null;
+    }
+    /**
+     * Match a path against a pattern
+     */
+    matchPath(pattern, path) {
+        // Convert the glob pattern to a regex
+        const regexPattern = pattern
+            .replace(/\./g, '\\.') // Escape dots
+            .replace(/\*/g, '.*') // Convert * to .*
+            .replace(/\//g, '\\/'); // Escape slashes
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(path);
+    }
+    /**
+     * Convert a domain config to routes
+     * (For backward compatibility with code that still uses domainConfigs)
+     */
+    domainConfigToRoutes(domainConfig) {
+        const routes = [];
+        const { domains, forwarding } = domainConfig;
+        // Determine the action based on forwarding type
+        let action = {
+            type: 'forward',
+            target: {
+                host: forwarding.target.host,
+                port: forwarding.target.port
+            }
+        };
+        // Set TLS mode based on forwarding type
+        switch (forwarding.type) {
+            case 'http-only':
+                // No TLS settings needed
+                break;
+            case 'https-passthrough':
+                action.tls = { mode: 'passthrough' };
+                break;
+            case 'https-terminate-to-http':
+                action.tls = {
+                    mode: 'terminate',
+                    certificate: forwarding.https?.customCert ? {
+                        key: forwarding.https.customCert.key,
+                        cert: forwarding.https.customCert.cert
+                    } : 'auto'
+                };
+                break;
+            case 'https-terminate-to-https':
+                action.tls = {
+                    mode: 'terminate-and-reencrypt',
+                    certificate: forwarding.https?.customCert ? {
+                        key: forwarding.https.customCert.key,
+                        cert: forwarding.https.customCert.cert
+                    } : 'auto'
+                };
+                break;
+        }
+        // Add security settings if present
+        if (forwarding.security) {
+            action.security = {
+                allowedIps: forwarding.security.allowedIps,
+                blockedIps: forwarding.security.blockedIps,
+                maxConnections: forwarding.security.maxConnections
+            };
+        }
+        // Add advanced settings if present
+        if (forwarding.advanced) {
+            action.advanced = {
+                timeout: forwarding.advanced.timeout,
+                headers: forwarding.advanced.headers,
+                keepAlive: forwarding.advanced.keepAlive
+            };
+        }
+        // Determine which port to use based on forwarding type
+        const defaultPort = forwarding.type.startsWith('https') ? 443 : 80;
+        // Add the main route
+        routes.push({
+            match: {
+                ports: defaultPort,
+                domains
+            },
+            action,
+            name: `Route for ${domains.join(', ')}`
+        });
+        // Add HTTP redirect if needed
+        if (forwarding.http?.redirectToHttps) {
+            routes.push({
+                match: {
+                    ports: 80,
+                    domains
+                },
+                action: {
+                    type: 'redirect',
+                    redirect: {
+                        to: 'https://{domain}{path}',
+                        status: 301
+                    }
+                },
+                name: `HTTP Redirect for ${domains.join(', ')}`,
+                priority: 100 // Higher priority for redirects
+            });
+        }
+        // Add port ranges if specified
+        if (forwarding.advanced?.portRanges) {
+            for (const range of forwarding.advanced.portRanges) {
+                routes.push({
+                    match: {
+                        ports: [{ from: range.from, to: range.to }],
+                        domains
+                    },
+                    action,
+                    name: `Port Range ${range.from}-${range.to} for ${domains.join(', ')}`
+                });
+            }
+        }
+        return routes;
+    }
+    /**
+     * Update routes based on domain configs
+     * (For backward compatibility with code that still uses domainConfigs)
+     */
+    updateFromDomainConfigs(domainConfigs) {
+        const routes = [];
+        // Convert each domain config to routes
+        for (const config of domainConfigs) {
+            routes.push(...this.domainConfigToRoutes(config));
+        }
+        // Merge with existing routes that aren't derived from domain configs
+        const nonDomainRoutes = this.routes.filter(r => !r.name || !r.name.includes('for '));
+        this.updateRoutes([...nonDomainRoutes, ...routes]);
+    }
+    /**
+     * Validate the route configuration and return any warnings
+     */
+    validateConfiguration() {
+        const warnings = [];
+        const duplicatePorts = new Map();
+        // Check for routes with the same exact match criteria
+        for (let i = 0; i < this.routes.length; i++) {
+            for (let j = i + 1; j < this.routes.length; j++) {
+                const route1 = this.routes[i];
+                const route2 = this.routes[j];
+                // Check if route match criteria are the same
+                if (this.areMatchesSimilar(route1.match, route2.match)) {
+                    warnings.push(`Routes "${route1.name || i}" and "${route2.name || j}" have similar match criteria. ` +
+                        `The route with higher priority (${Math.max(route1.priority || 0, route2.priority || 0)}) will be used.`);
+                }
+            }
+        }
+        // Check for routes that may never be matched due to priority
+        for (let i = 0; i < this.routes.length; i++) {
+            const route = this.routes[i];
+            const higherPriorityRoutes = this.routes.filter(r => (r.priority || 0) > (route.priority || 0));
+            for (const higherRoute of higherPriorityRoutes) {
+                if (this.isRouteShadowed(route, higherRoute)) {
+                    warnings.push(`Route "${route.name || i}" may never be matched because it is shadowed by ` +
+                        `higher priority route "${higherRoute.name || 'unnamed'}"`);
+                    break;
+                }
+            }
+        }
+        return warnings;
+    }
+    /**
+     * Check if two route matches are similar (potential conflict)
+     */
+    areMatchesSimilar(match1, match2) {
+        // Check port overlap
+        const ports1 = new Set(this.expandPortRange(match1.ports));
+        const ports2 = new Set(this.expandPortRange(match2.ports));
+        let havePortOverlap = false;
+        for (const port of ports1) {
+            if (ports2.has(port)) {
+                havePortOverlap = true;
+                break;
+            }
+        }
+        if (!havePortOverlap) {
+            return false;
+        }
+        // Check domain overlap
+        if (match1.domains && match2.domains) {
+            const domains1 = Array.isArray(match1.domains) ? match1.domains : [match1.domains];
+            const domains2 = Array.isArray(match2.domains) ? match2.domains : [match2.domains];
+            // Check if any domain pattern from match1 could match any from match2
+            let haveDomainOverlap = false;
+            for (const domain1 of domains1) {
+                for (const domain2 of domains2) {
+                    if (domain1 === domain2 ||
+                        (domain1.includes('*') || domain2.includes('*'))) {
+                        haveDomainOverlap = true;
+                        break;
+                    }
+                }
+                if (haveDomainOverlap)
+                    break;
+            }
+            if (!haveDomainOverlap) {
+                return false;
+            }
+        }
+        else if (match1.domains || match2.domains) {
+            // One has domains, the other doesn't - they could overlap
+            // The one with domains is more specific, so it's not exactly a conflict
+            return false;
+        }
+        // Check path overlap
+        if (match1.path && match2.path) {
+            // This is a simplified check - in a real implementation,
+            // you'd need to check if the path patterns could match the same paths
+            return match1.path === match2.path ||
+                match1.path.includes('*') ||
+                match2.path.includes('*');
+        }
+        else if (match1.path || match2.path) {
+            // One has a path, the other doesn't
+            return false;
+        }
+        // If we get here, the matches have significant overlap
+        return true;
+    }
+    /**
+     * Check if a route is completely shadowed by a higher priority route
+     */
+    isRouteShadowed(route, higherPriorityRoute) {
+        // If they don't have similar match criteria, no shadowing occurs
+        if (!this.areMatchesSimilar(route.match, higherPriorityRoute.match)) {
+            return false;
+        }
+        // If higher priority route has more specific criteria, no shadowing
+        if (this.isRouteMoreSpecific(higherPriorityRoute.match, route.match)) {
+            return false;
+        }
+        // If higher priority route is equally or less specific but has higher priority,
+        // it shadows the lower priority route
+        return true;
+    }
+    /**
+     * Check if route1 is more specific than route2
+     */
+    isRouteMoreSpecific(match1, match2) {
+        // Check if match1 has more specific criteria
+        let match1Points = 0;
+        let match2Points = 0;
+        // Path is the most specific
+        if (match1.path)
+            match1Points += 3;
+        if (match2.path)
+            match2Points += 3;
+        // Domain is next most specific
+        if (match1.domains)
+            match1Points += 2;
+        if (match2.domains)
+            match2Points += 2;
+        // Client IP and TLS version are least specific
+        if (match1.clientIp)
+            match1Points += 1;
+        if (match2.clientIp)
+            match2Points += 1;
+        if (match1.tlsVersion)
+            match1Points += 1;
+        if (match2.tlsVersion)
+            match2Points += 1;
+        return match1Points > match2Points;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/route-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAY5C,OAAO,EACL,eAAe,EACf,eAAe,EAChB,MAAM,wBAAwB,CAAC;AAWhC;;GAEG;AACH,MAAM,OAAO,YAAa,SAAQ,OAAO,CAAC,YAAY;IAKpD,YAAY,OAA2B;QACrC,KAAK,EAAE,CAAC;QALF,WAAM,GAAmB,EAAE,CAAC;QAC5B,YAAO,GAAgC,IAAI,GAAG,EAAE,CAAC;QAMvD,mEAAmE;QACnE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,uCAAuC;QACvC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,SAAyB,EAAE;QAC7C,yCAAyC;QACzC,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YAC9C,MAAM,SAAS,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC;YAClC,MAAM,SAAS,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC;YAClC,OAAO,SAAS,GAAG,SAAS,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEH,wCAAwC;QACxC,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;IAED;;OAEG;IACK,cAAc;QACpB,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QAErB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAEtD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC5B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBAC7B,CAAC;gBACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,eAAe,CAAC,SAAqB;QAC3C,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;YAClC,OAAO,CAAC,SAAS,CAAC,CAAC;QACrB,CAAC;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7B,0CAA0C;YAC1C,OAAO,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBAC9B,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;oBAC7B,OAAO,CAAC,IAAI,CAAC,CAAC;gBAChB,CAAC;qBAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,MAAM,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;oBACtE,2BAA2B;oBAC3B,MAAM,KAAK,GAAa,EAAE,CAAC;oBAC3B,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;wBAC1C,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBAChB,CAAC;oBACD,OAAO,KAAK,CAAC;gBACf,CAAC;gBACD,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC,CAAC;QACL,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;OAEG;IACI,iBAAiB;QACtB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,gBAAgB,CAAC,IAAY;QAClC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACtC,CAAC;IAED;;OAEG;IACK,WAAW,CAAC,OAAe,EAAE,MAAc;QACjD,gCAAgC;QAChC,MAAM,YAAY,GAAG,OAAO;aACzB,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAI,cAAc;aACvC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAI,kBAAkB;QAE9C,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,IAAI,YAAY,GAAG,EAAE,GAAG,CAAC,CAAC;QACnD,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,KAAmB,EAAE,MAAc;QAC1D,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACzB,6CAA6C;YAC7C,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC;YACjD,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO;YACrB,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAE1B,OAAO,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;IACrE,CAAC;IAED;;OAEG;IACK,iBAAiB,CAAC,KAAmB,EAAE,QAAgB;QAC7D,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC;QAEvC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,IAAI,CAAC,CAAC,qCAAqC;QACpD,CAAC;QAED,0BAA0B;QAC1B,IAAI,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1D,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;gBAC1C,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;oBAC3C,OAAO,KAAK,CAAC,CAAC,gBAAgB;gBAChC,CAAC;YACH,CAAC;QACH,CAAC;QAED,uCAAuC;QACvC,IAAI,QAAQ,CAAC,UAAU,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1D,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;gBAC1C,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;oBAC3C,OAAO,IAAI,CAAC,CAAC,gBAAgB;gBAC/B,CAAC;YACH,CAAC;YACD,OAAO,KAAK,CAAC,CAAC,yBAAyB;QACzC,CAAC;QAED,6CAA6C;QAC7C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,cAAc,CAAC,OAAe,EAAE,EAAU;QAChD,qBAAqB;QACrB,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,8CAA8C;QAC9C,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACvC,CAAC;QAED,0CAA0C;QAC1C,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YACxE,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,IAAI,YAAY,GAAG,CAAC,CAAC;YAC9C,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACxB,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACK,WAAW,CAAC,IAAY,EAAE,EAAU;QAC1C,IAAI,CAAC;YACH,0DAA0D;YAC1D,sCAAsC;YACtC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACvC,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAEhC,yCAAyC;YACzC,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YAClC,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAE1C,wBAAwB;YACxB,MAAM,OAAO,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YAExC,2BAA2B;YAC3B,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,GAAG,OAAO,CAAC,CAAC;QACrD,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,qBAAqB,EAAE,iBAAiB,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC;YAClE,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;OAEG;IACK,UAAU,CAAC,EAAU;QAC3B,MAAM,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;QAC5D,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1E,CAAC;IAED;;OAEG;IACI,iBAAiB,CAAC,OAMxB;QACC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;QAE7D,+BAA+B;QAC/B,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAElD,wDAAwD;QACxD,KAAK,MAAM,KAAK,IAAI,aAAa,EAAE,CAAC;YAClC,kCAAkC;YAClC,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC;gBACpD,SAAS;YACX,CAAC;YAED,0DAA0D;YAC1D,IAAI,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;gBAC7B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;oBAC5C,SAAS;gBACX,CAAC;YACH,CAAC;YAED,wBAAwB;YACxB,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAC/D,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC;gBAC1C,SAAS;YACX,CAAC;YAED,0BAA0B;YAC1B,IAAI,UAAU,IAAI,KAAK,CAAC,KAAK,CAAC,UAAU;gBACpC,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBACjD,SAAS;YACX,CAAC;YAED,0BAA0B;YAC1B,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,CAAC;gBAC7C,SAAS;YACX,CAAC;YAED,wCAAwC;YACxC,OAAO,EAAE,KAAK,EAAE,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,OAAe,EAAE,IAAY;QAC7C,sCAAsC;QACtC,MAAM,YAAY,GAAG,OAAO;aACzB,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAI,cAAc;aACvC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAK,kBAAkB;aAC3C,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAG,iBAAiB;QAE7C,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,IAAI,YAAY,GAAG,CAAC,CAAC;QAC9C,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACI,oBAAoB,CAAC,YAA2B;QACrD,MAAM,MAAM,GAAmB,EAAE,CAAC;QAClC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,YAAY,CAAC;QAE7C,gDAAgD;QAChD,IAAI,MAAM,GAAiB;YACzB,IAAI,EAAE,SAAS;YACf,MAAM,EAAE;gBACN,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,IAAI;gBAC5B,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,IAAI;aAC7B;SACF,CAAC;QAEF,wCAAwC;QACxC,QAAQ,UAAU,CAAC,IAAI,EAAE,CAAC;YACxB,KAAK,WAAW;gBACd,yBAAyB;gBACzB,MAAM;YACR,KAAK,mBAAmB;gBACtB,MAAM,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;gBACrC,MAAM;YACR,KAAK,yBAAyB;gBAC5B,MAAM,CAAC,GAAG,GAAG;oBACX,IAAI,EAAE,WAAW;oBACjB,WAAW,EAAE,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;wBAC1C,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG;wBACpC,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI;qBACvC,CAAC,CAAC,CAAC,MAAM;iBACX,CAAC;gBACF,MAAM;YACR,KAAK,0BAA0B;gBAC7B,MAAM,CAAC,GAAG,GAAG;oBACX,IAAI,EAAE,yBAAyB;oBAC/B,WAAW,EAAE,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;wBAC1C,GAAG,EAAE,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG;wBACpC,IAAI,EAAE,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI;qBACvC,CAAC,CAAC,CAAC,MAAM;iBACX,CAAC;gBACF,MAAM;QACV,CAAC;QAED,mCAAmC;QACnC,IAAI,UAAU,CAAC,QAAQ,EAAE,CAAC;YACxB,MAAM,CAAC,QAAQ,GAAG;gBAChB,UAAU,EAAE,UAAU,CAAC,QAAQ,CAAC,UAAU;gBAC1C,UAAU,EAAE,UAAU,CAAC,QAAQ,CAAC,UAAU;gBAC1C,cAAc,EAAE,UAAU,CAAC,QAAQ,CAAC,cAAc;aACnD,CAAC;QACJ,CAAC;QAED,mCAAmC;QACnC,IAAI,UAAU,CAAC,QAAQ,EAAE,CAAC;YACxB,MAAM,CAAC,QAAQ,GAAG;gBAChB,OAAO,EAAE,UAAU,CAAC,QAAQ,CAAC,OAAO;gBACpC,OAAO,EAAE,UAAU,CAAC,QAAQ,CAAC,OAAO;gBACpC,SAAS,EAAE,UAAU,CAAC,QAAQ,CAAC,SAAS;aACzC,CAAC;QACJ,CAAC;QAED,uDAAuD;QACvD,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAEnE,qBAAqB;QACrB,MAAM,CAAC,IAAI,CAAC;YACV,KAAK,EAAE;gBACL,KAAK,EAAE,WAAW;gBAClB,OAAO;aACR;YACD,MAAM;YACN,IAAI,EAAE,aAAa,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;SACxC,CAAC,CAAC;QAEH,8BAA8B;QAC9B,IAAI,UAAU,CAAC,IAAI,EAAE,eAAe,EAAE,CAAC;YACrC,MAAM,CAAC,IAAI,CAAC;gBACV,KAAK,EAAE;oBACL,KAAK,EAAE,EAAE;oBACT,OAAO;iBACR;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,UAAU;oBAChB,QAAQ,EAAE;wBACR,EAAE,EAAE,wBAAwB;wBAC5B,MAAM,EAAE,GAAG;qBACZ;iBACF;gBACD,IAAI,EAAE,qBAAqB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBAC/C,QAAQ,EAAE,GAAG,CAAC,gCAAgC;aAC/C,CAAC,CAAC;QACL,CAAC;QAED,+BAA+B;QAC/B,IAAI,UAAU,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC;YACpC,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;gBACnD,MAAM,CAAC,IAAI,CAAC;oBACV,KAAK,EAAE;wBACL,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC;wBAC3C,OAAO;qBACR;oBACD,MAAM;oBACN,IAAI,EAAE,cAAc,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,EAAE,QAAQ,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;iBACvE,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;OAGG;IACI,uBAAuB,CAAC,aAA8B;QAC3D,MAAM,MAAM,GAAmB,EAAE,CAAC;QAElC,uCAAuC;QACvC,KAAK,MAAM,MAAM,IAAI,aAAa,EAAE,CAAC;YACnC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC;QACpD,CAAC;QAED,qEAAqE;QACrE,MAAM,eAAe,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAC7C,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;QAEvC,IAAI,CAAC,YAAY,CAAC,CAAC,GAAG,eAAe,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACI,qBAAqB;QAC1B,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,MAAM,cAAc,GAAG,IAAI,GAAG,EAAkB,CAAC;QAEjD,sDAAsD;QACtD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAChD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAE9B,6CAA6C;gBAC7C,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;oBACvD,QAAQ,CAAC,IAAI,CACX,WAAW,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,MAAM,CAAC,IAAI,IAAI,CAAC,iCAAiC;wBACtF,mCAAmC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,EAAE,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,iBAAiB,CACzG,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,6DAA6D;QAC7D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YAC7B,MAAM,oBAAoB,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAClD,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;YAE7C,KAAK,MAAM,WAAW,IAAI,oBAAoB,EAAE,CAAC;gBAC/C,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,WAAW,CAAC,EAAE,CAAC;oBAC7C,QAAQ,CAAC,IAAI,CACX,UAAU,KAAK,CAAC,IAAI,IAAI,CAAC,mDAAmD;wBAC5E,0BAA0B,WAAW,CAAC,IAAI,IAAI,SAAS,GAAG,CAC3D,CAAC;oBACF,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACK,iBAAiB,CAAC,MAAmB,EAAE,MAAmB;QAChE,qBAAqB;QACrB,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAC3D,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAE3D,IAAI,eAAe,GAAG,KAAK,CAAC;QAC5B,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;YAC1B,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACrB,eAAe,GAAG,IAAI,CAAC;gBACvB,MAAM;YACR,CAAC;QACH,CAAC;QAED,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,uBAAuB;QACvB,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACrC,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACnF,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAEnF,sEAAsE;YACtE,IAAI,iBAAiB,GAAG,KAAK,CAAC;YAC9B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;gBAC/B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;oBAC/B,IAAI,OAAO,KAAK,OAAO;wBACnB,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;wBACrD,iBAAiB,GAAG,IAAI,CAAC;wBACzB,MAAM;oBACR,CAAC;gBACH,CAAC;gBACD,IAAI,iBAAiB;oBAAE,MAAM;YAC/B,CAAC;YAED,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;aAAM,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YAC5C,0DAA0D;YAC1D,wEAAwE;YACxE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,qBAAqB;QACrB,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;YAC/B,yDAAyD;YACzD,sEAAsE;YACtE,OAAO,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI;gBAC3B,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;gBACzB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QACnC,CAAC;aAAM,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;YACtC,oCAAoC;YACpC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,uDAAuD;QACvD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,eAAe,CAAC,KAAmB,EAAE,mBAAiC;QAC5E,iEAAiE;QACjE,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,KAAK,EAAE,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;YACpE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,oEAAoE;QACpE,IAAI,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACrE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,gFAAgF;QAChF,sCAAsC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,MAAmB,EAAE,MAAmB;QAClE,6CAA6C;QAC7C,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,YAAY,GAAG,CAAC,CAAC;QAErB,4BAA4B;QAC5B,IAAI,MAAM,CAAC,IAAI;YAAE,YAAY,IAAI,CAAC,CAAC;QACnC,IAAI,MAAM,CAAC,IAAI;YAAE,YAAY,IAAI,CAAC,CAAC;QAEnC,+BAA+B;QAC/B,IAAI,MAAM,CAAC,OAAO;YAAE,YAAY,IAAI,CAAC,CAAC;QACtC,IAAI,MAAM,CAAC,OAAO;YAAE,YAAY,IAAI,CAAC,CAAC;QAEtC,+CAA+C;QAC/C,IAAI,MAAM,CAAC,QAAQ;YAAE,YAAY,IAAI,CAAC,CAAC;QACvC,IAAI,MAAM,CAAC,QAAQ;YAAE,YAAY,IAAI,CAAC,CAAC;QAEvC,IAAI,MAAM,CAAC,UAAU;YAAE,YAAY,IAAI,CAAC,CAAC;QACzC,IAAI,MAAM,CAAC,UAAU;YAAE,YAAY,IAAI,CAAC,CAAC;QAEzC,OAAO,YAAY,GAAG,YAAY,CAAC;IACrC,CAAC;CACF"}

package/dist_ts/proxies/smart-proxy/smart-proxy.d.ts

@@ -1,9 +1,8 @@
 import * as plugins from '../../plugins.js';
-import { DomainConfigManager } from './domain-config-manager.js';
 import type { ISmartProxyOptions, IDomainConfig } from './models/interfaces.js';
-export type { ISmartProxyOptions as IPortProxySettings, IDomainConfig };
+import type { IRouteConfig } from './models/route-types.js';
 /**
- * SmartProxy - Main class that coordinates all components
+ * SmartProxy - Unified route-based API
  */
 export declare class SmartProxy extends plugins.EventEmitter {
     private netServers;
@@ -11,17 +10,21 @@ export declare class SmartProxy extends plugins.EventEmitter {
     private isShuttingDown;
     private connectionManager;
     private securityManager;
-    domainConfigManager: DomainConfigManager;
+    private domainConfigManager;
     private tlsManager;
     private networkProxyBridge;
     private timeoutManager;
     private portRangeManager;
-    private connectionHandler;
+    private routeManager;
+    private routeConnectionHandler;
     private port80Handler;
     private certProvisioner?;
+    /**
+     * Constructor that supports both legacy and route-based configuration
+     */
     constructor(settingsArg: ISmartProxyOptions);
     /**
-     * The settings for the port proxy
+     * The settings for the SmartProxy
      */
     settings: ISmartProxyOptions;
     /**
@@ -29,17 +32,25 @@ export declare class SmartProxy extends plugins.EventEmitter {
      */
     private initializePort80Handler;
     /**
-     * Start the proxy server
+     * Start the proxy server with support for both configuration types
      */
     start(): Promise<void>;
+    /**
+     * Extract domain configurations from routes for certificate provisioning
+     */
+    private extractDomainConfigsFromRoutes;
     /**
      * Stop the proxy server
      */
     stop(): Promise<void>;
     /**
-     * Updates the domain configurations for the proxy
+     * Updates the domain configurations for the proxy (legacy support)
      */
     updateDomainConfigs(newDomainConfigs: IDomainConfig[]): Promise<void>;
+    /**
+     * Update routes with new configuration (new API)
+     */
+    updateRoutes(newRoutes: IRouteConfig[]): Promise<void>;
     /**
      * Request a certificate for a specific domain
      */