@long2ice/relayx-backend 0.0.1

package/dist/services/tunnel.d.ts

@@ -0,0 +1,1235 @@
+import { z } from "zod";
+import { IpType, NodeType, Prisma, TunnelType } from "@/generated/prisma/client";
+import { TunnelQuerySchema, TunnelRequestSchema, TunnelTrafficQuerySchema } from "../schemas/request";
+import { ListenProtocol } from "../schemas/tunnel";
+import { LicenseService } from "../services/license";
+import { NodeGroupService } from "../services/node_group";
+import { RedisService } from "../services/redis";
+import { SystemConfigService } from "../services/system_config";
+type ForwardAddress = {
+    address: string;
+    weight: number;
+    host?: string | null;
+};
+export declare class TunnelService {
+    private readonly redisService;
+    private readonly nodeGroupService;
+    private readonly licenseService;
+    private readonly systemConfigService;
+    constructor(redisService: RedisService, nodeGroupService: NodeGroupService, licenseService: LicenseService, systemConfigService: SystemConfigService);
+    resetExpiredTunnels(): Promise<number>;
+    getTunnels(query: z.infer<typeof TunnelQuerySchema>, user_id?: number): Promise<{
+        data: {
+            forward_addresses: ForwardAddress[];
+            tunnel_chains: {
+                node_group_id: number;
+                node_type: import("../generated/prisma/client").$Enums.NodeType;
+            }[];
+            listen_protocol: ListenProtocol;
+            forward_addresses_protocol: ListenProtocol;
+            user: {
+                email: string;
+            };
+            in_node_group: {
+                name: string;
+                connect_ip: string | null;
+                admission: boolean;
+                traffic_rate: number;
+                nodes: {
+                    connect_ip: string;
+                }[];
+            };
+            out_node_group: {
+                name: string;
+                traffic_rate: number;
+            } | null;
+            name: string;
+            id: number;
+            load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            user_id: number;
+            status: import("../generated/prisma/client").$Enums.Status;
+            tunnel_type: import("../generated/prisma/client").$Enums.TunnelType;
+            category: import("../generated/prisma/client").$Enums.TunnelCategory;
+            listen_ip: string | null;
+            listen_port: number | null;
+            is_port_used: boolean;
+            white_list: Prisma.JsonValue | null;
+            ip_type: import("../generated/prisma/client").$Enums.IpType;
+            ip_limit: number | null;
+            bandwidth_limit: number | null;
+            traffic: number;
+            traffic_cost: number;
+            stats: Prisma.JsonValue | null;
+            proxy_protocol: boolean;
+            in_node_group_id: number;
+            out_node_group_id: number | null;
+        }[];
+        total: number;
+    }>;
+    getTunnelTraffics(user_id: number, query: z.infer<typeof TunnelTrafficQuerySchema>): Promise<{
+        data: {
+            id: number;
+            tunnel: {
+                name: string;
+                in_node_group: {
+                    name: string;
+                };
+                out_node_group: {
+                    name: string;
+                } | null;
+            };
+            traffic: number;
+            traffic_cost: number;
+            date: Date;
+        }[];
+        total: number;
+    }>;
+    getTunnelSummary(user_id: number): Promise<{
+        status: import("../generated/prisma/client").$Enums.Status;
+        count: number;
+    }[]>;
+    deleteTunnelTraffic(): Promise<number>;
+    resetPortUsed(node_group_id: number): Promise<void>;
+    pushNodeConfig(): Promise<void>;
+    getAllAvailableTunnels(): Promise<({
+        user: {
+            user_plan: ({
+                plan: {
+                    node_groups: {
+                        id: number;
+                        created_at: Date;
+                        updated_at: Date;
+                        plan_id: number;
+                        node_group_id: number;
+                    }[];
+                } & {
+                    name: string;
+                    id: number;
+                    order_by: number;
+                    created_at: Date;
+                    updated_at: Date;
+                    status: import("../generated/prisma/client").$Enums.Status;
+                    ip_limit: number | null;
+                    bandwidth_limit: number | null;
+                    traffic: number | null;
+                    price: number;
+                    max_tunnels: number | null;
+                    description: string | null;
+                    original_price: number | null;
+                    allow_custom_in_node_group: boolean;
+                    allow_custom_out_node_group: boolean;
+                    all_in_node_groups: boolean;
+                    all_out_node_groups: boolean;
+                    setup_fee: number | null;
+                    billing_cycle: import("../generated/prisma/client").$Enums.BillingCycle;
+                    renewable: boolean;
+                    stock: number | null;
+                };
+            } & {
+                id: number;
+                created_at: Date;
+                updated_at: Date;
+                user_id: number;
+                traffic: number | null;
+                plan_id: number;
+                traffic_used: number;
+                max_tunnels: number | null;
+                expired_at: Date | null;
+            }) | null;
+        } & {
+            id: number;
+            created_at: Date;
+            updated_at: Date;
+            super_admin: boolean;
+            email: string;
+            balance: number;
+            tg_id: string | null;
+            uid: string | null;
+            note: string | null;
+            parent_id: number | null;
+            referral_commission_rate: number | null;
+            referral_first_only: boolean | null;
+            auto_renew: boolean;
+            api_key: string;
+            notify_subscriptions: Prisma.JsonValue | null;
+            status: import("../generated/prisma/client").$Enums.Status;
+        };
+        in_node_group: {
+            nodes: {
+                id: number;
+                connect_ip: string;
+                order_by: number;
+                created_at: Date;
+                updated_at: Date;
+                status: import("../generated/prisma/client").$Enums.Status;
+                weight: number;
+                node_id: string;
+                version: string;
+                backup: boolean;
+                custom_line: string | null;
+                dns_status: boolean;
+                node_group_id: number;
+            }[];
+        } & {
+            name: string;
+            id: number;
+            token: string;
+            port_range: string | null;
+            connect_ip: string | null;
+            node_type: import("../generated/prisma/client").$Enums.NodeType;
+            load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+            allow_listen_protocol: boolean;
+            allow_tunnel_types: Prisma.JsonValue | null;
+            bypass_type: import("../generated/prisma/client").$Enums.BypassType;
+            bypass_list: Prisma.JsonValue | null;
+            admission: boolean;
+            block_protocols: Prisma.JsonValue | null;
+            traffic_rate: number;
+            need_out_node_group: boolean;
+            allow_out_node_groups: Prisma.JsonValue | null;
+            allow_in_node_groups: Prisma.JsonValue | null;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            user_id: number;
+        };
+        out_node_group: ({
+            nodes: {
+                id: number;
+                connect_ip: string;
+                order_by: number;
+                created_at: Date;
+                updated_at: Date;
+                status: import("../generated/prisma/client").$Enums.Status;
+                weight: number;
+                node_id: string;
+                version: string;
+                backup: boolean;
+                custom_line: string | null;
+                dns_status: boolean;
+                node_group_id: number;
+            }[];
+        } & {
+            name: string;
+            id: number;
+            token: string;
+            port_range: string | null;
+            connect_ip: string | null;
+            node_type: import("../generated/prisma/client").$Enums.NodeType;
+            load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+            allow_listen_protocol: boolean;
+            allow_tunnel_types: Prisma.JsonValue | null;
+            bypass_type: import("../generated/prisma/client").$Enums.BypassType;
+            bypass_list: Prisma.JsonValue | null;
+            admission: boolean;
+            block_protocols: Prisma.JsonValue | null;
+            traffic_rate: number;
+            need_out_node_group: boolean;
+            allow_out_node_groups: Prisma.JsonValue | null;
+            allow_in_node_groups: Prisma.JsonValue | null;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            user_id: number;
+        }) | null;
+        tunnel_chains: ({
+            node_group: {
+                nodes: {
+                    id: number;
+                    connect_ip: string;
+                    order_by: number;
+                    created_at: Date;
+                    updated_at: Date;
+                    status: import("../generated/prisma/client").$Enums.Status;
+                    weight: number;
+                    node_id: string;
+                    version: string;
+                    backup: boolean;
+                    custom_line: string | null;
+                    dns_status: boolean;
+                    node_group_id: number;
+                }[];
+            } & {
+                name: string;
+                id: number;
+                token: string;
+                port_range: string | null;
+                connect_ip: string | null;
+                node_type: import("../generated/prisma/client").$Enums.NodeType;
+                load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                allow_listen_protocol: boolean;
+                allow_tunnel_types: Prisma.JsonValue | null;
+                bypass_type: import("../generated/prisma/client").$Enums.BypassType;
+                bypass_list: Prisma.JsonValue | null;
+                admission: boolean;
+                block_protocols: Prisma.JsonValue | null;
+                traffic_rate: number;
+                need_out_node_group: boolean;
+                allow_out_node_groups: Prisma.JsonValue | null;
+                allow_in_node_groups: Prisma.JsonValue | null;
+                order_by: number;
+                created_at: Date;
+                updated_at: Date;
+                user_id: number;
+            };
+        } & {
+            id: number;
+            node_type: import("../generated/prisma/client").$Enums.NodeType;
+            node_group_id: number;
+            tunnel_id: number;
+        })[];
+    } & {
+        name: string;
+        id: number;
+        load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+        order_by: number;
+        created_at: Date;
+        updated_at: Date;
+        user_id: number;
+        status: import("../generated/prisma/client").$Enums.Status;
+        tunnel_type: import("../generated/prisma/client").$Enums.TunnelType;
+        category: import("../generated/prisma/client").$Enums.TunnelCategory;
+        listen_ip: string | null;
+        listen_port: number | null;
+        listen_protocol: Prisma.JsonValue | null;
+        is_port_used: boolean;
+        white_list: Prisma.JsonValue | null;
+        forward_addresses: Prisma.JsonValue;
+        forward_addresses_protocol: Prisma.JsonValue | null;
+        ip_type: import("../generated/prisma/client").$Enums.IpType;
+        ip_limit: number | null;
+        bandwidth_limit: number | null;
+        traffic: number;
+        traffic_cost: number;
+        stats: Prisma.JsonValue | null;
+        proxy_protocol: boolean;
+        in_node_group_id: number;
+        out_node_group_id: number | null;
+    })[]>;
+    filterAvailableTunnels<T extends {
+        user_id: number;
+        in_node_group: {
+            user_id: number | null;
+        };
+        out_node_group: {
+            user_id: number | null;
+        } | null;
+        user: {
+            user_plan: {
+                traffic_used: number;
+                max_tunnels: number | null;
+                traffic: number | null;
+                plan: {
+                    max_tunnels: number | null;
+                    traffic: number | null;
+                    all_in_node_groups: boolean;
+                    all_out_node_groups: boolean;
+                    node_groups: {
+                        node_group_id: number;
+                    }[];
+                };
+            } | null;
+        };
+    }>(tunnels: T[], in_node_group_id?: number, out_node_group_id?: number): T[];
+    getAvailableTunnels(in_node_group_id?: number, out_node_group_id?: number): Promise<({
+        user: {
+            user_plan: ({
+                plan: {
+                    node_groups: {
+                        id: number;
+                        created_at: Date;
+                        updated_at: Date;
+                        plan_id: number;
+                        node_group_id: number;
+                    }[];
+                } & {
+                    name: string;
+                    id: number;
+                    order_by: number;
+                    created_at: Date;
+                    updated_at: Date;
+                    status: import("../generated/prisma/client").$Enums.Status;
+                    ip_limit: number | null;
+                    bandwidth_limit: number | null;
+                    traffic: number | null;
+                    price: number;
+                    max_tunnels: number | null;
+                    description: string | null;
+                    original_price: number | null;
+                    allow_custom_in_node_group: boolean;
+                    allow_custom_out_node_group: boolean;
+                    all_in_node_groups: boolean;
+                    all_out_node_groups: boolean;
+                    setup_fee: number | null;
+                    billing_cycle: import("../generated/prisma/client").$Enums.BillingCycle;
+                    renewable: boolean;
+                    stock: number | null;
+                };
+            } & {
+                id: number;
+                created_at: Date;
+                updated_at: Date;
+                user_id: number;
+                traffic: number | null;
+                plan_id: number;
+                traffic_used: number;
+                max_tunnels: number | null;
+                expired_at: Date | null;
+            }) | null;
+        } & {
+            id: number;
+            created_at: Date;
+            updated_at: Date;
+            super_admin: boolean;
+            email: string;
+            balance: number;
+            tg_id: string | null;
+            uid: string | null;
+            note: string | null;
+            parent_id: number | null;
+            referral_commission_rate: number | null;
+            referral_first_only: boolean | null;
+            auto_renew: boolean;
+            api_key: string;
+            notify_subscriptions: Prisma.JsonValue | null;
+            status: import("../generated/prisma/client").$Enums.Status;
+        };
+        in_node_group: {
+            nodes: {
+                id: number;
+                connect_ip: string;
+                order_by: number;
+                created_at: Date;
+                updated_at: Date;
+                status: import("../generated/prisma/client").$Enums.Status;
+                weight: number;
+                node_id: string;
+                version: string;
+                backup: boolean;
+                custom_line: string | null;
+                dns_status: boolean;
+                node_group_id: number;
+            }[];
+        } & {
+            name: string;
+            id: number;
+            token: string;
+            port_range: string | null;
+            connect_ip: string | null;
+            node_type: import("../generated/prisma/client").$Enums.NodeType;
+            load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+            allow_listen_protocol: boolean;
+            allow_tunnel_types: Prisma.JsonValue | null;
+            bypass_type: import("../generated/prisma/client").$Enums.BypassType;
+            bypass_list: Prisma.JsonValue | null;
+            admission: boolean;
+            block_protocols: Prisma.JsonValue | null;
+            traffic_rate: number;
+            need_out_node_group: boolean;
+            allow_out_node_groups: Prisma.JsonValue | null;
+            allow_in_node_groups: Prisma.JsonValue | null;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            user_id: number;
+        };
+        out_node_group: ({
+            nodes: {
+                id: number;
+                connect_ip: string;
+                order_by: number;
+                created_at: Date;
+                updated_at: Date;
+                status: import("../generated/prisma/client").$Enums.Status;
+                weight: number;
+                node_id: string;
+                version: string;
+                backup: boolean;
+                custom_line: string | null;
+                dns_status: boolean;
+                node_group_id: number;
+            }[];
+        } & {
+            name: string;
+            id: number;
+            token: string;
+            port_range: string | null;
+            connect_ip: string | null;
+            node_type: import("../generated/prisma/client").$Enums.NodeType;
+            load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+            allow_listen_protocol: boolean;
+            allow_tunnel_types: Prisma.JsonValue | null;
+            bypass_type: import("../generated/prisma/client").$Enums.BypassType;
+            bypass_list: Prisma.JsonValue | null;
+            admission: boolean;
+            block_protocols: Prisma.JsonValue | null;
+            traffic_rate: number;
+            need_out_node_group: boolean;
+            allow_out_node_groups: Prisma.JsonValue | null;
+            allow_in_node_groups: Prisma.JsonValue | null;
+            order_by: number;
+            created_at: Date;
+            updated_at: Date;
+            user_id: number;
+        }) | null;
+    } & {
+        name: string;
+        id: number;
+        load_balance_type: import("../generated/prisma/client").$Enums.LoadBalanceType;
+        order_by: number;
+        created_at: Date;
+        updated_at: Date;
+        user_id: number;
+        status: import("../generated/prisma/client").$Enums.Status;
+        tunnel_type: import("../generated/prisma/client").$Enums.TunnelType;
+        category: import("../generated/prisma/client").$Enums.TunnelCategory;
+        listen_ip: string | null;
+        listen_port: number | null;
+        listen_protocol: Prisma.JsonValue | null;
+        is_port_used: boolean;
+        white_list: Prisma.JsonValue | null;
+        forward_addresses: Prisma.JsonValue;
+        forward_addresses_protocol: Prisma.JsonValue | null;
+        ip_type: import("../generated/prisma/client").$Enums.IpType;
+        ip_limit: number | null;
+        bandwidth_limit: number | null;
+        traffic: number;
+        traffic_cost: number;
+        stats: Prisma.JsonValue | null;
+        proxy_protocol: boolean;
+        in_node_group_id: number;
+        out_node_group_id: number | null;
+    })[]>;
+    getConnectIP(connect_ip: string, ip_type: IpType): string | undefined;
+    getTunnelChains(tunnel_id: number, ip_type: IpType): Promise<{
+        in_hops: {
+            name: string;
+            selector: {
+                strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                healthCheck: boolean;
+            };
+            nodes: {
+                name: string;
+                addr: string;
+                connector: {
+                    type: string;
+                };
+                dialer: {
+                    type: string;
+                };
+                metadata: {
+                    weight: string;
+                    backup: boolean;
+                };
+            }[];
+        }[];
+        out_hops: {
+            name: string;
+            selector: {
+                strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                healthCheck: boolean;
+            };
+            nodes: {
+                name: string;
+                addr: string;
+                connector: {
+                    type: string;
+                };
+                dialer: {
+                    type: string;
+                };
+                metadata: {
+                    weight: string;
+                    backup: boolean;
+                };
+            }[];
+        }[];
+    }>;
+    getOutListenFromCache(outListens: Record<string, string>, node_id: number, type: string): string | null;
+    getTunnelChainsFromTunnel(tunnel: {
+        id: number;
+        ip_type: IpType;
+        tunnel_chains: {
+            id: number;
+            node_type: NodeType;
+            node_group: {
+                load_balance_type: string;
+                nodes: {
+                    id: number;
+                    node_id: string;
+                    connect_ip: string;
+                    weight: number;
+                    backup: boolean;
+                }[];
+            };
+        }[];
+    }, outListens: Record<string, string>): {
+        in_hops: {
+            name: string;
+            selector: {
+                strategy: string;
+                healthCheck: boolean;
+            };
+            nodes: {
+                name: string;
+                addr: string;
+                connector: {
+                    type: string;
+                };
+                dialer: {
+                    type: string;
+                };
+                metadata: {
+                    weight: string;
+                    backup: boolean;
+                };
+            }[];
+        }[];
+        out_hops: {
+            name: string;
+            selector: {
+                strategy: string;
+                healthCheck: boolean;
+            };
+            nodes: {
+                name: string;
+                addr: string;
+                connector: {
+                    type: string;
+                };
+                dialer: {
+                    type: string;
+                };
+                metadata: {
+                    weight: string;
+                    backup: boolean;
+                };
+            }[];
+        }[];
+    };
+    getNodeConfig(node_group_id: number, node_type: NodeType, port_range: string | null, allow_listen_protocol: boolean, allTunnels: Awaited<ReturnType<typeof this.getAllAvailableTunnels>>, outListens: Record<string, string>): Promise<{
+        log: {
+            level: string;
+        };
+        tls: {
+            validity: string;
+            commonName: string;
+            organization: string;
+        };
+        services: ({
+            addr: string;
+            climiter: string | undefined;
+            limiter: string | undefined;
+            observer: string;
+            forwarder: {
+                nodes: {
+                    name: string;
+                    addr: string;
+                    filter: {
+                        host: string;
+                    } | undefined;
+                    metadata: {
+                        weight: string;
+                    };
+                }[];
+                selector: {
+                    strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                    healthCheck: boolean;
+                };
+            } | undefined;
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+                proxyProtocol: number | undefined;
+            };
+            name: string;
+            bypass: string | undefined;
+            admission: string | undefined;
+            handler: {
+                type: string;
+                chain: string | undefined;
+                metadata: {
+                    sniffing: boolean | undefined;
+                    "block.protocol": string | number | boolean | Prisma.JsonObject | Prisma.JsonArray | undefined;
+                    proxyProtocol: number | undefined;
+                    bind?: undefined;
+                };
+                auth: {
+                    username: string;
+                    password: string;
+                } | undefined;
+            };
+            listener: {
+                type: string;
+                metadata?: undefined;
+            };
+        } | {
+            addr: string;
+            climiter: string | undefined;
+            limiter: string | undefined;
+            observer: string;
+            forwarder: {
+                nodes: {
+                    name: string;
+                    addr: string;
+                    filter: {
+                        host: string;
+                    } | undefined;
+                    metadata: {
+                        weight: string;
+                    };
+                }[];
+                selector: {
+                    strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                    healthCheck: boolean;
+                };
+            } | undefined;
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+                proxyProtocol: number | undefined;
+            };
+            name: string;
+            bypass: string | undefined;
+            admission: string | undefined;
+            handler: {
+                type: string;
+                chain: string | undefined;
+                auth: {
+                    username: string;
+                    password: string;
+                } | undefined;
+                metadata?: undefined;
+            };
+            listener: {
+                type: string;
+                metadata: {
+                    keepalive: boolean;
+                };
+            };
+        } | {
+            name: import("../generated/prisma/client").$Enums.TunnelType;
+            bypass: string | undefined;
+            addr: string;
+            handler: {
+                type: string;
+                metadata: {
+                    bind: boolean;
+                    sniffing?: undefined;
+                    "block.protocol"?: undefined;
+                    proxyProtocol?: undefined;
+                };
+                chain?: undefined;
+                auth?: undefined;
+            };
+            listener: {
+                type: import("../generated/prisma/client").$Enums.TunnelType;
+                metadata: {
+                    keepalive: boolean | undefined;
+                };
+            };
+            metadata?: undefined;
+        } | {
+            name: string;
+            bypass: string | undefined;
+            addr: string;
+            listener: {
+                type: string;
+                metadata?: undefined;
+            };
+            handler: {
+                type: string;
+                chain?: undefined;
+                metadata?: undefined;
+                auth?: undefined;
+            };
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+            };
+        })[];
+        chains: {
+            name: string;
+            hops: {
+                name: string;
+                selector: {
+                    strategy: string;
+                    healthCheck: boolean;
+                };
+                nodes: {
+                    name: string;
+                    addr: string;
+                    connector: {
+                        type: string;
+                    };
+                    dialer: {
+                        type: string;
+                    };
+                    metadata: {
+                        weight: string;
+                        backup: boolean;
+                    };
+                }[];
+            }[];
+        }[];
+        climiters: {
+            name: string | undefined;
+            limits: string[];
+        }[];
+        limiters: {
+            name: string | undefined;
+            limits: string[];
+        }[];
+        bypasses: {
+            name: string;
+            whitelist: boolean;
+            matchers: string[];
+        }[];
+        admissions: {
+            name: string;
+            whitelist: boolean;
+            matchers: string[];
+        }[];
+        observers: {
+            name: string;
+            plugin: {
+                type: string;
+                addr: string;
+            };
+        }[];
+    } | {
+        log: {
+            level: string;
+        };
+        tls: {
+            validity: string;
+            commonName: string;
+            organization: string;
+        };
+        chains: {
+            name: string;
+            hops: {
+                name: string;
+                selector: {
+                    strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                    healthCheck: boolean;
+                };
+                nodes: {
+                    name: string;
+                    addr: string;
+                    connector: {
+                        type: string;
+                    };
+                    dialer: {
+                        metadata?: {
+                            key: string;
+                            host: string;
+                        } | undefined;
+                        type: import("../generated/prisma/client").$Enums.TunnelType;
+                    };
+                    metadata: {
+                        weight: string;
+                        backup: boolean;
+                    };
+                }[];
+            }[];
+        }[];
+        climiters: {
+            name: string | undefined;
+            limits: string[];
+        }[];
+        limiters: {
+            name: string | undefined;
+            limits: string[];
+        }[];
+        services: ({
+            name: import("../generated/prisma/client").$Enums.TunnelType;
+            addr: string;
+            handler: {
+                type: string;
+                metadata: {
+                    sniffing: boolean | undefined;
+                    "block.protocol": string[] | undefined;
+                };
+            };
+            listener: {
+                type: import("../generated/prisma/client").$Enums.TunnelType;
+                metadata: {
+                    key?: string | undefined;
+                    keepalive?: boolean | undefined;
+                };
+                chain?: undefined;
+            };
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+            };
+        } | {
+            addr: string;
+            climiter: string | undefined;
+            limiter: string | undefined;
+            observer: string;
+            forwarder: {
+                nodes: {
+                    name: string;
+                    addr: string;
+                    filter: {
+                        host: string;
+                    } | undefined;
+                    metadata: {
+                        weight: string;
+                    };
+                }[];
+                selector: {
+                    strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                    healthCheck: boolean;
+                };
+            };
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+            };
+            name: string;
+            handler: {
+                type: string;
+                metadata?: undefined;
+            };
+            listener: {
+                type: string;
+                chain: string;
+                metadata?: undefined;
+            };
+        })[];
+        observers: {
+            name: string;
+            plugin: {
+                type: string;
+                addr: string;
+            };
+        }[];
+    }>;
+    getInNodeConfig(in_node_group_id: number, port_range: string | null, allow_listen_protocol: boolean, allTunnels: Awaited<ReturnType<typeof this.getAllAvailableTunnels>>, outListens: Record<string, string>): Promise<{
+        log: {
+            level: string;
+        };
+        tls: {
+            validity: string;
+            commonName: string;
+            organization: string;
+        };
+        services: ({
+            addr: string;
+            climiter: string | undefined;
+            limiter: string | undefined;
+            observer: string;
+            forwarder: {
+                nodes: {
+                    name: string;
+                    addr: string;
+                    filter: {
+                        host: string;
+                    } | undefined;
+                    metadata: {
+                        weight: string;
+                    };
+                }[];
+                selector: {
+                    strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                    healthCheck: boolean;
+                };
+            } | undefined;
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+                proxyProtocol: number | undefined;
+            };
+            name: string;
+            bypass: string | undefined;
+            admission: string | undefined;
+            handler: {
+                type: string;
+                chain: string | undefined;
+                metadata: {
+                    sniffing: boolean | undefined;
+                    "block.protocol": string | number | boolean | Prisma.JsonObject | Prisma.JsonArray | undefined;
+                    proxyProtocol: number | undefined;
+                    bind?: undefined;
+                };
+                auth: {
+                    username: string;
+                    password: string;
+                } | undefined;
+            };
+            listener: {
+                type: string;
+                metadata?: undefined;
+            };
+        } | {
+            addr: string;
+            climiter: string | undefined;
+            limiter: string | undefined;
+            observer: string;
+            forwarder: {
+                nodes: {
+                    name: string;
+                    addr: string;
+                    filter: {
+                        host: string;
+                    } | undefined;
+                    metadata: {
+                        weight: string;
+                    };
+                }[];
+                selector: {
+                    strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                    healthCheck: boolean;
+                };
+            } | undefined;
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+                proxyProtocol: number | undefined;
+            };
+            name: string;
+            bypass: string | undefined;
+            admission: string | undefined;
+            handler: {
+                type: string;
+                chain: string | undefined;
+                auth: {
+                    username: string;
+                    password: string;
+                } | undefined;
+                metadata?: undefined;
+            };
+            listener: {
+                type: string;
+                metadata: {
+                    keepalive: boolean;
+                };
+            };
+        } | {
+            name: import("../generated/prisma/client").$Enums.TunnelType;
+            bypass: string | undefined;
+            addr: string;
+            handler: {
+                type: string;
+                metadata: {
+                    bind: boolean;
+                    sniffing?: undefined;
+                    "block.protocol"?: undefined;
+                    proxyProtocol?: undefined;
+                };
+                chain?: undefined;
+                auth?: undefined;
+            };
+            listener: {
+                type: import("../generated/prisma/client").$Enums.TunnelType;
+                metadata: {
+                    keepalive: boolean | undefined;
+                };
+            };
+            metadata?: undefined;
+        } | {
+            name: string;
+            bypass: string | undefined;
+            addr: string;
+            listener: {
+                type: string;
+                metadata?: undefined;
+            };
+            handler: {
+                type: string;
+                chain?: undefined;
+                metadata?: undefined;
+                auth?: undefined;
+            };
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+            };
+        })[];
+        chains: {
+            name: string;
+            hops: {
+                name: string;
+                selector: {
+                    strategy: string;
+                    healthCheck: boolean;
+                };
+                nodes: {
+                    name: string;
+                    addr: string;
+                    connector: {
+                        type: string;
+                    };
+                    dialer: {
+                        type: string;
+                    };
+                    metadata: {
+                        weight: string;
+                        backup: boolean;
+                    };
+                }[];
+            }[];
+        }[];
+        climiters: {
+            name: string | undefined;
+            limits: string[];
+        }[];
+        limiters: {
+            name: string | undefined;
+            limits: string[];
+        }[];
+        bypasses: {
+            name: string;
+            whitelist: boolean;
+            matchers: string[];
+        }[];
+        admissions: {
+            name: string;
+            whitelist: boolean;
+            matchers: string[];
+        }[];
+        observers: {
+            name: string;
+            plugin: {
+                type: string;
+                addr: string;
+            };
+        }[];
+    }>;
+    getOutNodeConfig(out_node_group_id: number, port_range: string | null, allTunnels: Awaited<ReturnType<typeof this.getAllAvailableTunnels>>, outListens: Record<string, string>): Promise<{
+        log: {
+            level: string;
+        };
+        tls: {
+            validity: string;
+            commonName: string;
+            organization: string;
+        };
+        chains: {
+            name: string;
+            hops: {
+                name: string;
+                selector: {
+                    strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                    healthCheck: boolean;
+                };
+                nodes: {
+                    name: string;
+                    addr: string;
+                    connector: {
+                        type: string;
+                    };
+                    dialer: {
+                        metadata?: {
+                            key: string;
+                            host: string;
+                        } | undefined;
+                        type: import("../generated/prisma/client").$Enums.TunnelType;
+                    };
+                    metadata: {
+                        weight: string;
+                        backup: boolean;
+                    };
+                }[];
+            }[];
+        }[];
+        climiters: {
+            name: string | undefined;
+            limits: string[];
+        }[];
+        limiters: {
+            name: string | undefined;
+            limits: string[];
+        }[];
+        services: ({
+            name: import("../generated/prisma/client").$Enums.TunnelType;
+            addr: string;
+            handler: {
+                type: string;
+                metadata: {
+                    sniffing: boolean | undefined;
+                    "block.protocol": string[] | undefined;
+                };
+            };
+            listener: {
+                type: import("../generated/prisma/client").$Enums.TunnelType;
+                metadata: {
+                    key?: string | undefined;
+                    keepalive?: boolean | undefined;
+                };
+                chain?: undefined;
+            };
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+            };
+        } | {
+            addr: string;
+            climiter: string | undefined;
+            limiter: string | undefined;
+            observer: string;
+            forwarder: {
+                nodes: {
+                    name: string;
+                    addr: string;
+                    filter: {
+                        host: string;
+                    } | undefined;
+                    metadata: {
+                        weight: string;
+                    };
+                }[];
+                selector: {
+                    strategy: import("../generated/prisma/client").$Enums.LoadBalanceType;
+                    healthCheck: boolean;
+                };
+            };
+            metadata: {
+                enableStats: boolean;
+                "observer.resetTraffic": boolean;
+                "observer.period": string;
+            };
+            name: string;
+            handler: {
+                type: string;
+                metadata?: undefined;
+            };
+            listener: {
+                type: string;
+                chain: string;
+                metadata?: undefined;
+            };
+        })[];
+        observers: {
+            name: string;
+            plugin: {
+                type: string;
+                addr: string;
+            };
+        }[];
+    }>;
+    checkTunnel(tunnel_type: TunnelType, in_node_group_id: number, out_node_group_id: number | null, listen_port: number | null, id: number | null): Promise<void>;
+    updateTunnelOrder(id: number, order_by: number, user_id: number): Promise<void>;
+    createTunnel(user_id: number, data: z.infer<typeof TunnelRequestSchema>, max_tunnels: number | null): Promise<void>;
+    testTunnel(tunnel_id: number, ip: string, user_id?: number): Promise<{
+        from: string;
+        to: string;
+        results: unknown[];
+    }[]>;
+}
+export {};