@push.rocks/smartdns 7.6.1 → 7.8.0

package/dist_ts_server/classes.dnsserver.d.ts

@@ -32,52 +32,65 @@ interface LetsEncryptOptions {
 }
 export declare class DnsServer {
     private options;
-    private udpServer;
-    private httpsServer;
+    private bridge;
     private handlers;
-    private dnsSec;
-    private dnskeyRecord;
-    private keyTag;
-    private udpServerInitialized;
-    private httpsServerInitialized;
+    private bridgeSpawned;
+    private httpsServer;
+    private udpServer;
     constructor(options: IDnsServerOptions);
     /**
-     * Initialize servers without binding to ports
-     * This is called automatically by start() or can be called manually
+     * Register a DNS handler for a domain pattern and record types.
+     */
+    registerHandler(domainPattern: string, recordTypes: string[], handler: (question: dnsPacket.Question) => DnsAnswer | null): void;
+    /**
+     * Unregister a specific handler.
+     */
+    unregisterHandler(domainPattern: string, recordTypes: string[]): boolean;
+    /**
+     * Start the DNS server.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the DNS server.
+     */
+    stop(): Promise<void>;
+    /**
+     * Initialize servers (no-op with Rust bridge, kept for API compatibility).
      */
     initializeServers(): void;
     /**
-     * Initialize UDP server without binding
+     * Initialize UDP server (no-op with Rust bridge).
      */
     initializeUdpServer(): void;
     /**
-     * Initialize HTTPS server without binding
+     * Initialize HTTPS server (no-op with Rust bridge).
      */
     initializeHttpsServer(): void;
     /**
-     * Handle a raw TCP socket for HTTPS/DoH
-     * @param socket The TCP socket to handle
+     * Handle a raw TCP socket for HTTPS/DoH.
+     * In Rust mode, this is not directly supported — use processRawDnsPacket instead.
      */
     handleHttpsSocket(socket: plugins.net.Socket): void;
     /**
-     * Handle a UDP message manually
-     * @param msg The DNS message buffer
-     * @param rinfo Remote address information
-     * @param responseCallback Optional callback to handle the response
+     * Handle a UDP message manually.
      */
     handleUdpMessage(msg: Buffer, rinfo: plugins.dgram.RemoteInfo, responseCallback?: (response: Buffer, rinfo: plugins.dgram.RemoteInfo) => void): void;
     /**
-     * Process a raw DNS packet and return the response
-     * This is useful for custom transport implementations
+     * Process a raw DNS packet and return the response.
+     * Synchronous version using the TypeScript fallback (for backward compatibility).
      */
     processRawDnsPacket(packet: Buffer): Buffer;
-    registerHandler(domainPattern: string, recordTypes: string[], handler: (question: dnsPacket.Question) => DnsAnswer | null): void;
-    unregisterHandler(domainPattern: string, recordTypes: string[]): boolean;
+    /**
+     * Process a raw DNS packet asynchronously via Rust bridge.
+     */
+    processRawDnsPacketAsync(packet: Buffer): Promise<Buffer>;
+    /**
+     * Process a DNS request locally (TypeScript handler resolution).
+     * Used as fallback and for pre-bridge-spawn calls.
+     */
+    processDnsRequest(request: dnsPacket.Packet): dnsPacket.Packet;
     /**
      * Retrieve SSL certificate for specified domains using Let's Encrypt
-     * @param domainNames Array of domain names to include in the certificate
-     * @param options Configuration options for Let's Encrypt
-     * @returns Object containing certificate, private key, and success status
      */
     retrieveSslCertificate(domainNames: string[], options?: LetsEncryptOptions): Promise<{
         cert: string;
@@ -85,41 +98,15 @@ export declare class DnsServer {
         success: boolean;
     }>;
     /**
-     * Create DNS record value for the ACME challenge
-     */
-    private getDnsRecordValueForChallenge;
-    /**
-     * Restart the HTTPS server with the new certificate
-     */
-    private restartHttpsServer;
-    /**
-     * Filter domains to include only those the server is authoritative for
+     * Filter domains to include only those the server is authoritative for.
      */
     filterAuthorizedDomains(domainNames: string[]): string[];
     /**
-     * Validate if a string is a valid IP address (IPv4 or IPv6)
+     * Resolve a DNS query event from Rust using TypeScript handlers.
      */
+    private resolveQuery;
+    private getDnsRecordValueForChallenge;
     private isValidIpAddress;
-    /**
-     * Determine if an IP address is IPv6
-     */
-    private isIPv6;
-    /**
-     * Check if the server is authoritative for a domain
-     */
     private isAuthorizedForDomain;
-    processDnsRequest(request: dnsPacket.Packet): dnsPacket.Packet;
-    private isDnssecRequested;
-    private generateRRSIG;
-    private serializeRRset;
-    private serializeRData;
-    private parseDNSKEYRecord;
-    private computeKeyTag;
-    private handleHttpsRequest;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    private qtypeToNumber;
-    private classToNumber;
-    private nameToBuffer;
 }
 export {};