// Query via a string IP or a binary IP (Buffer type) parsed by parseIP
search(ip: string | Buffer): string;

import {IPv4, IPv6} from 'ip2region.js';

// For IPv4: Set xdb path to the v4 xdb file, and set IP version to Version.IPv4
let dbPath  = "../../data/ip2region_v4.xdb";  // or your ipv4 xdb path
let version = IPv4;

// For IPv6: Set xdb path to the v6 xdb file, and set IP version to Version.IPv6
let dbPath  = "../../data/ip2region_v6.xdb";  // or your ipv6 xdb path
let version = IPv6;

// The IP version of the xdb specified by dbPath must match the version specified; otherwise, an error will occur during execution.
// Note: The following demonstrations directly use the dbPath and version variables.

import {verifyFromFile} from 'ip2region.js';

try {
    verifyFromFile(dbPath);
} catch (e) {
    // Applicability verification failed!!!
    // The current query client implementation is not applicable for queries on the xdb file specified by dbPath.
    // You should stop the service and use a suitable xdb file or upgrade to a Searcher implementation that fits dbPath.
    console.log(`binding is not applicable for xdb file '${dbPath}': ${e.message}`);
    return;
}

// Verification passed. The current Searcher can be safely used for query operations on the xdb pointed to by dbPath.

import {newWithFileOnly} from 'ip2region.js';

// 1. Create a file-only query object using the version and dbPath mentioned above
let searcher;
try {
    searcher = newWithFileOnly(version, dbPath);
} catch(e) {
    console.log(`failed to newWithFileOnly: ${err.message}`);
    return;
}


// 2. Query; the interface is the same for both IPv4 and IPv6 addresses
let ip = "1.2.3.4";
// ip = "240e:3b7:3272:d8d0:db09:c067:8d59:539e";  // IPv6
try {
    let region = await searcher.search(ip);
    console.log(`search(${ip}): {region: ${region}, ioCount: ${searcher.getIOCount()}}`);
} catch(e) {
    console.log(`${err.message}`);
}

// 3. Close resources
searcher.close();

// Note: Each thread needs to create an independent Searcher object separately

import {loadVectorIndexFromFile, newWithVectorIndex} from 'ip2region.js';

// 1. Pre-load VectorIndex cache from dbPath and keep this data as a global variable for subsequent repeated use.
let vIndex;
try {
    vIndex = loadVectorIndexFromFile(dbPath);
} catch (e) {
    console.log(`failed to load vector index from ${dbPath}: ${e.message}`);
    return;
}

// 2. Create a query object with VectorIndex cache using the global vIndex.
let searcher;
try {
    searcher = newWithVectorIndex(version, dbPath, vIndex);
} catch(e) {
    console.log(`failed to newWithVectorIndex: ${err.message}`);
    return;
}


// 3. Query; the interface is the same for both IPv4 and IPv6 addresses
let ip = "1.2.3.4";
// ip = "240e:3b7:3272:d8d0:db09:c067:8d59:539e";  // IPv6
try {
    let region = await searcher.search(ip);
    console.log(`search(${ip}): {region: ${region}, ioCount: ${searcher.getIOCount()}}`);
} catch(e) {
    console.log(`${err.message}`);
}

// 4. Close resources
searcher.close();

// Note: Each thread needs to create a separate independent Searcher object, but they all share the global read-only vIndex cache.

import {loadContentFromFile, newWithBuffer} from 'ip2region.js';

// 1. Load the entire xdb from dbPath into memory.
let cBuffer;
try {
    cBuffer = loadContentFromFile(dbPath);
} catch (e) {
    console.log(`failed to load content from ${dbPath}: ${e.message}`);
    return;
}

// 2. Use the cBuff above to create a completely memory-based query object.
let searcher;
try {
    searcher = newWithBuffer(version, cBuffer);
} catch(e) {
    console.log(`failed to newWithBuffer: ${err.message}`);
    return;
}

// 3. Query; the interface is the same for both IPv4 and IPv6 addresses
let ip = "1.2.3.4";
// ip = "240e:3b7:3272:d8d0:db09:c067:8d59:539e";  // IPv6
try {
    let region = await searcher.search(ip);
    console.log(`search(${ip}): {region: ${region}`);
} catch(e) {
    console.log(`${err.message}`);
}
        
// 4. Close resources - This searcher object is safe for concurrent use; close the searcher only when the entire service shuts down.
// searcher.close();

// Note: For concurrent use, the query object created with the entire xdb data cache can be safely used concurrently, meaning you can make this searcher object a global object for cross-thread access.