import { LogLevel } from '@nestjs/common';
import { ExtractionOptions, ExtractionSchema, HtmlFetchResponse, HtmlParserOptions, PaginationPage, ProxyConfig } from './types';
/**
 * HTML Parser Service for NestJS
 *
 * A powerful service for parsing HTML content with support for:
 * - XPath and CSS selector extraction
 * - Proxy configuration with authentication
 * - Random user agent rotation
 * - Retry logic with configurable delays
 * - Verbose logging for debugging
 * - Rich response metadata including headers and status codes
 *
 * @example
 * ```typescript
 * const parser = new HtmlParserService();
 *
 * // Fetch HTML with options
 * const response = await parser.fetchHtml('https://example.com', {
 *   timeout: 10000,
 *   useRandomUserAgent: true,
 *   verbose: true
 * });
 *
 * // Extract data using XPath
 * const title = parser.extractSingle(response.data, '//title/text()');
 *
 * // Extract structured data
 * const articles = parser.extractStructuredList(response.data, '//article', {
 *   title: { selector: './/h2/text()', type: 'xpath' },
 *   link: { selector: './/a', type: 'xpath', attribute: 'href' }
 * });
 * ```
 */
export declare class HtmlParserService {
    private readonly logger;
    private readonly loggerLevel;
    /**
     * Default configuration options for HTML parsing operations
     */
    private defaultOptions;
    /**
     * Initialize the HTML Parser Service
     */
    constructor(loggerLevel?: LogLevel | Array<LogLevel>);
    /**
     * Helper to check if a log level should be logged
     * Fixed to properly handle both single and array logger configurations
     */
    private shouldLog;
    /**
     * Helper method to log with proper level checking
     */
    private logWithLevel;
    /**
     * Suppress console output when verbose is false
     */
    private suppressConsole;
    /**
     * Restore console output
     */
    private restoreConsole;
    /**
     * Fetch HTML content from a URL with comprehensive configuration options
     *
     * Supports proxy configuration, custom headers, user agent rotation,
     * retry logic, SSL error handling, and rich response metadata. Automatically handles
     * different proxy types (HTTP, HTTPS, SOCKS4, SOCKS5) and provides
     * detailed error information on failures.
     *
     * @param url - The URL to fetch HTML content from
     * @param options - Configuration options for the request
     * @param options.timeout - Request timeout in milliseconds (default: 10000)
     * @param options.headers - Custom headers to send with the request
     * @param options.userAgent - Custom user agent string
     * @param options.useRandomUserAgent - Use a random user agent instead of specified one
     * @param options.proxy - Proxy configuration for the request
     * @param options.retries - Number of retry attempts on failure (default: 3)
     * @param options.retryDelay - Delay between retries in milliseconds (default: 1000)
     * @param options.verbose - Enable verbose logging for debugging
     * @param options.rejectUnauthorized - Reject unauthorized SSL certificates (default: true)
     * @param options.ignoreSSLErrors - Skip SSL certificate verification entirely
     * @param options.disableServerIdentityCheck - Disable server name indication (SNI) validation
     * @param options.maxRedirects - Maximum number of redirects to follow (default: 5)
     * @param options.retryOnErrors - Configure retry behavior for specific error types
     *
     * @returns Promise resolving to HtmlFetchResponse with HTML content, headers, and status
     *
     * @throws Error when all retry attempts fail
     *
     * @example
     * ```typescript
     * // Basic usage
     * const response = await parser.fetchHtml('https://example.com');
     *
     * // Handle SSL errors for sites with invalid certificates
     * const response = await parser.fetchHtml('https://self-signed-site.com', {
     *   rejectUnauthorized: false,
     *   retryOnErrors: { ssl: true }
     * });
     *
     * // Ignore SSL completely (use with caution)
     * const response = await parser.fetchHtml('https://expired-cert-site.com', {
     *   ignoreSSLErrors: true
     * });
     *
     * // Disable only server identity validation (for hostname mismatches)
     * const response = await parser.fetchHtml('https://hostname-mismatch-site.com', {
     *   disableServerIdentityCheck: true
     * });
     *
     * // Robust configuration for unreliable sites
     * const response = await parser.fetchHtml('https://unreliable-site.com', {
     *   retries: 5,
     *   retryDelay: 2000,
     *   timeout: 15000,
     *   retryOnErrors: {
     *     ssl: true,
     *     timeout: true,
     *     dns: true,
     *     connectionRefused: true
     *   }
     * });
     * ```
     */
    fetchHtml(url: string, options?: HtmlParserOptions): Promise<HtmlFetchResponse>;
    /**
     * Create a proxy agent based on proxy configuration
     */
    private createProxyAgent;
    /**
     * Detect proxy type from URL
     */
    private detectProxyType;
    /**
     * Delay function for retries
     */
    private delay;
    /**
     * Generate a random user agent string
     *
     * Returns a realistic user agent string selected randomly from a pool
     * of current browser user agents. Useful for avoiding detection when
     * scraping websites that block requests with default user agents.
     * Falls back to a default user agent if the random generation fails.
     *
     * @returns Promise resolving to a random user agent string
     *
     * @example
     * ```typescript
     * // Get a random user agent
     * const userAgent = await parser.getRandomUserAgent();
     * console.log(userAgent);
     * // Result: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36..."
     *
     * // Use with fetchHtml for better stealth
     * const response = await parser.fetchHtml('https://example.com', {
     *   useRandomUserAgent: true  // This uses getRandomUserAgent() internally
     * });
     *
     * // Or manually
     * const customUserAgent = await parser.getRandomUserAgent();
     * const response = await parser.fetchHtml('https://example.com', {
     *   userAgent: customUserAgent
     * });
     * ```
     */
    getRandomUserAgent(): Promise<string>;
    /**
     * Test proxy connection and authentication
     *
     * Validates that a proxy configuration is working by attempting
     * to fetch a test URL through the proxy. Useful for verifying
     * proxy credentials and connectivity before using it for actual
     * HTML parsing operations.
     *
     * @param proxy - Proxy configuration to test
     * @param testUrl - URL to use for testing proxy connection (default: 'https://httpbin.org/ip')
     *
     * @returns Promise resolving to true if proxy works, false otherwise
     *
     * @example
     * ```typescript
     * const proxyConfig = {
     *   url: 'http://proxy.example.com:8080',
     *   username: 'user',
     *   password: 'pass'
     * };
     *
     * const isWorking = await parser.testProxy(proxyConfig);
     * if (isWorking) {
     *   console.log('Proxy is working!');
     * } else {
     *   console.log('Proxy failed or authentication invalid');
     * }
     *
     * // Test with custom URL
     * const isWorking = await parser.testProxy(proxyConfig, 'https://example.com');
     * ```
     */
    testProxy(proxy: ProxyConfig, testUrl?: string): Promise<boolean>;
    /**
     * Extract a single value from HTML using XPath or CSS selectors
     *
     * Extracts the first matching element's text content or attribute value.
     * Supports both XPath expressions (recommended) and CSS selectors.
     * Can extract specific attributes from elements or their text content.
     *
     * @param html - HTML content to parse
     * @param selector - XPath expression or CSS selector to locate the element
     * @param type - Type of selector: 'xpath' (default) or 'css'
     * @param attribute - HTML attribute to extract (optional, extracts text content if not specified)
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     *
     * @returns The extracted text/attribute value, or null if no match found
     *
     * @example
     * ```typescript
     * const html = '<div><h1 id="title">Welcome</h1><a href="/home">Home</a></div>';
     *
     * // Extract text content using XPath
     * const title = parser.extractSingle(html, '//h1[@id="title"]/text()');
     * // Result: "Welcome"
     *
     * // Extract attribute using XPath
     * const link = parser.extractSingle(html, '//a', 'xpath', 'href');
     * // Result: "/home"
     *
     * // Extract using CSS selector
     * const titleCSS = parser.extractSingle(html, 'h1#title', 'css');
     * // Result: "Welcome"
     *
     * // With type safety and transformation
     * const id = parser.extractSingle<number>(html, '//div/@data-id', 'xpath', undefined, {
     *   transform: (value: string) => parseInt(value)
     * });
     * // Result: number | null
     *
     * // With verbose logging
     * const result = parser.extractSingle(html, '//h1/text()', 'xpath', undefined, { verbose: true });
     * ```
     */
    extractSingle<T = string>(html: string, selector: string, type?: 'xpath' | 'css', attribute?: string, options?: ExtractionOptions): T | null;
    /**
     * Extract multiple values from HTML using XPath or CSS selectors
     *
     * Extracts text content or attribute values from all matching elements.
     * Returns an array of strings containing all found values. Supports
     * both XPath expressions and CSS selectors with attribute extraction.
     *
     * @param html - HTML content to parse
     * @param selector - XPath expression or CSS selector to locate elements
     * @param type - Type of selector: 'xpath' (default) or 'css'
     * @param attribute - HTML attribute to extract (optional, extracts text content if not specified)
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     *
     * @returns Array of extracted text/attribute values (empty array if no matches)
     *
     * @example
     * ```typescript
     * const html = `
     *   <ul>
     *     <li><a href="/page1">Page 1</a></li>
     *     <li><a href="/page2">Page 2</a></li>
     *     <li><a href="/page3">Page 3</a></li>
     *   </ul>
     * `;
     *
     * // Extract all link texts using XPath
     * const linkTexts = parser.extractMultiple(html, '//a/text()');
     * // Result: ["Page 1", "Page 2", "Page 3"]
     *
     * // Extract all href attributes using XPath
     * const hrefs = parser.extractMultiple(html, '//a', 'xpath', 'href');
     * // Result: ["/page1", "/page2", "/page3"]
     *
     * // Extract using CSS selector
     * const linksCSS = parser.extractMultiple(html, 'li a', 'css');
     * // Result: ["Page 1", "Page 2", "Page 3"]
     *
     * // With type safety and transformation
     * const ids = parser.extractMultiple<number>(html, '//li/@data-id', 'xpath', undefined, {
     *   transform: (value: string) => parseInt(value)
     * });
     * // Result: number[]
     *
     * // With verbose logging
     * const results = parser.extractMultiple(html, '//li', 'xpath', undefined, { verbose: true });
     * ```
     */
    extractMultiple<T = string>(html: string, selector: string, type?: 'xpath' | 'css', attribute?: string, options?: ExtractionOptions): T[];
    /**
     * Extract text content from HTML elements
     *
     * Convenience method specifically for extracting text content from elements.
     * This is equivalent to calling extractSingle without an attribute parameter.
     * Useful when you only need the text content and want clearer intent.
     *
     * @param html - HTML content to parse
     * @param selector - XPath expression or CSS selector to locate the element
     * @param type - Type of selector: 'xpath' (default) or 'css'
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     *
     * @returns The extracted text content, or null if no match found
     *
     * @example
     * ```typescript
     * const html = '<div><h1>Main Title</h1><p>Description text</p></div>';
     *
     * // Extract heading text
     * const title = parser.extractText(html, '//h1');
     * // Result: "Main Title"
     *
     * // Extract paragraph text using CSS
     * const description = parser.extractText(html, 'p', 'css');
     * // Result: "Description text"
     *
     * // With type safety and transformation
     * const wordCount = parser.extractText<number>(html, '//p', 'xpath', {
     *   transform: (text: string) => text.split(' ').length
     * });
     * // Result: number | null
     *
     * // With verbose logging
     * const text = parser.extractText(html, '//p/text()', 'xpath', { verbose: true });
     * ```
     */
    extractText<T = string>(html: string, selector: string, type?: 'xpath' | 'css', options?: ExtractionOptions): T | null;
    /**
     * Extract attribute values from multiple HTML elements
     *
     * Convenience method for extracting a specific attribute from all matching elements.
     * This is equivalent to calling extractMultiple with an attribute parameter.
     * Returns all attribute values from elements that match the selector.
     *
     * @param html - HTML content to parse
     * @param selector - XPath expression or CSS selector to locate elements
     * @param attribute - HTML attribute name to extract
     * @param type - Type of selector: 'xpath' (default) or 'css'
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     *
     * @returns Array of attribute values (empty array if no matches or no attribute)
     *
     * @example
     * ```typescript
     * const html = `
     *   <nav>
     *     <a href="/home" title="Home Page">Home</a>
     *     <a href="/about" title="About Us">About</a>
     *     <a href="/contact" title="Contact Form">Contact</a>
     *   </nav>
     * `;
     *
     * // Extract all href attributes
     * const links = parser.extractAttributes(html, '//a', 'href');
     * // Result: ["/home", "/about", "/contact"]
     *
     * // Extract all title attributes
     * const titles = parser.extractAttributes(html, '//a', 'title', 'xpath');
     * // Result: ["Home Page", "About Us", "Contact Form"]
     *
     * // Using CSS selector
     * const hrefs = parser.extractAttributes(html, 'nav a', 'href', 'css');
     * // Result: ["/home", "/about", "/contact"]
     *
     * // With type safety and transformation
     * const ids = parser.extractAttributes<number>(html, '//img', 'data-id', 'xpath', {
     *   transform: (value: string) => parseInt(value)
     * });
     * // Result: number[]
     * ```
     */
    extractAttributes<T = string>(html: string, selector: string, attribute: string, type?: 'xpath' | 'css', options?: ExtractionOptions): T[];
    /**
     * Check if elements exist in HTML content
     *
     * Tests whether the specified selector matches any elements in the HTML.
     * Useful for conditional logic based on element presence or for validating
     * HTML structure before attempting extractions.
     *
     * @param html - HTML content to search
     * @param selector - XPath expression or CSS selector to test
     * @param type - Type of selector: 'xpath' (default) or 'css'
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     *
     * @returns true if at least one element matches, false otherwise
     *
     * @example
     * ```typescript
     * const html = '<div><h1>Title</h1><p class="content">Text</p></div>';
     *
     * // Check if title exists
     * const hasTitle = parser.exists(html, '//h1');
     * // Result: true
     *
     * // Check if specific class exists
     * const hasContent = parser.exists(html, '//p[@class="content"]');
     * // Result: true
     *
     * // Check for non-existent element
     * const hasFooter = parser.exists(html, '//footer');
     * // Result: false
     *
     * // Using CSS selector
     * const hasContentCSS = parser.exists(html, 'p.content', 'css');
     * // Result: true
     *
     * // Conditional extraction based on existence
     * if (parser.exists(html, '//nav')) {
     *   const navigation = parser.extractStructured(html, navSchema);
     * }
     * ```
     */
    exists(html: string, selector: string, type?: 'xpath' | 'css', options?: {
        verbose?: boolean;
    }): boolean;
    /**
     * Count the number of matching elements in HTML content
     *
     * Returns the total number of elements that match the specified selector.
     * Useful for pagination, validation, or determining the size of data sets
     * before processing them.
     *
     * @param html - HTML content to search
     * @param selector - XPath expression or CSS selector to count
     * @param type - Type of selector: 'xpath' (default) or 'css'
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     *
     * @returns Number of matching elements (0 if no matches)
     *
     * @example
     * ```typescript
     * const html = `
     *   <ul>
     *     <li>Item 1</li>
     *     <li>Item 2</li>
     *     <li>Item 3</li>
     *   </ul>
     *   <div class="highlight">Special</div>
     * `;
     *
     * // Count list items
     * const itemCount = parser.count(html, '//li');
     * // Result: 3
     *
     * // Count elements with specific class
     * const highlightCount = parser.count(html, '//div[@class="highlight"]');
     * // Result: 1
     *
     * // Count using CSS selector
     * const listItemsCSS = parser.count(html, 'ul li', 'css');
     * // Result: 3
     *
     * // Use count for conditional processing
     * const articleCount = parser.count(html, '//article');
     * if (articleCount > 10) {
     *   console.log('Large dataset detected, processing in batches');
     * }
     * ```
     */
    count(html: string, selector: string, type?: 'xpath' | 'css', options?: {
        verbose?: boolean;
    }): number;
    /**
     * Extract structured data from HTML using a schema definition
     *
     * Applies a schema object to extract multiple related fields from HTML content.
     * Each field in the schema defines its own selector, type, optional attribute,
     * transformation function, and now supports 'multiple' and 'raw' flags for array and raw HTML extraction.
     *
     * If a schema field includes `multiple: true`, the extracted value for that field
     * will be an array of results (with transform applied to each item if provided).
     * If a schema field includes `raw: true`, the extracted value will be the raw HTML of the matched element(s).
     * Otherwise, a single value is returned as before.
     *
     * @param html - HTML content to parse
     * @param schema - Schema object defining fields to extract (see ExtractionSchema)
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     *
     * @returns Object with extracted data matching the schema structure. Fields with
     *          `multiple: true` will be arrays, `raw: true` will be raw HTML, others will be single values.
     *
     * @example
     * ```typescript
     * const html = `
     *   <article>
     *     <h1>Product Name</h1>
     *     <span class="price">$29.99</span>
     *     <img src="/image.jpg" alt="Product">
     *     <div class="rating" data-stars="4">★★★★☆</div>
     *     <div class="tags">
     *       <span class="tag">electronics</span>
     *       <span class="tag">gadget</span>
     *     </div>
     *   </article>
     * `;
     *
     * // Define typed interface
     * interface Product {
     *   title: string;
     *   price: number;
     *   image: string;
     *   rating: number;
     *   tags: string[]; // <-- array field
     *   titleHtml: string; // <-- raw HTML field
     * }
     *
     * const productSchema: ExtractionSchema<Product> = {
     *   title: {
     *     selector: '//h1/text()',
     *     type: 'xpath'
     *   },
     *   price: {
     *     selector: '//span[@class="price"]/text()',
     *     type: 'xpath',
     *     transform: (price) => parseFloat(price.replace('$', ''))
     *   },
     *   image: {
     *     selector: '//img',
     *     type: 'xpath',
     *     attribute: 'src'
     *   },
     *   rating: {
     *     selector: '//div[@class="rating"]',
     *     type: 'xpath',
     *     attribute: 'data-stars',
     *     transform: (stars) => parseInt(stars)
     *   },
     *   tags: {
     *     selector: '//span[@class="tag"]/text()',
     *     type: 'xpath',
     *     multiple: true // <-- NEW: array extraction
     *   },
     *   titleHtml: {
     *     selector: '//h1',
     *     type: 'xpath',
     *     raw: true // <-- NEW: raw HTML extraction
     *   }
     * };
     *
     * const product = parser.extractStructured<Product>(html, productSchema);
     * // Result: Product type with full type safety
     * // {
     * //   title: "Product Name",
     * //   price: 29.99,
     * //   image: "/image.jpg",
     * //   rating: 4,
     * //   tags: ["electronics", "gadget"], // <-- array result
     * //   titleHtml: "<h1>Product Name</h1>" // <-- raw HTML result
     * // }
     * ```
     */
    extractStructured<T = Record<string, any>>(html: string, schema: ExtractionSchema<T>, options?: {
        verbose?: boolean;
        baseUrl?: string;
    }): T;
    /**
     * Extract structured data directly from a container node (preserves XPath context)
     *
     * This method works directly with DOM nodes to preserve the XPath evaluation context,
     * allowing relative XPath expressions like './td[2]//a/@href' to work correctly.
     *
     * @param containerNode - The DOM node to extract data from
     * @param schema - Schema object defining fields to extract
     * @param options - Parsing options
     */
    private extractStructuredFromNode;
    /**
     * Extract array of structured data from repeating HTML elements
     *
     * For each container, applies the schema as in extractStructured. If a schema field
     * includes `multiple: true`, the extracted value for that field will be an array of results.
     * If a schema field includes `raw: true`, the extracted value will be the raw HTML of the matched element(s).
     *
     * @param html - HTML content to parse
     * @param containerSelector - XPath or CSS selector to find container elements
     * @param schema - Schema object defining fields to extract from each container
     * @param containerType - Type of container selector: 'xpath' (default) or 'css'
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     *
     * @returns Array of objects with extracted data matching the schema structure. Fields with
     *          `multiple: true` will be arrays, `raw: true` will be raw HTML, others will be single values.
     *
     * @example
     * ```typescript
     * const html = `
     *   <div class="products">
     *     <div class="product">
     *       <h3>Product A</h3>
     *       <span class="price">$19.99</span>
     *       <span class="tag">electronics</span>
     *       <span class="tag">gadget</span>
     *     </div>
     *     <div class="product">
     *       <h3>Product B</h3>
     *       <span class="price">$29.99</span>
     *       <span class="tag">accessory</span>
     *     </div>
     *   </div>
     * `;
     *
     * // Define typed interface
     * interface Product {
     *   name: string;
     *   price: number;
     *   tags: string[]; // <-- array field
     *   nameHtml: string; // <-- raw HTML field
     * }
     *
     * const productSchema: ExtractionSchema<Product> = {
     *   name: {
     *     selector: './/h3/text()',
     *     type: 'xpath'
     *   },
     *   price: {
     *     selector: './/span[@class="price"]/text()',
     *     type: 'xpath',
     *     transform: (value) => parseFloat(value.replace('$', ''))
     *   },
     *   tags: {
     *     selector: './/span[@class="tag"]/text()',
     *     type: 'xpath',
     *     multiple: true // <-- NEW: array extraction
     *   },
     *   nameHtml: {
     *     selector: './/h3',
     *     type: 'xpath',
     *     raw: true // <-- NEW: raw HTML extraction
     *   }
     * };
     *
     * const products = parser.extractStructuredList<Product>(
     *   html,
     *   '//div[@class="product"]',
     *   productSchema
     * );
     * // Result: Product[] with tags as array and nameHtml as raw HTML for each product
     * // [
     * //   { name: "Product A", price: 19.99, tags: ["electronics", "gadget"], nameHtml: "<h3>Product A</h3>" },
     * //   { name: "Product B", price: 29.99, tags: ["accessory"], nameHtml: "<h3>Product B</h3>" }
     * // ]
     * ```
     */
    extractStructuredList<T = Record<string, any>>(html: string, containerSelector: string, schema: ExtractionSchema<T>, containerType?: 'xpath' | 'css', options?: {
        verbose?: boolean;
        baseUrl?: string;
    }): T[];
    /**
     * Evaluate XPath expression and return matching nodes
     */
    private evaluateXPath;
    /**
     * Extract single value from a container node using XPath (preserves context)
     */
    private extractSingleXPathFromNode;
    /**
     * Extract multiple values from a container node using XPath (preserves context)
     */
    private extractMultipleXPathFromNode;
    private getElementHTML;
    private extractSingleXPath;
    private extractMultipleXPath;
    private extractSingleCSS;
    private extractMultipleCSS;
    private normalizeHeaders;
    /**
     * Categorize error types for better handling and retry logic
     *
     * @param error - The error to categorize
     * @returns Object with error type and description
     */
    private categorizeError;
    /**
     * Determine if an error should trigger a retry based on configuration
     *
     * @param errorInfo - Categorized error information
     * @param config - Parser configuration options
     * @returns Whether to retry the request
     */
    private shouldRetryOnError;
    /**
     * Extract pagination data from HTML using a predefined or custom schema
     *
     * This method provides a convenient way to extract pagination information. It can use
     * either a default pagination schema or a custom schema provided by the user. When no
     * custom schema is provided, it extracts all links from the container selector.
     *
     * @param html - HTML content to parse
     * @param containerSelector - XPath or CSS selector to find the container element(s)
     * @param containerType - Type of container selector: 'xpath' (default) or 'css'
     * @param options - Parsing options
     * @param options.verbose - Enable verbose logging for debugging
     * @param options.baseUrl - Base URL for relative link resolution
     * @param options.schema - Optional custom schema for extraction. If not provided, extracts all links from container
     * @param options.linkSelector - Optional selector to find links within container (default: './/a' for xpath, 'a' for css)
     * @param options.transform - Optional transformation function or pipe to apply to results (only used when no custom schema)
     *
     * @returns Array of pagination objects with href and text properties (or custom schema structure)
     *
     * @example
     * ```typescript
     * const html = `
     *   <div class="pageNav">
     *     <a href="/page-4" class="pageNav-jump">Prev</a>
     *     <ul class="pageNav-main">
     *       <li><a href="/page-1">1</a></li>
     *       <li><a href="/page-2">2</a></li>
     *     </ul>
     *     <a href="/page-6" class="pageNav-jump">Next</a>
     *   </div>
     * `;
     *
     * // Extract all links from container
     * const allLinks = parser.extractPagination(html, '//div[@class="pageNav"]');
     * // Result: [
     * //   { href: "/page-4", text: "Prev" },
     * //   { href: "/page-1", text: "1" },
     * //   { href: "/page-2", text: "2" },
     * //   { href: "/page-6", text: "Next" }
     * // ]
     *
     * // With transform pipe
     * const transformedPages = parser.extractPagination(
     *   html,
     *   '//div[@class="pageNav"]',
     *   'xpath',
     *   {
     *     baseUrl: 'https://example.com',
     *     transform: { class: PathAppendPipe, payload: { pathSegment: '/view' } }
     *   }
     * );
     * // Result: URLs will have '/view' appended to the path
     *
     * // Extract specific pagination items only
     * const pages = parser.extractPagination(
     *   html,
     *   "//li",
     *   'xpath'
     * );
     * // Result: [
     * //   { href: "/page-1", text: "1" },
     * //   { href: "/page-2", text: "2" }
     * // ]
     *
     * // With custom schema
     * interface CustomPage {
     *   url: string;
     *   label: string;
     *   isActive: boolean;
     * }
     *
     * const customPages = parser.extractPagination<CustomPage>(
     *   html,
     *   "//li",
     *   'xpath',
     *   {
     *     schema: {
     *       url: { selector: './/a', type: 'xpath', attribute: 'href' },
     *       label: { selector: './/a/text()', type: 'xpath' },
     *       isActive: {
     *         selector: '.',
     *         type: 'xpath',
     *         attribute: 'class',
     *         transform: (cls: string) => cls?.includes('current') || false
     *       }
     *     }
     *   }
     * );
     * ```
     */
    extractPagination<T = PaginationPage>(html: string, containerSelector: string, containerType?: 'xpath' | 'css', options?: {
        verbose?: boolean;
        baseUrl?: string;
        schema?: ExtractionSchema<T>;
        linkSelector?: string;
        transform?: any;
    }): T[];
    /**
     * Extract the origin (protocol + hostname + port) from a URL
     *
     * @param url - Full URL string
     * @returns Origin string (e.g., "https://example.com")
     *
     * @example
     * ```typescript
     * const origin = parser.getOrigin('https://www.bmw-sg.com/forums/forums/introduction-greetings.24/page-5');
     * // Result: "https://www.bmw-sg.com"
     * ```
     */
    getOrigin(url: string): string;
    /**
     * Apply a transform (object with class and payload, or array of these) to a value or array of values.
     * Supports pipe classes with transform method that need baseUrl context and properly chains transform outputs as inputs to next transform.
     */
    private applyTransform;
}