@push.rocks/smartproxy 21.1.7 → 22.6.0

package/dist_ts/proxies/smart-proxy/utils/route-helpers/dynamic-helpers.js

@@ -0,0 +1,89 @@
+/**
+ * Dynamic Route Helper Functions
+ *
+ * This module provides utility functions for creating dynamic routes
+ * with context-based host and port mapping.
+ */
+/**
+ * Create a helper function that applies a port offset
+ * @param offset The offset to apply to the matched port
+ * @returns A function that adds the offset to the matched port
+ */
+export function createPortOffset(offset) {
+    return (context) => context.port + offset;
+}
+/**
+ * Create a port mapping route with context-based port function
+ * @param options Port mapping route options
+ * @returns Route configuration object
+ */
+export function createPortMappingRoute(options) {
+    // Create route match
+    const match = {
+        ports: options.sourcePortRange,
+        domains: options.domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [{
+                host: options.targetHost,
+                port: options.portMapper
+            }]
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Port Mapping Route for ${options.domains || 'all domains'}`,
+        priority: options.priority,
+        ...options
+    };
+}
+/**
+ * Create a simple offset port mapping route
+ * @param options Offset port mapping route options
+ * @returns Route configuration object
+ */
+export function createOffsetPortMappingRoute(options) {
+    return createPortMappingRoute({
+        sourcePortRange: options.ports,
+        targetHost: options.targetHost,
+        portMapper: (context) => context.port + options.offset,
+        name: options.name || `Offset Mapping (${options.offset > 0 ? '+' : ''}${options.offset}) for ${options.domains || 'all domains'}`,
+        domains: options.domains,
+        priority: options.priority,
+        ...options
+    });
+}
+/**
+ * Create a dynamic route with context-based host and port mapping
+ * @param options Dynamic route options
+ * @returns Route configuration object
+ */
+export function createDynamicRoute(options) {
+    // Create route match
+    const match = {
+        ports: options.ports,
+        domains: options.domains,
+        path: options.path,
+        clientIp: options.clientIp
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [{
+                host: options.targetHost,
+                port: options.portMapper
+            }]
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Dynamic Route for ${options.domains || 'all domains'}`,
+        priority: options.priority,
+        ...options
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/utils/route-helpers/http-helpers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * HTTP Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTP route configurations.
+ */
+import type { IRouteConfig } from '../../models/route-types.js';
+/**
+ * Create an HTTP-only route configuration
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: Partial<IRouteConfig>): IRouteConfig;

package/dist_ts/proxies/smart-proxy/utils/route-helpers/http-helpers.js

@@ -0,0 +1,32 @@
+/**
+ * HTTP Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTP route configurations.
+ */
+/**
+ * Create an HTTP-only route configuration
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 80,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target]
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTP Route for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1oZWxwZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vdHMvcHJveGllcy9zbWFydC1wcm94eS91dGlscy9yb3V0ZS1oZWxwZXJzL2h0dHAtaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBSUg7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLGVBQWUsQ0FDN0IsT0FBMEIsRUFDMUIsTUFBaUQsRUFDakQsVUFBaUMsRUFBRTtJQUVuQyxxQkFBcUI7SUFDckIsTUFBTSxLQUFLLEdBQWdCO1FBQ3pCLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxFQUFFLEtBQUssSUFBSSxFQUFFO1FBQ2pDLE9BQU87S0FDUixDQUFDO0lBRUYsc0JBQXNCO0lBQ3RCLE1BQU0sTUFBTSxHQUFpQjtRQUMzQixJQUFJLEVBQUUsU0FBUztRQUNmLE9BQU8sRUFBRSxDQUFDLE1BQU0sQ0FBQztLQUNsQixDQUFDO0lBRUYsMEJBQTBCO0lBQzFCLE9BQU87UUFDTCxLQUFLO1FBQ0wsTUFBTTtRQUNOLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSSxJQUFJLGtCQUFrQixLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLEVBQUU7UUFDL0YsR0FBRyxPQUFPO0tBQ1gsQ0FBQztBQUNKLENBQUMifQ==

package/dist_ts/proxies/smart-proxy/utils/route-helpers/https-helpers.d.ts

@@ -0,0 +1,68 @@
+/**
+ * HTTPS Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTPS route configurations
+ * including TLS termination and passthrough routes.
+ */
+import type { IRouteConfig } from '../../models/route-types.js';
+/**
+ * Create an HTTPS route with TLS termination
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpsTerminateRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    reencrypt?: boolean;
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create an HTTP to HTTPS redirect route
+ * @param domains Domain(s) to match
+ * @param httpsPort HTTPS port to redirect to (default: 443)
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpToHttpsRedirect(domains: string | string[], httpsPort?: number, options?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Create an HTTPS passthrough route (SNI-based forwarding without TLS termination)
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createHttpsPassthroughRoute(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: Partial<IRouteConfig>): IRouteConfig;
+/**
+ * Create a complete HTTPS server with HTTP to HTTPS redirects
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional configuration options
+ * @returns Array of two route configurations (HTTPS and HTTP redirect)
+ */
+export declare function createCompleteHttpsServer(domains: string | string[], target: {
+    host: string | string[];
+    port: number;
+}, options?: {
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    reencrypt?: boolean;
+    name?: string;
+    [key: string]: any;
+}): IRouteConfig[];

package/dist_ts/proxies/smart-proxy/utils/route-helpers/https-helpers.js

@@ -0,0 +1,117 @@
+/**
+ * HTTPS Route Helper Functions
+ *
+ * This module provides utility functions for creating HTTPS route configurations
+ * including TLS termination and passthrough routes.
+ */
+import { SocketHandlers } from './socket-handlers.js';
+/**
+ * Create an HTTPS route with TLS termination
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpsTerminateRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.httpsPort || 443,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target],
+        tls: {
+            mode: options.reencrypt ? 'terminate-and-reencrypt' : 'terminate',
+            certificate: options.certificate || 'auto'
+        }
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTPS Route for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an HTTP to HTTPS redirect route
+ * @param domains Domain(s) to match
+ * @param httpsPort HTTPS port to redirect to (default: 443)
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpToHttpsRedirect(domains, httpsPort = 443, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 80,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'socket-handler',
+        socketHandler: SocketHandlers.httpRedirect(`https://{domain}:${httpsPort}{path}`, 301)
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create an HTTPS passthrough route (SNI-based forwarding without TLS termination)
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export function createHttpsPassthroughRoute(domains, target, options = {}) {
+    // Create route match
+    const match = {
+        ports: options.match?.ports || 443,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target],
+        tls: {
+            mode: 'passthrough'
+        }
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `HTTPS Passthrough for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...options
+    };
+}
+/**
+ * Create a complete HTTPS server with HTTP to HTTPS redirects
+ * @param domains Domain(s) to match
+ * @param target Target host and port
+ * @param options Additional configuration options
+ * @returns Array of two route configurations (HTTPS and HTTP redirect)
+ */
+export function createCompleteHttpsServer(domains, target, options = {}) {
+    // Create the HTTPS route
+    const httpsRoute = createHttpsTerminateRoute(domains, target, options);
+    // Create the HTTP redirect route
+    const httpRedirectRoute = createHttpToHttpsRedirect(domains, 
+    // Extract the HTTPS port from the HTTPS route - ensure it's a number
+    typeof options.httpsPort === 'number' ? options.httpsPort :
+        Array.isArray(options.httpsPort) ? options.httpsPort[0] : 443, {
+        // Set the HTTP port
+        match: {
+            ports: options.httpPort || 80,
+            domains
+        },
+        name: `HTTP to HTTPS Redirect for ${Array.isArray(domains) ? domains.join(', ') : domains}`
+    });
+    return [httpsRoute, httpRedirectRoute];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/utils/route-helpers/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Route Helper Functions
+ *
+ * This module provides utility functions for creating route configurations for common scenarios.
+ * These functions aim to simplify the creation of route configurations for typical use cases.
+ *
+ * This barrel file re-exports all helper functions for backwards compatibility.
+ */
+export { createHttpRoute } from './http-helpers.js';
+export { createHttpsTerminateRoute, createHttpToHttpsRedirect, createHttpsPassthroughRoute, createCompleteHttpsServer } from './https-helpers.js';
+export { createWebSocketRoute } from './websocket-helpers.js';
+export { createLoadBalancerRoute, createSmartLoadBalancer } from './load-balancer-helpers.js';
+export { createNfTablesRoute, createNfTablesTerminateRoute, createCompleteNfTablesHttpsServer } from './nftables-helpers.js';
+export { createPortOffset, createPortMappingRoute, createOffsetPortMappingRoute, createDynamicRoute } from './dynamic-helpers.js';
+export { createApiRoute, createApiGatewayRoute } from './api-helpers.js';
+export { addRateLimiting, addBasicAuth, addJwtAuth } from './security-helpers.js';
+export { SocketHandlers, createSocketHandlerRoute } from './socket-handlers.js';

package/dist_ts/proxies/smart-proxy/utils/route-helpers/index.js

@@ -0,0 +1,27 @@
+/**
+ * Route Helper Functions
+ *
+ * This module provides utility functions for creating route configurations for common scenarios.
+ * These functions aim to simplify the creation of route configurations for typical use cases.
+ *
+ * This barrel file re-exports all helper functions for backwards compatibility.
+ */
+// HTTP helpers
+export { createHttpRoute } from './http-helpers.js';
+// HTTPS helpers
+export { createHttpsTerminateRoute, createHttpToHttpsRedirect, createHttpsPassthroughRoute, createCompleteHttpsServer } from './https-helpers.js';
+// WebSocket helpers
+export { createWebSocketRoute } from './websocket-helpers.js';
+// Load balancer helpers
+export { createLoadBalancerRoute, createSmartLoadBalancer } from './load-balancer-helpers.js';
+// NFTables helpers
+export { createNfTablesRoute, createNfTablesTerminateRoute, createCompleteNfTablesHttpsServer } from './nftables-helpers.js';
+// Dynamic routing helpers
+export { createPortOffset, createPortMappingRoute, createOffsetPortMappingRoute, createDynamicRoute } from './dynamic-helpers.js';
+// API helpers
+export { createApiRoute, createApiGatewayRoute } from './api-helpers.js';
+// Security helpers
+export { addRateLimiting, addBasicAuth, addJwtAuth } from './security-helpers.js';
+// Socket handlers
+export { SocketHandlers, createSocketHandlerRoute } from './socket-handlers.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL3JvdXRlLWhlbHBlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVILGVBQWU7QUFDZixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFcEQsZ0JBQWdCO0FBQ2hCLE9BQU8sRUFDTCx5QkFBeUIsRUFDekIseUJBQXlCLEVBQ3pCLDJCQUEyQixFQUMzQix5QkFBeUIsRUFDMUIsTUFBTSxvQkFBb0IsQ0FBQztBQUU1QixvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFOUQsd0JBQXdCO0FBQ3hCLE9BQU8sRUFDTCx1QkFBdUIsRUFDdkIsdUJBQXVCLEVBQ3hCLE1BQU0sNEJBQTRCLENBQUM7QUFFcEMsbUJBQW1CO0FBQ25CLE9BQU8sRUFDTCxtQkFBbUIsRUFDbkIsNEJBQTRCLEVBQzVCLGlDQUFpQyxFQUNsQyxNQUFNLHVCQUF1QixDQUFDO0FBRS9CLDBCQUEwQjtBQUMxQixPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLHNCQUFzQixFQUN0Qiw0QkFBNEIsRUFDNUIsa0JBQWtCLEVBQ25CLE1BQU0sc0JBQXNCLENBQUM7QUFFOUIsY0FBYztBQUNkLE9BQU8sRUFDTCxjQUFjLEVBQ2QscUJBQXFCLEVBQ3RCLE1BQU0sa0JBQWtCLENBQUM7QUFFMUIsbUJBQW1CO0FBQ25CLE9BQU8sRUFDTCxlQUFlLEVBQ2YsWUFBWSxFQUNaLFVBQVUsRUFDWCxNQUFNLHVCQUF1QixDQUFDO0FBRS9CLGtCQUFrQjtBQUNsQixPQUFPLEVBQ0wsY0FBYyxFQUNkLHdCQUF3QixFQUN6QixNQUFNLHNCQUFzQixDQUFDIn0=

package/dist_ts/proxies/smart-proxy/utils/route-helpers/load-balancer-helpers.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Load Balancer Route Helper Functions
+ *
+ * This module provides utility functions for creating load balancer route configurations.
+ */
+import type { IRouteConfig, TPortRange, IRouteContext } from '../../models/route-types.js';
+/**
+ * Create a load balancer route (round-robin between multiple backend hosts)
+ * @param domains Domain(s) to match
+ * @param backendsOrHosts Array of backend servers OR array of host strings (legacy)
+ * @param portOrOptions Port number (legacy) OR options object
+ * @param options Additional route options (legacy)
+ * @returns Route configuration object
+ */
+export declare function createLoadBalancerRoute(domains: string | string[], backendsOrHosts: Array<{
+    host: string;
+    port: number;
+}> | string[], portOrOptions?: number | {
+    tls?: {
+        mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+        certificate?: 'auto' | {
+            key: string;
+            cert: string;
+        };
+    };
+    useTls?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+    algorithm?: 'round-robin' | 'least-connections' | 'ip-hash';
+    healthCheck?: {
+        path: string;
+        interval: number;
+        timeout: number;
+        unhealthyThreshold: number;
+        healthyThreshold: number;
+    };
+    [key: string]: any;
+}, options?: {
+    tls?: {
+        mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+        certificate?: 'auto' | {
+            key: string;
+            cert: string;
+        };
+    };
+    [key: string]: any;
+}): IRouteConfig;
+/**
+ * Create a smart load balancer with dynamic domain-based backend selection
+ * @param options Smart load balancer options
+ * @returns Route configuration object
+ */
+export declare function createSmartLoadBalancer(options: {
+    ports: TPortRange;
+    domainTargets: Record<string, string | string[]>;
+    portMapper: (context: IRouteContext) => number;
+    name?: string;
+    defaultTarget?: string | string[];
+    priority?: number;
+    [key: string]: any;
+}): IRouteConfig;

package/dist_ts/proxies/smart-proxy/utils/route-helpers/load-balancer-helpers.js

@@ -0,0 +1,105 @@
+/**
+ * Load Balancer Route Helper Functions
+ *
+ * This module provides utility functions for creating load balancer route configurations.
+ */
+/**
+ * Create a load balancer route (round-robin between multiple backend hosts)
+ * @param domains Domain(s) to match
+ * @param backendsOrHosts Array of backend servers OR array of host strings (legacy)
+ * @param portOrOptions Port number (legacy) OR options object
+ * @param options Additional route options (legacy)
+ * @returns Route configuration object
+ */
+export function createLoadBalancerRoute(domains, backendsOrHosts, portOrOptions, options) {
+    // Handle legacy signature: (domains, hosts[], port, options)
+    let backends;
+    let finalOptions;
+    if (Array.isArray(backendsOrHosts) && backendsOrHosts.length > 0 && typeof backendsOrHosts[0] === 'string') {
+        // Legacy signature
+        const hosts = backendsOrHosts;
+        const port = portOrOptions;
+        backends = hosts.map(host => ({ host, port }));
+        finalOptions = options || {};
+    }
+    else {
+        // New signature
+        backends = backendsOrHosts;
+        finalOptions = portOrOptions || {};
+    }
+    // Extract hosts and ensure all backends use the same port
+    const port = backends[0].port;
+    const hosts = backends.map(backend => backend.host);
+    // Create route match
+    const match = {
+        ports: finalOptions.match?.ports || (finalOptions.tls || finalOptions.useTls ? 443 : 80),
+        domains
+    };
+    // Create route target
+    const target = {
+        host: hosts,
+        port
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [target]
+    };
+    // Add TLS configuration if provided
+    if (finalOptions.tls || finalOptions.useTls) {
+        action.tls = {
+            mode: finalOptions.tls?.mode || 'terminate',
+            certificate: finalOptions.tls?.certificate || finalOptions.certificate || 'auto'
+        };
+    }
+    // Add load balancing options
+    if (finalOptions.algorithm || finalOptions.healthCheck) {
+        action.loadBalancing = {
+            algorithm: finalOptions.algorithm || 'round-robin',
+            healthCheck: finalOptions.healthCheck
+        };
+    }
+    // Create the route config
+    return {
+        match,
+        action,
+        name: finalOptions.name || `Load Balancer for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+        ...finalOptions
+    };
+}
+/**
+ * Create a smart load balancer with dynamic domain-based backend selection
+ * @param options Smart load balancer options
+ * @returns Route configuration object
+ */
+export function createSmartLoadBalancer(options) {
+    // Extract all domain keys to create the match criteria
+    const domains = Object.keys(options.domainTargets);
+    // Create the smart host selector function
+    const hostSelector = (context) => {
+        const domain = context.domain || '';
+        return options.domainTargets[domain] || options.defaultTarget || 'localhost';
+    };
+    // Create route match
+    const match = {
+        ports: options.ports,
+        domains
+    };
+    // Create route action
+    const action = {
+        type: 'forward',
+        targets: [{
+                host: hostSelector,
+                port: options.portMapper
+            }]
+    };
+    // Create the route config
+    return {
+        match,
+        action,
+        name: options.name || `Smart Load Balancer for ${domains.join(', ')}`,
+        priority: options.priority,
+        ...options
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/utils/route-helpers/nftables-helpers.d.ts

@@ -0,0 +1,83 @@
+/**
+ * NFTables Route Helper Functions
+ *
+ * This module provides utility functions for creating NFTables-based route configurations
+ * for high-performance packet forwarding at the kernel level.
+ */
+import type { IRouteConfig, TPortRange } from '../../models/route-types.js';
+/**
+ * Create an NFTables-based route for high-performance packet forwarding
+ * @param nameOrDomains Name or domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createNfTablesRoute(nameOrDomains: string | string[], target: {
+    host: string;
+    port: number | 'preserve';
+}, options?: {
+    ports?: TPortRange;
+    protocol?: 'tcp' | 'udp' | 'all';
+    preserveSourceIP?: boolean;
+    ipAllowList?: string[];
+    ipBlockList?: string[];
+    maxRate?: string;
+    priority?: number;
+    useTls?: boolean;
+    tableName?: string;
+    useIPSets?: boolean;
+    useAdvancedNAT?: boolean;
+}): IRouteConfig;
+/**
+ * Create an NFTables-based TLS termination route
+ * @param nameOrDomains Name or domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Route configuration object
+ */
+export declare function createNfTablesTerminateRoute(nameOrDomains: string | string[], target: {
+    host: string;
+    port: number | 'preserve';
+}, options?: {
+    ports?: TPortRange;
+    protocol?: 'tcp' | 'udp' | 'all';
+    preserveSourceIP?: boolean;
+    ipAllowList?: string[];
+    ipBlockList?: string[];
+    maxRate?: string;
+    priority?: number;
+    tableName?: string;
+    useIPSets?: boolean;
+    useAdvancedNAT?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+}): IRouteConfig;
+/**
+ * Create a complete NFTables-based HTTPS setup with HTTP redirect
+ * @param nameOrDomains Name or domain(s) to match
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns Array of two route configurations (HTTPS and HTTP redirect)
+ */
+export declare function createCompleteNfTablesHttpsServer(nameOrDomains: string | string[], target: {
+    host: string;
+    port: number | 'preserve';
+}, options?: {
+    httpPort?: TPortRange;
+    httpsPort?: TPortRange;
+    protocol?: 'tcp' | 'udp' | 'all';
+    preserveSourceIP?: boolean;
+    ipAllowList?: string[];
+    ipBlockList?: string[];
+    maxRate?: string;
+    priority?: number;
+    tableName?: string;
+    useIPSets?: boolean;
+    useAdvancedNAT?: boolean;
+    certificate?: 'auto' | {
+        key: string;
+        cert: string;
+    };
+}): IRouteConfig[];