import { AxiosRequestConfig } from 'axios';
import { LaunchOptions } from 'puppeteer';

declare const SCRAPE_TYPES: Record<string, (url: string, options: TScrapeDefaultOptions) => TScrapedDataPromise>;
declare const registerEnginePlugin: (plugin: IEnginePlugin) => void;

declare enum EngineType {
    Html = "html",
    Spa = "spa",
    Json = "json",
    Xml = "xml"
}
type EnginePlugins = {
    [K in keyof typeof SCRAPE_TYPES]: K;
};
type TEngineTypes = keyof EnginePlugins;
type TScrapedData = Record<string, any>;
type TScrapedDataPromise = Promise<TScrapedData>;
interface ISelector {
    selector: string;
    attribute?: string;
}
type TSelectors = Record<string, ISelector>;
interface IScrapeHtmlOptions {
    selectors: TSelectors;
    request?: AxiosRequestConfig;
    plugins?: ITransformerPlugin[];
}
interface IScrapeSpaOptions {
    selectors: TSelectors;
    request?: LaunchOptions;
    plugins?: ITransformerPlugin[];
}
interface IScrapeJsonOptions {
    selectors: TSelectors;
    request?: AxiosRequestConfig;
    plugins?: ITransformerPlugin[];
}
interface IScrapeXmlOptions {
    selectors: TSelectors;
    request?: AxiosRequestConfig;
    plugins?: ITransformerPlugin[];
}
type TScrapeDefaultOptions = IScrapeHtmlOptions & IScrapeSpaOptions & IScrapeJsonOptions & IScrapeXmlOptions;
interface IScrapeOptions {
    url: string;
    engine: EngineType | TEngineTypes;
    options: TScrapeDefaultOptions;
}
declare enum PluginType {
    Transformer = "transformer",
    Engine = "engine"
}
type PluginTypes = "transformer" | "engine";
interface IPlugin {
    type: string;
}
type TPluginSupportedEngines = EngineType | keyof EnginePlugins | "all";
interface ITransformerPlugin extends IPlugin {
    supportedEngines?: TPluginSupportedEngines[];
    onInit?: (options: {
        selectors: TSelectors;
    }) => void;
    onPreProcess?: (data: string) => string;
    onPostProcess?: (data: TScrapedData) => TScrapedData;
}
interface IEnginePlugin<T extends keyof EnginePlugins = keyof EnginePlugins> extends IPlugin {
    engine: T;
    scrape: (url: string, options: TScrapeDefaultOptions) => TScrapedDataPromise;
}

declare const scrape$4: (url: string, { selectors, request, plugins }: IScrapeHtmlOptions) => TScrapedDataPromise;

declare const scrape$3: (url: string, { selectors, request, plugins }: IScrapeSpaOptions) => TScrapedDataPromise;

declare const scrape$2: (url: string, { selectors, request, plugins }: IScrapeJsonOptions) => TScrapedDataPromise;

declare const scrape$1: (url: string, { selectors, request, plugins }: IScrapeXmlOptions) => TScrapedDataPromise;

declare enum ConditionOperationType {
    Difference = "difference",
    Equal = "equal",
    Contains = "contains",
    Regex = "regex"
}
type ConditionOperationTypes = "difference" | "equal" | "contains" | "regex";
interface ConditionType {
    value: string;
    operation: ConditionOperationType | ConditionOperationTypes;
    sensitive?: boolean;
}
interface ConditionPluginType extends Record<string, ConditionType[]> {
}

declare const plugin: (conditions: ConditionPluginType) => ITransformerPlugin;

declare const scrape: ({ url, engine, options, }: IScrapeOptions) => TScrapedDataPromise;

export { ConditionOperationType, ConditionType, EnginePlugins, EngineType, IEnginePlugin, IPlugin, IScrapeHtmlOptions, IScrapeJsonOptions, IScrapeOptions, IScrapeSpaOptions, IScrapeXmlOptions, ISelector, ITransformerPlugin, PluginType, PluginTypes, TEngineTypes, TPluginSupportedEngines, TScrapeDefaultOptions, TScrapedData, TScrapedDataPromise, TSelectors, plugin as conditions, registerEnginePlugin, scrape, scrape$4 as scrapeHtml, scrape$2 as scrapeJson, scrape$3 as scrapeSpa, scrape$1 as scrapeXml };