wsper-js 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2793 @@
+import { CanvasRenderingContext2D, Canvas } from 'canvas';
+
+interface WsperCredentials {
+    cookie?: string;
+    csrfToken?: string;
+    bearerToken?: string;
+    apiKey?: string;
+    userAgent?: string;
+}
+type WsperPlatform = "instagram" | "youtube" | "spotify" | "twitter" | "threads" | "pinterest";
+declare class CredentialsManager {
+    #private;
+    constructor(override?: WsperCredentials, defaults?: WsperCredentials);
+    static forPlatform(platform: WsperPlatform, override?: WsperCredentials, defaults?: Record<string, unknown>): CredentialsManager;
+    resolve(key: keyof WsperCredentials): string | undefined;
+    get cookie(): string | undefined;
+    get csrfToken(): string | undefined;
+    get bearerToken(): string | undefined;
+    get apiKey(): string | undefined;
+    get userAgent(): string | undefined;
+    hasCredential(key: keyof WsperCredentials): boolean;
+}
+
+declare const PLATFORM_DEFAULT_HEADERS: Record<string, Record<string, string>>;
+declare function buildPlatformHeaders(platform: string, credentials: CredentialsManager): Record<string, string>;
+
+interface WsperErrorOptions {
+    code?: string;
+    cause?: unknown;
+    details?: Record<string, unknown>;
+}
+declare class WsperError extends Error {
+    readonly code: string;
+    readonly cause?: unknown;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, options?: WsperErrorOptions);
+}
+
+interface HttpErrorOptions extends WsperErrorOptions {
+    statusCode?: number;
+    url?: string;
+    method?: string;
+}
+declare class HttpError extends WsperError {
+    readonly statusCode?: number | undefined;
+    readonly url?: string | undefined;
+    readonly method?: string | undefined;
+    constructor(message: string, options?: HttpErrorOptions);
+}
+
+declare class ParseError extends WsperError {
+    constructor(message: string, options?: WsperErrorOptions);
+}
+
+declare class ValidationError extends WsperError {
+    constructor(message: string, options?: WsperErrorOptions);
+}
+
+declare class ScraperError extends WsperError {
+    constructor(message: string, options?: WsperErrorOptions);
+}
+
+declare class DownloadError extends WsperError {
+    constructor(message: string, options?: WsperErrorOptions);
+}
+
+type Nullable<T> = T | null;
+type Optional<T> = T | undefined;
+type MaybePromise<T> = T | Promise<T>;
+interface Timestamped {
+    fetchedAt: string;
+    durationMs: number;
+}
+
+interface HttpOptions {
+    timeoutMs?: number;
+    retries?: number;
+    retryDelayMs?: number;
+    maxRetryAfterMs?: number;
+    maxRedirects?: number;
+    headers?: Record<string, string>;
+    userAgent?: string;
+    allowPrivateNetwork?: boolean;
+}
+interface QueueOptions {
+    concurrency?: number;
+    intervalMs?: number;
+    intervalCap?: number;
+    minDelayMs?: number;
+    maxDelayMs?: number;
+}
+interface ScraperOptions {
+    credentials?: WsperCredentials;
+    debug?: boolean;
+    http?: HttpOptions;
+    queue?: QueueOptions;
+}
+
+interface WsperResponseMeta {
+    statusCode: number;
+    sourceUrl: string;
+    fetchedAt: string;
+    durationMs: number;
+}
+interface WsperErrorPayload {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface WsperResponse<TData, TMeta extends WsperResponseMeta = WsperResponseMeta> {
+    ok: boolean;
+    statusCode: number;
+    data: TData | null;
+    error: WsperErrorPayload | null;
+    meta: TMeta;
+}
+declare function createSuccessResponse<TData, TMeta extends WsperResponseMeta>(input: {
+    code: string;
+    message: string;
+    data: TData;
+    meta: TMeta;
+}): WsperResponse<TData, TMeta>;
+declare function createErrorResponse<TMeta extends WsperResponseMeta>(error: unknown, input: {
+    code: string;
+    message: string;
+    meta: TMeta;
+}): WsperResponse<never, TMeta>;
+declare function extractStatusCode(error: unknown): number;
+
+declare class RequestQueue {
+    #private;
+    constructor(options?: QueueOptions);
+    get size(): number;
+    get active(): number;
+    add<T>(task: () => Promise<T>): Promise<T>;
+    onIdle(): Promise<void>;
+    pause(): void;
+    resume(): void;
+    clear(): void;
+}
+
+interface HttpRequestOptions extends HttpOptions {
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
+    body?: RequestBody;
+    responseType?: "json" | "text" | "arrayBuffer";
+}
+interface HttpResponse<T = unknown> {
+    url: string;
+    statusCode: number;
+    headers: Record<string, string>;
+    data: T;
+}
+type RequestBody = string | Blob | FormData | ArrayBuffer | URLSearchParams | BufferSource | Record<string, string | number | boolean | null | undefined>;
+declare class HttpClient {
+    #private;
+    constructor(options?: HttpOptions, queue?: RequestQueue);
+    getJson<T = unknown>(input: string | URL, options?: HttpRequestOptions): Promise<HttpResponse<T>>;
+    getText(input: string | URL, options?: HttpRequestOptions): Promise<HttpResponse<string>>;
+    request<T = unknown>(input: string | URL, options?: HttpRequestOptions): Promise<HttpResponse<T>>;
+}
+
+type LogLevel = "info" | "warn" | "error" | "debug";
+declare class WsperLogger {
+    #private;
+    constructor(prefix: string, enabled?: boolean);
+    enable(): this;
+    disable(): this;
+    get isEnabled(): boolean;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    debug(message: string, data?: unknown): void;
+}
+
+interface ParsedHtmlMetadata {
+    title: string | null;
+    meta: Record<string, string>;
+    jsonLd: unknown[];
+}
+declare class HtmlMetadataParser {
+    static parse(html: string): ParsedHtmlMetadata;
+    static getMeta(metadata: ParsedHtmlMetadata, keys: string[]): string | null;
+}
+
+declare class JsonParser {
+    static parse<T = unknown>(text: string, context?: string): T;
+    static get<T = unknown>(data: unknown, ...keys: string[]): T | undefined;
+    static extractEmbedded(html: string, pattern: RegExp): unknown | null;
+}
+
+interface DownloadOptions {
+    maxSizeBytes?: number;
+    allowedMimeTypes?: string[];
+    overwrite?: boolean;
+    timeoutMs?: number;
+}
+interface DownloadResult {
+    outputPath: string;
+    url: string;
+    contentType: string | null;
+    sizeBytes: number;
+    durationMs: number;
+}
+
+declare class Downloader {
+    #private;
+    constructor(baseDir: string, logger?: WsperLogger);
+    download(url: string, relativePath: string, options?: DownloadOptions): Promise<DownloadResult>;
+}
+
+type BackgroundSolidConfig = {
+    type: "solid";
+    color: string;
+};
+type LinearGradientDirection = "to-top" | "to-bottom" | "to-left" | "to-right" | "to-bottom-right" | "to-bottom-left" | "to-top-right" | "to-top-left";
+type BackgroundLinearConfig = {
+    type: "linear-gradient";
+    colors: string[];
+    direction: LinearGradientDirection;
+};
+type RadialGradientPosition = "center" | "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | {
+    x: number;
+    y: number;
+};
+type BackgroundRadialConfig = {
+    type: "radial-gradient";
+    colors: string[];
+    position: RadialGradientPosition;
+};
+type BackgroundConfig = BackgroundSolidConfig | BackgroundLinearConfig | BackgroundRadialConfig;
+type TextAlign = "left" | "right" | "center" | "justify";
+type PaddingConfig = number | {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+type NormalizedPadding = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+type TextConfig = {
+    value: string;
+    align?: TextAlign;
+    lineHeight?: number;
+    color?: string;
+    fontFamily?: string;
+    fontWeight?: number | string;
+    fontSize?: number | "auto";
+    minFontSize?: number;
+    maxFontSize?: number;
+    blur?: number;
+};
+type CanvasPreset = "square" | "story" | "post" | "landscape" | "1:1" | "9:16" | "16:9";
+type CanvasConfig = {
+    width?: number;
+    height?: number;
+    preset?: CanvasPreset;
+    aspectRatio?: string;
+};
+type AnimationDirection = "left-to-right" | "right-to-left";
+type AnimationMode = "word" | "line" | "character";
+type AnimationConfig = {
+    enabled?: boolean;
+    direction?: AnimationDirection;
+    mode?: AnimationMode;
+    duration?: number;
+    fps?: number;
+    textSpeed?: number;
+};
+type ImageOutputConfig = {
+    type: "image";
+    format: "png" | "jpg" | "webp";
+    path?: string;
+};
+type GifOutputConfig = {
+    type: "gif";
+    format?: "gif";
+    path?: string;
+};
+type VideoOutputConfig = {
+    type: "video";
+    format?: "mp4" | "webm";
+    path?: string;
+    codec?: string;
+};
+type OutputConfig = ImageOutputConfig | GifOutputConfig | VideoOutputConfig;
+type BratConfig = {
+    canvas?: CanvasConfig;
+    background?: BackgroundConfig;
+    backgroundBlur?: number;
+    text: TextConfig;
+    layout?: {
+        padding?: PaddingConfig;
+    };
+    animation?: AnimationConfig;
+    output?: OutputConfig;
+};
+type StylePreset = "classic" | "blurred" | "brat-green" | "clean";
+type StickerConfig = {
+    size?: number;
+    format?: "webp" | "png";
+    quality?: number;
+};
+type ConvertOptions = {
+    fps?: number;
+    quality?: number;
+    loop?: number;
+    width?: number;
+    height?: number;
+    startTime?: number;
+    duration?: number;
+};
+type BratResult = {
+    buffer: Buffer;
+    format: string;
+    path?: string;
+};
+type NormalizedAnimation = Required<Omit<AnimationConfig, "textSpeed">> & {
+    textSpeed: number | undefined;
+};
+type NormalizedBratConfig = {
+    canvas: {
+        width: number;
+        height: number;
+    };
+    background: BackgroundConfig;
+    backgroundBlur: number;
+    text: Required<TextConfig>;
+    padding: NormalizedPadding;
+    animation: NormalizedAnimation;
+    output: OutputConfig;
+};
+
+declare const CANVAS_PRESETS: Record<CanvasPreset, {
+    width: number;
+    height: number;
+}>;
+declare const DEFAULT_CANVAS: {
+    width: number;
+    height: number;
+};
+declare const DEFAULT_PADDING: NormalizedPadding;
+declare const DEFAULT_TEXT: {
+    align: "justify";
+    lineHeight: number;
+    color: string;
+    fontFamily: string;
+    fontWeight: number | string;
+    fontSize: number | "auto";
+    minFontSize: number;
+    maxFontSize: number;
+    blur: number;
+};
+declare const DEFAULT_ANIMATION: {
+    enabled: boolean;
+    direction: "left-to-right";
+    mode: "word";
+    duration: number;
+    fps: number;
+    textSpeed: number | undefined;
+};
+declare const FFMPEG_PATH = "C:\\ffmpeg\\ffmpeg.exe";
+
+declare function normalizeConfig(cfg: BratConfig): NormalizedBratConfig;
+
+declare function makeCanvas(width: number, height: number): Canvas;
+declare function renderBackground(ctx: CanvasRenderingContext2D, width: number, height: number, bg: BackgroundConfig): void;
+declare function applyBlur(ctx: CanvasRenderingContext2D, canvas: Canvas, padding: NormalizedPadding, blur: number): void;
+
+type WordPos = {
+    word: string;
+    x: number;
+};
+type LineLayout = {
+    words: WordPos[];
+    y: number;
+};
+declare function measureText(ctx: CanvasRenderingContext2D, text: string, fontSize: number, fontFamily: string, fontWeight: number | string): number;
+declare function wrapText(ctx: CanvasRenderingContext2D, text: string, maxWidth: number, fontSize: number, fontFamily: string, fontWeight: number | string): string[][];
+declare function calcAutoFontSize(ctx: CanvasRenderingContext2D, text: string, maxWidth: number, maxHeight: number, fontFamily: string, fontWeight: number | string, lineHeight: number, minFont: number, maxFont: number): number;
+declare function buildLayout(ctx: CanvasRenderingContext2D, lines: string[][], fontSize: number, fontFamily: string, fontWeight: number | string, lineHeight: number, align: TextAlign, padding: NormalizedPadding, canvasWidth: number, canvasHeight: number): LineLayout[];
+declare function drawLayout(ctx: CanvasRenderingContext2D, layout: LineLayout[], color: string, fontSize: number, fontFamily: string, fontWeight: number | string, wordLimit?: number): void;
+declare function totalWordCount(layout: LineLayout[]): number;
+declare function totalLineCount(layout: LineLayout[]): number;
+declare function totalCharCount(layout: LineLayout[]): number;
+
+type RenderFrame = {
+    canvas: Canvas;
+    layout: LineLayout[];
+    fontSize: number;
+    totalWords: number;
+};
+declare function renderFrame(cfg: NormalizedBratConfig, wordLimit?: number): RenderFrame;
+declare function renderAnimationFrame(cfg: NormalizedBratConfig, layout: LineLayout[], fontSize: number, wordLimit: number): Canvas;
+
+type AnimationStep = {
+    wordLimit: number;
+    lineLimit?: number;
+    charLimit?: number;
+};
+declare function buildSteps(layout: LineLayout[], mode: AnimationMode, direction: AnimationDirection): number[];
+
+declare function exportImage(cfg: NormalizedBratConfig): Promise<BratResult>;
+
+declare function exportGif(cfg: NormalizedBratConfig): Promise<BratResult>;
+
+declare function exportVideo(cfg: NormalizedBratConfig): Promise<BratResult>;
+
+type StickerTextOptions = {
+    top?: string;
+    bottom?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    color?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+};
+declare function imageToSticker(source: string | Buffer, opts?: StickerConfig & StickerTextOptions): Promise<Buffer>;
+declare function imagesToSticker(source: string | Buffer, dest: string, opts?: StickerConfig & StickerTextOptions): Promise<void>;
+declare function mp4ToGif(input: string, output: string, opts?: ConvertOptions): Promise<Buffer>;
+declare function gifToMp4(input: string, output: string, opts?: ConvertOptions): Promise<Buffer>;
+declare function gifToWebm(input: string, output: string, opts?: ConvertOptions): Promise<Buffer>;
+declare function convertImage(source: string | Buffer, outputFormat: "png" | "jpg" | "webp", dest?: string): Promise<Buffer>;
+
+declare class BratGenerator {
+    generate(cfg: BratConfig): Promise<BratResult>;
+    generateImage(cfg: BratConfig, format?: "png" | "jpg" | "webp"): Promise<BratResult>;
+    generateGif(cfg: BratConfig): Promise<BratResult>;
+    generateVideo(cfg: BratConfig, format?: "mp4" | "webm"): Promise<BratResult>;
+    withPreset(preset: StylePreset, cfg: BratConfig): BratConfig;
+    imageToSticker(source: string | Buffer, opts?: StickerConfig & StickerTextOptions): Promise<Buffer>;
+    saveSticker(source: string | Buffer, dest: string, opts?: StickerConfig & StickerTextOptions): Promise<void>;
+    mp4ToGif(input: string, output: string, opts?: ConvertOptions): Promise<Buffer>;
+    gifToMp4(input: string, output: string, opts?: ConvertOptions): Promise<Buffer>;
+    gifToWebm(input: string, output: string, opts?: ConvertOptions): Promise<Buffer>;
+    convertImage(source: string | Buffer, format: "png" | "jpg" | "webp", dest?: string): Promise<Buffer>;
+}
+declare const bratGenerator: BratGenerator;
+declare function generateBrat(cfg: BratConfig): Promise<BratResult>;
+
+type MonthlyPoint = {
+    label: string;
+    group: number;
+    user: number;
+};
+type WeeklyPoint = {
+    label: string;
+    group: number;
+    user: number;
+};
+type AnalyticsTheme = {
+    background: string;
+    surface: string;
+    ink: string;
+    mutedInk: string;
+    groupLine: string;
+    userLine: string;
+    groupFill: string;
+    userFill: string;
+    grid: string;
+    accent: string;
+};
+type MonthlyChartStyle = "smooth-line" | "area" | "grouped-bars";
+type WeeklyChartStyle = "bubbles" | "stacked-bars" | "radial-bars" | "mini-columns";
+type AnalyticsChartVariant = "poster" | "dashboard" | "minimal" | "neon" | "compact";
+declare const ANALYTICS_CHART_MODEL_NAMES: readonly ["vintage-poster", "modern-dashboard", "minimal-report", "dark-neon", "compact-card"];
+type AnalyticsChartModelName = (typeof ANALYTICS_CHART_MODEL_NAMES)[number];
+type AnalyticsChartModel = {
+    id: string;
+    label?: string;
+    variant?: AnalyticsChartVariant;
+    monthlyChart?: MonthlyChartStyle;
+    weeklyChart?: WeeklyChartStyle;
+    showAnnotations?: boolean;
+    showLegend?: boolean;
+    showTexture?: boolean;
+    theme?: Partial<AnalyticsTheme>;
+};
+type AnalyticsImageOptions = {
+    title?: string;
+    subtitle?: string;
+    monthly?: readonly MonthlyPoint[];
+    weekly?: readonly WeeklyPoint[];
+    output?: string;
+    width?: number;
+    height?: number;
+    footer?: string;
+    theme?: Partial<AnalyticsTheme>;
+    model?: AnalyticsChartModelName | AnalyticsChartModel;
+    modelOverrides?: Partial<AnalyticsChartModel>;
+};
+declare const ANALYTICS_CHART_MODELS: Record<AnalyticsChartModelName, AnalyticsChartModel>;
+declare const demoAnalyticsData: {
+    monthly: {
+        label: string;
+        group: number;
+        user: number;
+    }[];
+    weekly: {
+        label: string;
+        group: number;
+        user: number;
+    }[];
+};
+declare function getAnalyticsChartModels(): AnalyticsChartModel[];
+declare function generateChartImage(options: AnalyticsImageOptions): Promise<Buffer>;
+declare function generateAnalyticsStatsImage(options?: AnalyticsImageOptions): Promise<Buffer>;
+declare class ChartGenerator {
+    generateAnalyticsStatsImage(options?: AnalyticsImageOptions): Promise<Buffer>;
+    generateStatsImage(options?: AnalyticsImageOptions): Promise<Buffer>;
+    getModels(): AnalyticsChartModel[];
+}
+declare const chartGenerator: ChartGenerator;
+
+interface InstagramScraperOptions extends ScraperOptions {
+    credentials?: {
+        cookie?: string;
+        csrfToken?: string;
+    };
+}
+interface InstagramProfile {
+    id: string;
+    username: string;
+    fullName: string;
+    biography: string;
+    profilePicUrl: string;
+    profilePicUrlHd: string | null;
+    followersCount: number;
+    followingCount: number;
+    mediaCount: number;
+    isPrivate: boolean;
+    isVerified: boolean;
+    externalUrl: string | null;
+}
+interface InstagramCarouselItem {
+    id: string;
+    mediaType: number;
+    thumbnailUrl: string | null;
+    videoUrl: string | null;
+}
+interface InstagramMediaItem {
+    id: string;
+    shortcode: string;
+    mediaType: number;
+    productType: string | null;
+    caption: string | null;
+    takenAt: number | null;
+    likeCount: number | null;
+    commentCount: number | null;
+    thumbnailUrl: string | null;
+    videoUrl: string | null;
+    carousel: InstagramCarouselItem[] | null;
+}
+interface InstagramFeed {
+    items: InstagramMediaItem[];
+    nextMaxId: string | null;
+    hasMore: boolean;
+}
+interface InstagramProfileWithFeed {
+    profile: InstagramProfile;
+    items: InstagramMediaItem[];
+    nextMaxId: string | null;
+    hasMore: boolean;
+}
+interface InstagramDownloadAsset {
+    url: string;
+    outputPath: string;
+    type: "image" | "video";
+    index: number;
+}
+interface InstagramDownloadResult {
+    sourceUrl: string;
+    outputDir: string;
+    metadataPath: string | null;
+    assets: InstagramDownloadAsset[];
+}
+interface InstagramFeedOptions {
+    count?: number;
+    maxId?: string;
+}
+interface InstagramDownloadPostInput {
+    postUrl?: string;
+    shortcode?: string;
+    media?: InstagramMediaItem;
+    outputDir: string;
+    includeMetadata?: boolean;
+}
+interface InstagramDownloadProfileInput {
+    usernameOrUrl: string;
+    outputDir: string;
+    feedCount?: number;
+    includeProfilePicture?: boolean;
+    includeInitialPosts?: boolean;
+    includeMetadata?: boolean;
+}
+
+declare class InstagramScraper {
+    #private;
+    constructor(options?: ScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getProfile(username: string): Promise<WsperResponse<InstagramProfile>>;
+    getFeed(username: string, options?: InstagramFeedOptions): Promise<WsperResponse<InstagramFeed>>;
+    getPost(input: string): Promise<WsperResponse<InstagramMediaItem>>;
+    getProfileWithFeed(username: string, options?: InstagramFeedOptions): Promise<WsperResponse<InstagramProfileWithFeed>>;
+    downloadPost(input: InstagramDownloadPostInput): Promise<WsperResponse<InstagramDownloadResult>>;
+    downloadProfile(input: InstagramDownloadProfileInput): Promise<WsperResponse<InstagramDownloadResult>>;
+}
+
+interface AlkitabScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface AlkitabVerse {
+    title: string;
+    text: string;
+    link: string;
+}
+
+declare class AlkitabScraper {
+    #private;
+    constructor(options?: AlkitabScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    search(query: string): Promise<WsperResponse<AlkitabVerse[]>>;
+}
+
+declare function parseAlkitabSearchHtml(html: string, pageUrl: string): AlkitabVerse[];
+
+interface AnimeQuoteScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface AnimeQuoteItem {
+    character: string;
+    anime: string;
+    episode: string;
+    quote: string;
+}
+
+declare class AnimeQuoteScraper {
+    #private;
+    constructor(options?: AnimeQuoteScraperOptions);
+    getRandom(): Promise<WsperResponse<AnimeQuoteItem>>;
+}
+
+declare function parseAnimeQuoteFeedHtml(html: string, pageUrl: string): string[];
+declare function parseAnimeQuoteDetailHtml(html: string, pageUrl: string): AnimeQuoteItem;
+
+interface AnimeRandomScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface AnimeRandomResult {
+    character: string;
+    imageUrl: string;
+}
+
+declare const ANIME_CHARACTERS: readonly ["akira", "akiyama", "anna", "asuna", "ayuzawa", "boruto", "chitanda", "chitoge", "deidara", "doraemon", "emilia", "erza", "gremory", "hestia", "hinata", "inori", "isuzu", "itachi", "itori", "kaga", "kagura", "kakasih", "kaori", "kaneki", "kosaki", "kotori", "kuriyama", "kuroha", "kurumi", "madara", "mikasa", "miku", "minato", "naruto", "natsukawa", "neko", "nekohime", "nezuko", "nishimiya", "onepiece", "pokemon", "rem", "rize", "sagiri", "sakura", "sasuke", "shina", "shinka", "shizuka", "shota", "tomori", "toukachan", "tsunade", "yatogami", "yuki"];
+type AnimeCharacter = typeof ANIME_CHARACTERS[number];
+declare class AnimeRandomScraper {
+    #private;
+    constructor(options?: AnimeRandomScraperOptions);
+    getImage(character: string): Promise<WsperResponse<AnimeRandomResult>>;
+    random(): Promise<WsperResponse<AnimeRandomResult>>;
+}
+
+interface BiliBiliScraperOptions extends ScraperOptions {
+    apiBaseUrl?: string | undefined;
+    cookie?: string | undefined;
+}
+interface BiliBiliVideoStream {
+    quality: string;
+    qualityId: number;
+    videoUrl: string;
+    audioUrl: string;
+}
+interface BiliBiliVideoInfo {
+    aid: number;
+    bvid: string;
+    title: string;
+    description: string;
+    cover: string;
+    duration: number;
+    author: string;
+    authorUid: number;
+    views: number;
+    likes: number;
+    cid: number;
+    url: string;
+    streams: BiliBiliVideoStream[];
+}
+interface BiliBiliSearchItem {
+    aid: number;
+    bvid: string;
+    title: string;
+    description: string;
+    cover: string;
+    author: string;
+    views: number;
+    duration: string;
+    url: string;
+}
+interface BiliBiliSearchResult {
+    query: string;
+    total: number;
+    page: number;
+    items: BiliBiliSearchItem[];
+}
+
+declare class BiliBiliScraper {
+    #private;
+    constructor(options?: BiliBiliScraperOptions);
+    search(query: string, page?: number): Promise<WsperResponse<BiliBiliSearchResult>>;
+    getVideoInfo(input: string): Promise<WsperResponse<BiliBiliVideoInfo>>;
+}
+
+declare function parseBiliBiliViewResponse(raw: unknown): BiliBiliVideoInfo;
+declare function parseBiliBiliPlayUrlResponse(raw: unknown): BiliBiliVideoStream[];
+declare function parseBiliBiliSearchResponse(raw: unknown, query: string, page: number): BiliBiliSearchResult;
+
+interface BMKGBaseUrls {
+    nowcasting: string;
+    autogempa: string;
+    gempaDirasakan: string;
+    shakemap: string;
+    prakiraan: string;
+}
+interface BMKGScraperOptions extends ScraperOptions {
+    baseUrls?: Partial<BMKGBaseUrls> | undefined;
+    downloadDir?: string | undefined;
+}
+interface BMKGNowcasting {
+    raw: Record<string, unknown>;
+    features: unknown[];
+    totalFeatures: number;
+    retrievedAt: string;
+}
+interface BMKGEarthquake {
+    tanggal: string;
+    jam: string;
+    datetime: string;
+    coordinates: string;
+    lintang: string;
+    bujur: string;
+    magnitude: string;
+    kedalaman: string;
+    wilayah: string;
+    potensi: string | null;
+    dirasakan: string | null;
+    shakemap: string | null;
+}
+interface BMKGEarthquakeFeed {
+    raw: Record<string, unknown>;
+    earthquakes: BMKGEarthquake[];
+    totalEarthquakes: number;
+    retrievedAt: string;
+}
+interface BMKGForecast {
+    provinceCode: string;
+    provinceName: string | null;
+    xml: string;
+    retrievedAt: string;
+}
+interface BMKGShakemapDownload {
+    filename: string;
+    outputPath: string;
+    sizeBytes: number;
+    url: string;
+    contentType: string | null;
+    durationMs: number;
+    downloadedAt: string;
+}
+
+declare class BMKGScraper {
+    #private;
+    constructor(options?: BMKGScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getCuacaNowcasting(offset?: number, limit?: number): Promise<WsperResponse<BMKGNowcasting>>;
+    getAutogempa(): Promise<WsperResponse<BMKGEarthquakeFeed>>;
+    getGempaDirasakan(): Promise<WsperResponse<BMKGEarthquakeFeed>>;
+    getPrakiraanCuaca(provinsi: string): Promise<WsperResponse<BMKGForecast>>;
+    downloadShakemap(kodeShakemap: string, saveDir?: string): Promise<WsperResponse<BMKGShakemapDownload>>;
+    getKodeProvinsi(): WsperResponse<Record<string, string>>;
+}
+
+declare const BMKG_DEFAULT_BASE_URLS: BMKGBaseUrls;
+declare const BMKG_QUEUE_DEFAULTS: {
+    concurrency: number;
+    intervalMs: number;
+    intervalCap: number;
+    minDelayMs: number;
+    maxDelayMs: number;
+};
+declare const BMKG_PROVINCE_CODES: Record<string, string>;
+
+declare function parseBMKGNowcasting(raw: unknown, retrievedAt?: string): BMKGNowcasting;
+declare function parseBMKGEarthquakeFeed(raw: unknown, retrievedAt?: string): BMKGEarthquakeFeed;
+declare function parseBMKGForecastXml(raw: unknown, provinceCode: string, provinceName: string | null, retrievedAt?: string): BMKGForecast;
+
+interface CapCutScraperOptions extends ScraperOptions {
+    resolverUrl?: string | undefined;
+}
+interface CapCutDownloadResult {
+    videoUrl: string;
+}
+
+declare class CapCutScraper {
+    #private;
+    constructor(options?: CapCutScraperOptions);
+    download(url: string): Promise<WsperResponse<CapCutDownloadResult>>;
+}
+
+declare function parseCapCutResolverResponse(raw: unknown): string;
+
+interface CuacaBaseUrls {
+    search: string;
+    weatherByCoord: string;
+    warning: string;
+}
+interface CuacaScraperOptions extends ScraperOptions {
+    baseUrls?: Partial<CuacaBaseUrls> | undefined;
+    warningApiKey?: string | undefined;
+}
+interface CuacaSearchResult {
+    adm4: string;
+    name: string;
+    lat: number;
+    lon: number;
+}
+interface CuacaResult {
+    location: string;
+    localTime: string;
+    weather: string;
+    temperature: string;
+    humidity: string;
+    cloudCover: string;
+    visibility: string;
+    wind: string;
+    impact: string;
+    warning: string;
+    bmkgUrl: string;
+    gmapUrl: string;
+    lat: number;
+    lon: number;
+}
+interface CuacaWarningInfo {
+    impact: string;
+    warning: string;
+}
+
+declare class CuacaScraper {
+    #private;
+    constructor(options?: CuacaScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getWeather(lokasi: string): Promise<WsperResponse<CuacaResult>>;
+    searchLocation(query: string): Promise<WsperResponse<CuacaSearchResult[]>>;
+    getWeatherByCoord(lat: number, lon: number): Promise<WsperResponse<CuacaResult>>;
+}
+
+declare const CUACA_DEFAULT_BASE_URLS: {
+    search: string;
+    weatherByCoord: string;
+    warning: string;
+};
+declare const CUACA_QUEUE_DEFAULTS: {
+    concurrency: number;
+    intervalMs: number;
+    intervalCap: number;
+    minDelayMs: number;
+    maxDelayMs: number;
+};
+declare const CUACA_WIND_DIRECTIONS: Record<string, string>;
+declare const CUACA_CITY_COORDS: Record<string, {
+    lat: number;
+    lon: number;
+}>;
+
+declare function parseCuacaSearchLocations(raw: unknown, fallbackName: string): CuacaSearchResult[];
+declare function parseCuacaWeather(raw: unknown, lat: number, lon: number, warning: CuacaWarningInfo): CuacaResult;
+declare function parseCuacaWarning(raw: unknown): CuacaWarningInfo;
+declare function defaultWarning(): CuacaWarningInfo;
+
+interface DrakorScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface DrakorGenre {
+    name: string;
+    url: string;
+}
+interface DrakorArtist {
+    name: string;
+    url: string;
+}
+interface DrakorItem {
+    title: string;
+    url: string;
+    image: string;
+    type: string;
+    duration: string | null;
+    quality: string | null;
+    rating: string | null;
+    slug: string;
+}
+interface DrakorEpisode {
+    title: string;
+    url: string;
+    episode: string;
+    date: string;
+}
+interface DrakorDetail {
+    title: string;
+    koreanTitle: string | null;
+    image: string | null;
+    synopsis: string;
+    rating: string;
+    type: string;
+    status: string;
+    episodeCount: string | null;
+    season: string | null;
+    firstAirDate: string | null;
+    country: string | null;
+    director: string | null;
+    videoLength: string | null;
+    views: string | null;
+    postedOn: string | null;
+    genres: DrakorGenre[];
+    artists: DrakorArtist[];
+    episodes: DrakorEpisode[];
+}
+interface DrakorPagination {
+    currentPage: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}
+interface DrakorList {
+    dramas: DrakorItem[];
+    pagination: DrakorPagination;
+}
+
+declare class DrakorScraper {
+    #private;
+    constructor(options?: DrakorScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    search(query: string): Promise<WsperResponse<DrakorList>>;
+    detail(slug: string): Promise<WsperResponse<DrakorDetail>>;
+    ongoing(): Promise<WsperResponse<DrakorList>>;
+    getAll(page?: number): Promise<WsperResponse<DrakorList>>;
+}
+
+declare function parseDrakorListHtml(html: string, pageUrl: string, currentPage: number): DrakorList;
+declare function parseDrakorDetailHtml(html: string, pageUrl: string): DrakorDetail;
+
+interface DramaboxScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface DramaboxListItem {
+    id: string;
+    title: string;
+    episodes: number;
+    description: string;
+    cover: string;
+    playUrl: string;
+}
+interface DramaboxResult {
+    query: string;
+    total: number;
+    results: DramaboxListItem[];
+}
+
+declare class DramaboxScraper {
+    #private;
+    constructor(options?: DramaboxScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    search(query: string): Promise<WsperResponse<DramaboxResult>>;
+}
+
+declare function parseDramaboxSearchHtml(html: string, pageUrl: string, query: string): DramaboxResult;
+
+interface FaceswapScraperOptions {
+    baseUrl?: string | undefined;
+    maxImageSizeBytes?: number | undefined;
+    maxPollAttempts?: number | undefined;
+    pollIntervalMs?: number | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+interface FaceswapResult {
+    job_id: string;
+    image: string;
+}
+
+declare class FaceswapScraper {
+    #private;
+    constructor(options?: FaceswapScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    process(sourceBuffer: Buffer, targetBuffer: Buffer): Promise<WsperResponse<FaceswapResult>>;
+}
+
+declare function parseFaceswapCreateResponse(input: unknown): string;
+declare function parseFaceswapPollResponse(input: unknown, jobId: string): FaceswapResult | null;
+
+interface HokInfoScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface HokInfoResult {
+    title: string;
+    image: string | null;
+    profile: Record<string, string>;
+    bio: string | null;
+    skills: string[];
+    lore: string | null;
+    url: string;
+}
+
+declare class HokInfoScraper {
+    #private;
+    constructor(options?: HokInfoScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getCharacter(name: string): Promise<WsperResponse<HokInfoResult>>;
+}
+
+declare function parseHokInfoHtml(html: string, pageUrl: string): HokInfoResult;
+
+type HtmlToJpgPageSize = "auto" | "A4" | "A3" | "Letter";
+type HtmlToJpgPageOrientation = "portrait" | "landscape";
+interface HtmlToJpgScraperOptions {
+    baseUrl?: string | undefined;
+    maxFileSizeBytes?: number | undefined;
+    maxPollAttempts?: number | undefined;
+    pollIntervalMs?: number | undefined;
+    viewportWidth?: number | undefined;
+    pageSize?: HtmlToJpgPageSize | undefined;
+    pageOrientation?: HtmlToJpgPageOrientation | undefined;
+    margin?: number | undefined;
+    initialDelaySeconds?: number | undefined;
+    hideCookie?: boolean | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+interface HtmlToJpgUploadForm {
+    jobId: string;
+    uploadUrl: string;
+    uploadParams: Record<string, string>;
+}
+interface HtmlToJpgResult {
+    jobId: string;
+    downloadUrl: string;
+}
+interface HtmlToJpgTask {
+    name: string;
+    status: string | null;
+    result: {
+        form?: {
+            url: string;
+            parameters: Record<string, string>;
+        };
+        files?: Array<{
+            url: string;
+        }>;
+        url?: string;
+    } | null;
+}
+
+declare class HtmlToJpgScraper {
+    #private;
+    constructor(options?: HtmlToJpgScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    convert(filePath: string): Promise<WsperResponse<HtmlToJpgResult>>;
+    convertBuffer(htmlBuffer: Buffer, filename?: string, startedAt?: number): Promise<WsperResponse<HtmlToJpgResult>>;
+}
+
+declare function parseHtmlToJpgCreateJobResponse(input: unknown): HtmlToJpgUploadForm;
+declare function parseHtmlToJpgTasks(input: unknown): HtmlToJpgTask[];
+declare function getHtmlToJpgDownloadUrl(tasks: HtmlToJpgTask[]): string | null;
+
+interface IkiruMangaScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface IkiruMangaItem {
+    title: string;
+    link: string;
+    type: string;
+    cover: string | null;
+}
+interface IkiruMangaResult {
+    items: IkiruMangaItem[];
+}
+
+declare class IkiruMangaScraper {
+    #private;
+    constructor(options?: IkiruMangaScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    search(query: string): Promise<WsperResponse<IkiruMangaResult>>;
+}
+
+declare function parseIkiruMangaSearchHtml(html: string, pageUrl: string): IkiruMangaResult;
+
+type ImageSiteName = "safebooru";
+interface ImageScraperOptions {
+    safebooruBaseUrl?: string | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+interface ImageSearchOptions {
+    tags: string;
+    page?: number | undefined;
+    limit?: number | undefined;
+}
+interface ImagePost {
+    id: number;
+    thumbnail: string | null;
+    contentUrl: string | null;
+    sampleUrl: string | null;
+    score: number | null;
+    uploader: string | null;
+    tags: string[];
+    rating: string | null;
+    md5: string | null;
+    width: number | null;
+    height: number | null;
+    sourceUrl: string | null;
+    createdAt: string | null;
+}
+interface ImageSearchResult {
+    site: ImageSiteName;
+    posts: ImagePost[];
+    total: number | null;
+    page: number;
+    limit: number;
+}
+
+declare class ImageScraper {
+    #private;
+    constructor(options?: ImageScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    search(site: ImageSiteName, options: ImageSearchOptions): Promise<WsperResponse<ImageSearchResult>>;
+    safebooru(tags: string, page?: number, limit?: number): Promise<WsperResponse<ImageSearchResult>>;
+    rule34xxx(): Promise<WsperResponse<ImageSearchResult>>;
+    gelbooru(): Promise<WsperResponse<ImageSearchResult>>;
+    static getSupportedSites(): ImageSiteName[];
+}
+
+declare function parseSafebooruSearchResponse(input: unknown, site: ImageSiteName, page: number, limit: number): ImageSearchResult;
+
+interface ImgUpscalerScraperOptions {
+    baseUrl?: string | undefined;
+    maxImageSizeBytes?: number | undefined;
+    maxPollAttempts?: number | undefined;
+    pollIntervalMs?: number | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+type ImgUpscalerScale = 2 | 4;
+interface ImgUpscalerResult {
+    originalPath: string | null;
+    outputPath: string | null;
+    resultUrl: string;
+    scale: ImgUpscalerScale;
+}
+
+declare class ImgUpscalerScraper {
+    #private;
+    constructor(options?: ImgUpscalerScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    upscale(inputPath: string, scale?: ImgUpscalerScale): Promise<WsperResponse<ImgUpscalerResult>>;
+    upscaleBuffer(imageBuffer: Buffer, filename?: string, scale?: ImgUpscalerScale, originalPath?: string | null, startedAt?: number): Promise<WsperResponse<ImgUpscalerResult>>;
+}
+
+declare function parseImgUpscalerUploadResponse(input: unknown): string;
+declare function parseImgUpscalerStatusResponse(input: unknown): string | null;
+
+interface KomikindoScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface KomikindoSearchItem {
+    title: string;
+    imageUrl: string | null;
+    rating: string;
+    url: string;
+}
+interface KomikindoDetail {
+    title: string;
+    imageUrl: string | null;
+    rating: string;
+    url: string;
+    alternativeTitle: string;
+    status: string;
+    author: string;
+    illustrator: string;
+    graphic: string;
+    theme: string;
+    comicType: string;
+    official: string;
+    information: string;
+}
+
+declare class KomikindoScraper {
+    #private;
+    constructor(options?: KomikindoScraperOptions);
+    search(query: string): Promise<WsperResponse<KomikindoSearchItem[]>>;
+    getDetail(url: string): Promise<WsperResponse<KomikindoDetail>>;
+}
+
+declare function parseKomikindoSearchHtml(html: string): KomikindoSearchItem[];
+declare function parseKomikindoDetailHtml(html: string, pageUrl: string): KomikindoDetail;
+
+interface LyricsScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface LyricsResult {
+    lyrics: string;
+    link: string;
+    title: string;
+}
+
+declare class LyricsScraper {
+    #private;
+    constructor(options?: LyricsScraperOptions);
+    search(query: string): Promise<WsperResponse<LyricsResult>>;
+}
+
+declare function parseLyricsSearchHtml(html: string, pageUrl: string): string;
+declare function parseLyricsDetailHtml(html: string, pageUrl: string): LyricsResult;
+
+interface MConverterScraperOptions {
+    baseUrl?: string | undefined;
+    maxFileSizeBytes?: number | undefined;
+    chunkSizeBytes?: number | undefined;
+    maxPollAttempts?: number | undefined;
+    pollIntervalMs?: number | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+interface MConverterTarget {
+    name: string;
+    mime: string;
+}
+interface MConverterTargetsResult {
+    targets: MConverterTarget[];
+}
+interface MConverterConvertResult {
+    url: string;
+}
+
+declare class MConverterScraper {
+    #private;
+    constructor(options?: MConverterScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getTargets(filename: string): Promise<WsperResponse<MConverterTargetsResult>>;
+    convert(inputPath: string, targetFormat: string): Promise<WsperResponse<MConverterConvertResult>>;
+    convertBuffer(buffer: Buffer, filename: string, targetFormat: string, startedAt?: number): Promise<WsperResponse<MConverterConvertResult>>;
+}
+
+interface MConverterUploadState {
+    token: string;
+    awaitingChunks: boolean;
+}
+interface MConverterPollState {
+    status: "pending" | "finished" | "error";
+    reason: string | null;
+}
+declare function parseMConverterTargets(input: unknown): MConverterTarget[];
+declare function parseMConverterUploadResponse(input: unknown): MConverterUploadState;
+declare function parseMConverterPollResponse(input: unknown): MConverterPollState;
+
+interface McAddonScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface McAddonSearchItem {
+    title: string;
+    url: string;
+    description: string;
+    rating: string;
+    tags: string[];
+}
+interface McAddonDetail {
+    image: string | null;
+    title: string;
+    subtitle: string;
+    gameplay: string;
+}
+interface McAddonResult {
+    info: McAddonSearchItem;
+    detail: McAddonDetail;
+}
+
+declare class McAddonScraper {
+    #private;
+    constructor(options?: McAddonScraperOptions);
+    search(query: string): Promise<WsperResponse<McAddonSearchItem[]>>;
+    getDetail(url: string): Promise<WsperResponse<McAddonDetail>>;
+    getAddon(query: string): Promise<WsperResponse<McAddonResult>>;
+}
+
+declare function parseMcAddonSearchHtml(html: string): McAddonSearchItem[];
+declare function parseMcAddonDetailHtml(html: string): McAddonDetail;
+
+interface ModAndroidScraperOptions {
+    android1BaseUrl?: string | undefined;
+    modyoloBaseUrl?: string | undefined;
+    aptoideBaseUrl?: string | undefined;
+    uptodownBaseUrl?: string | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+interface Android1Item {
+    judul: string;
+    dev: string;
+    rating: string;
+    thumb: string;
+    link: string;
+}
+interface Android1Result {
+    data: Android1Item[];
+}
+interface ModyoloItem {
+    judul: string;
+    link: string;
+    thumb: string;
+    versi: string;
+    ukuran: string;
+}
+interface ModyoloResult {
+    data: ModyoloItem[];
+}
+interface AptoideItem {
+    judul: string;
+    dev: string;
+    rating: string;
+    ukuran: string;
+    thumb: string;
+    link: string;
+}
+interface AptoideResult {
+    data: AptoideItem[];
+}
+interface UptodownItem {
+    judul: string;
+    dev: string;
+    rating: string;
+    thumb: string;
+    link: string;
+}
+interface UptodownResult {
+    data: UptodownItem[];
+}
+interface ModAndroidSearchResult {
+    android1: Android1Result;
+    modyolo: ModyoloResult;
+    aptoide: AptoideResult;
+    uptodown: UptodownResult;
+}
+
+declare class ModAndroidScraper {
+    #private;
+    constructor(options?: ModAndroidScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    android1(query: string): Promise<WsperResponse<Android1Result>>;
+    modyolo(query: string): Promise<WsperResponse<ModyoloResult>>;
+    aptoide(query: string): Promise<WsperResponse<AptoideResult>>;
+    uptodown(query: string): Promise<WsperResponse<UptodownResult>>;
+    searchAll(query: string): Promise<WsperResponse<ModAndroidSearchResult>>;
+}
+
+declare function parseAndroid1Results(html: string, baseUrl: string): Android1Item[];
+declare function parseModyoloResults(html: string, baseUrl: string): ModyoloItem[];
+declare function parseAptoideResults(input: unknown): AptoideItem[];
+declare function parseUptodownResults(html: string, baseUrl: string): UptodownItem[];
+
+interface MediafireScraperOptions extends ScraperOptions {
+}
+interface MediafireResult {
+    downloadUrl: string;
+    fileName: string;
+    fileSize: string;
+    fileType: string;
+}
+
+declare class MediafireScraper {
+    #private;
+    constructor(options?: MediafireScraperOptions);
+    getLink(url: string): Promise<WsperResponse<MediafireResult>>;
+}
+
+declare function parseMediafireHtml(html: string, pageUrl: string): MediafireResult;
+
+interface OcrScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+    filename?: string | undefined;
+    language?: string | undefined;
+    pageSegmentationMode?: string | undefined;
+    maxImageSizeBytes?: number | undefined;
+}
+interface OcrScanResult {
+    text: string;
+}
+
+declare class OcrScraper {
+    #private;
+    constructor(options?: OcrScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    scan(imageBuffer: Buffer): Promise<WsperResponse<OcrScanResult>>;
+}
+
+declare function parseOcrUploadHtml(html: string, pageUrl: string): string;
+declare function parseOcrResultHtml(html: string): string;
+
+interface TopAnimeScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface TopAnimeItem {
+    rank: string;
+    title: string;
+    score: string;
+    url: string;
+    type: string;
+    release: string;
+    members: string;
+}
+
+declare class TopAnimeScraper {
+    #private;
+    constructor(options?: TopAnimeScraperOptions);
+    getTopAnime(limit?: number): Promise<WsperResponse<TopAnimeItem[]>>;
+}
+
+declare function parseTopAnimeHtml(html: string): TopAnimeItem[];
+
+interface ResepScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface ResepItem {
+    name: string;
+    url: string;
+    cookingTime: string;
+    author: string;
+}
+
+declare class ResepScraper {
+    #private;
+    constructor(options?: ResepScraperOptions);
+    search(query: string): Promise<WsperResponse<ResepItem[]>>;
+}
+
+declare function parseResepSearchHtml(html: string, pageUrl: string): ResepItem[];
+
+interface SakuraNovelScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface SakuraNovelSearchItem {
+    title: string;
+    cover: string;
+    type: string;
+    status: string;
+    url: string;
+}
+interface SakuraNovelChapterItem {
+    title: string;
+    url: string;
+}
+interface SakuraNovelDetail {
+    title: string;
+    cover: string;
+    synopsis: string;
+    chapters: SakuraNovelChapterItem[];
+}
+interface SakuraNovelChapterContent {
+    images: string[];
+    text: string;
+}
+
+declare class SakuraNovelScraper {
+    #private;
+    constructor(options?: SakuraNovelScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    search(query: string): Promise<WsperResponse<SakuraNovelSearchItem[]>>;
+    getDetail(url: string): Promise<WsperResponse<SakuraNovelDetail>>;
+    getChapter(url: string): Promise<WsperResponse<SakuraNovelChapterContent>>;
+}
+
+declare function parseSakuraNovelSearchHtml(html: string, pageUrl: string): SakuraNovelSearchItem[];
+declare function parseSakuraNovelDetailHtml(html: string, pageUrl: string): SakuraNovelDetail;
+declare function parseSakuraNovelChapterHtml(html: string, pageUrl: string): SakuraNovelChapterContent;
+
+interface PlayStoreScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface PlayStoreApp {
+    name: string;
+    appId: string;
+    url: string;
+    developer: string;
+    ratingText: string;
+    rating: string;
+    developerUrl: string;
+}
+
+declare class PlayStoreScraper {
+    #private;
+    constructor(options?: PlayStoreScraperOptions);
+    search(query: string, limit?: number): Promise<WsperResponse<PlayStoreApp[]>>;
+}
+
+declare function parsePlayStoreSearchHtml(html: string, pageUrl: string, limit: number): PlayStoreApp[];
+
+type SpotifyCredentialSource = "default" | "custom";
+interface SpotifyCredentialsConfig {
+    clientId: string;
+    clientSecret: string;
+    callbackUrl?: string | undefined;
+    market?: string | undefined;
+}
+interface ResolvedSpotifyCredentials {
+    clientId: string;
+    clientSecret: string;
+    callbackUrl: string;
+    market: string;
+    source: SpotifyCredentialSource;
+}
+interface SpotifyScraperOptions extends ScraperOptions {
+    spotifyCredentials?: SpotifyCredentialsConfig | undefined;
+    clientId?: string | undefined;
+    clientSecret?: string | undefined;
+    market?: string | undefined;
+}
+interface SpotifyTrackMeta extends WsperResponseMeta {
+    externalSourceUrl: string | null;
+}
+interface SpotifyImage {
+    url: string;
+    width: number | null;
+    height: number | null;
+}
+interface NormalizedSpotifyArtist {
+    id: string;
+    name: string;
+    uri: string;
+    url: string | null;
+    type: string | null;
+}
+interface NormalizedSpotifyAlbum {
+    id: string;
+    name: string;
+    type: string | null;
+    albumType: string | null;
+    uri: string;
+    url: string | null;
+    releaseDate: string | null;
+    releaseDatePrecision: string | null;
+    totalTracks: number | null;
+    images: SpotifyImage[];
+    artists: NormalizedSpotifyArtist[];
+    copyrights: Array<{
+        text: string;
+        type: string;
+    }>;
+    label: string | null;
+    popularity: number | null;
+}
+interface YtDlpChannel {
+    id: string | null;
+    name: string | null;
+    url: string | null;
+    isVerified: boolean | null;
+    followerCount: number | null;
+}
+interface YtDlpUploader {
+    name: string | null;
+    id: string | null;
+    url: string | null;
+}
+interface YtDlpStats {
+    viewCount: number | null;
+    likeCount: number | null;
+    commentCount: number | null;
+}
+interface ExternalSource {
+    provider: string;
+    extractor: string | null;
+    id: string | null;
+    displayId: string | null;
+    title: string | null;
+    fullTitle: string | null;
+    url: string | null;
+    originalUrl: string | null;
+    durationSeconds: number | null;
+    durationString: string | null;
+    mediaType: string | null;
+    availability: string | null;
+    isLive: boolean;
+    wasLive: boolean;
+    playableInEmbed: boolean | null;
+    ageLimit: number | null;
+    uploadDate: string | null;
+    timestamp: number | null;
+    thumbnail: string | null;
+    channel: YtDlpChannel;
+    uploader: YtDlpUploader;
+    stats: YtDlpStats;
+    categories: string[];
+    tags: string[];
+}
+interface DownloadAudioFormat {
+    formatId: string | null;
+    ext: string | null;
+    formatNote: string | null;
+    protocol: string | null;
+    acodec: string | null;
+    vcodec: string | null;
+    abr: number | null;
+    asr: number | null;
+    audioChannels: number | null;
+    filesize: number | null;
+    resolution: string | null;
+    hasDrm: boolean;
+}
+interface SelectedDownload {
+    formatId: string | null;
+    ext: string | null;
+    resolution: string | null;
+    video: {
+        formatId: string | null;
+        ext: string | null;
+        width: number | null;
+        height: number | null;
+        fps: number | null;
+        vcodec: string | null;
+        acodec: string | null;
+        filesize: number | null;
+    } | null;
+    audio: DownloadAudioFormat | null;
+}
+interface DownloadMetadata {
+    enabled: boolean;
+    tool: "yt-dlp";
+    sourceUrl: string | null;
+    recommendedAudioFormat: DownloadAudioFormat | null;
+    fallbackAudioFormats: DownloadAudioFormat[];
+    selectedDownload: SelectedDownload | null;
+    commandHint: string | null;
+}
+interface NormalizedSpotifyTrack {
+    id: string;
+    name: string;
+    type: string | null;
+    uri: string;
+    url: string | null;
+    durationMs: number;
+    durationSeconds: number;
+    explicit: boolean;
+    popularity: number | null;
+    previewUrl: string | null;
+    trackNumber: number | null;
+    discNumber: number | null;
+    isLocal: boolean;
+    isPlayable: boolean | null;
+    artists: NormalizedSpotifyArtist[];
+    album: NormalizedSpotifyAlbum;
+    externalIds: Record<string, string>;
+    availableMarkets: string[];
+    externalSource: ExternalSource | null;
+    download: DownloadMetadata | null;
+}
+interface NormalizedSpotifyAlbumTrack {
+    id: string;
+    name: string;
+    type: string | null;
+    uri: string;
+    url: string | null;
+    durationMs: number;
+    durationSeconds: number;
+    explicit: boolean;
+    previewUrl: string | null;
+    trackNumber: number | null;
+    discNumber: number | null;
+    isLocal: boolean;
+    artists: NormalizedSpotifyArtist[];
+    externalSource: ExternalSource | null;
+    download: DownloadMetadata | null;
+}
+interface NormalizedSpotifyPlaylistTrackItem {
+    addedAt: string | null;
+    addedBy: {
+        id: string | null;
+        uri: string | null;
+        url: string | null;
+    } | null;
+    isLocal: boolean;
+    track: NormalizedSpotifyTrack;
+}
+interface NormalizedSpotifyPlaylist {
+    id: string;
+    name: string;
+    description: string | null;
+    uri: string;
+    url: string | null;
+    public: boolean | null;
+    collaborative: boolean;
+    snapshotId: string | null;
+    owner: {
+        id: string | null;
+        name: string | null;
+        uri: string | null;
+        url: string | null;
+    } | null;
+    followersCount: number | null;
+    images: SpotifyImage[];
+    tracksTotal: number;
+    tracks: NormalizedSpotifyPlaylistTrackItem[];
+}
+type SpotifyEntityType = "track" | "album" | "playlist" | "artist";
+interface SpotifySearchResult {
+    query: string;
+    tracks: NormalizedSpotifyTrack[];
+    albums: NormalizedSpotifyAlbum[];
+}
+interface SpotifyOAuthToken {
+    accessToken: string;
+    refreshToken: string | null;
+    expiresIn: number;
+    tokenType: string;
+    scope: string | null;
+}
+type SpotifyDownloadAudioFormat = "mp3" | "m4a" | "opus" | "flac" | "wav";
+interface SpotifyDownloadAsset {
+    sourceUrl: string;
+    outputPath: string;
+    type: "audio";
+    trackId: string;
+    name: string;
+}
+interface SpotifyDownloadResult {
+    sourceUrl: string;
+    outputDir: string;
+    metadataPath: string | null;
+    assets: SpotifyDownloadAsset[];
+}
+interface SpotifyDownloadPostInput {
+    trackUrlOrId?: string;
+    trackUrl?: string;
+    trackId?: string;
+    outputDir: string;
+    audioFormat?: SpotifyDownloadAudioFormat | undefined;
+    ytdlpPath?: string | undefined;
+    includeMetadata?: boolean;
+}
+interface SpotifyDownloadProfileInput {
+    playlistUrlOrId?: string;
+    albumUrlOrId?: string;
+    profileUrlOrId?: string;
+    kind?: "playlist" | "album";
+    outputDir: string;
+    limit?: number;
+    audioFormat?: SpotifyDownloadAudioFormat | undefined;
+    ytdlpPath?: string | undefined;
+    includeMetadata?: boolean;
+}
+
+interface SpotifyAlbumWithTracks extends NormalizedSpotifyAlbum {
+    albumTracks: NormalizedSpotifyAlbumTrack[];
+}
+
+declare class SpotifyScraper {
+    #private;
+    constructor(options?: SpotifyScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getCredentialSource(): SpotifyCredentialSource;
+    getTrack(input: string, options?: {
+        enrichYtDlp?: boolean;
+    }): Promise<WsperResponse<NormalizedSpotifyTrack, SpotifyTrackMeta>>;
+    getAlbum(input: string, options?: {
+        enrichYtDlp?: boolean;
+        enrichLimit?: number;
+    }): Promise<WsperResponse<SpotifyAlbumWithTracks>>;
+    getPlaylist(input: string, options?: {
+        enrichYtDlp?: boolean;
+        enrichLimit?: number;
+    }): Promise<WsperResponse<NormalizedSpotifyPlaylist>>;
+    search(query: string, options?: {
+        limit?: number;
+        type?: Array<"track" | "album">;
+    }): Promise<WsperResponse<SpotifySearchResult>>;
+    downloadPost(input: SpotifyDownloadPostInput): Promise<WsperResponse<SpotifyDownloadResult>>;
+    downloadProfile(input: SpotifyDownloadProfileInput): Promise<WsperResponse<SpotifyDownloadResult>>;
+    createAuthUrl(options?: {
+        state?: string;
+        scopes?: string[];
+    }): {
+        state: string;
+        url: string;
+    };
+    exchangeCode(code: string): Promise<SpotifyOAuthToken>;
+    refreshToken(refreshToken: string): Promise<SpotifyOAuthToken>;
+    getAccessToken(): Promise<string>;
+    invalidateToken(): void;
+}
+
+declare function createSpotifyAuthUrl(options: {
+    clientId: string;
+    callbackUrl: string;
+    state?: string;
+    scopes?: string[];
+}): {
+    state: string;
+    url: string;
+};
+declare function exchangeSpotifyCodeForToken(code: string, options: {
+    clientId: string;
+    clientSecret: string;
+    callbackUrl: string;
+}): Promise<SpotifyOAuthToken>;
+declare function refreshSpotifyAccessToken(refreshToken: string, options: {
+    clientId: string;
+    clientSecret: string;
+}): Promise<SpotifyOAuthToken>;
+
+interface SpotifyExtracted {
+    type: SpotifyEntityType;
+    id: string;
+}
+declare function extractSpotifyId(input: string, expectedType?: SpotifyEntityType): SpotifyExtracted;
+
+declare function normalizePathfinderTrack(response: unknown): NormalizedSpotifyTrack;
+
+declare function safeFileName(input: string): string;
+interface YtDlpOptions {
+    sourceUrl: string;
+    track: NormalizedSpotifyTrack | NormalizedSpotifyAlbumTrack;
+    outputDir?: string | undefined;
+    audioFormat?: "mp3" | "m4a" | "opus" | "flac" | "wav" | undefined;
+    ytdlpPath?: string | undefined;
+}
+declare function downloadWithYtDlp(params: YtDlpOptions): Promise<string>;
+
+declare function buildYtDlpSearchQuery(track: {
+    name: string;
+    artists: Array<{
+        name: string;
+    }>;
+}): string;
+declare function searchYtDlpByTrack(track: {
+    name: string;
+    durationSeconds?: number;
+    artists: Array<{
+        name: string;
+    }>;
+}): Promise<Record<string, unknown> | null>;
+
+declare function normalizeYtDlpExternalSource(metadata: Record<string, unknown>): ExternalSource;
+declare function normalizeYtDlpDownload(metadata: Record<string, unknown>): DownloadMetadata;
+
+declare function enrichTrackWithYtDlp<T extends NormalizedSpotifyTrack | NormalizedSpotifyAlbumTrack>(track: T, options?: {
+    enabled?: boolean;
+}): Promise<T>;
+
+declare function exportJson(outputPath: string, data: unknown): Promise<string>;
+
+interface StalkScraperOptions {
+    npmRegistryUrl?: string | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+interface NpmCollaborator {
+    name: string;
+    url: string;
+}
+interface NpmInfoItem {
+    type: string;
+    result: string;
+}
+interface NpmPackage {
+    title: string;
+    language: string;
+    publish: string;
+    readme: string;
+    explore: string;
+    dependencies: string;
+    dependents: string;
+    version_count: string;
+    keywords: string[];
+    install: string;
+    info: NpmInfoItem[];
+    collaborator: NpmCollaborator[];
+}
+
+declare class StalkScraper {
+    #private;
+    constructor(options?: StalkScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getNpmPackage(packageName: string): Promise<WsperResponse<NpmPackage>>;
+}
+
+declare function parseNpmPackage(input: unknown, requestedName: string): NpmPackage;
+
+interface YouTubeScraperOptions {
+    debug?: boolean;
+    ytdlpPath?: string;
+    ffmpegPath?: string;
+    ffprobePath?: string;
+    outputDir?: string;
+    searchLimit?: number;
+}
+interface YoutubeThumbnail {
+    url: string;
+    width: number | null;
+    height: number | null;
+}
+interface YoutubeChannel {
+    id: string | null;
+    name: string | null;
+    url: string | null;
+    handle: string | null;
+    isVerified: boolean | null;
+    followerCount: number | null;
+}
+interface YoutubeUploader {
+    id: string | null;
+    name: string | null;
+    url: string | null;
+}
+interface YoutubeStats {
+    viewCount: number | null;
+    likeCount: number | null;
+    commentCount: number | null;
+    repostCount: number | null;
+}
+interface YoutubeAudioFormat {
+    formatId: string | null;
+    ext: string | null;
+    formatNote: string | null;
+    protocol: string | null;
+    acodec: string | null;
+    vcodec: string | null;
+    abr: number | null;
+    asr: number | null;
+    audioChannels: number | null;
+    filesize: number | null;
+    resolution: string | null;
+    hasDrm: boolean;
+}
+interface YoutubeVideoFormat {
+    formatId: string | null;
+    ext: string | null;
+    formatNote: string | null;
+    protocol: string | null;
+    vcodec: string | null;
+    acodec: string | null;
+    width: number | null;
+    height: number | null;
+    fps: number | null;
+    vbr: number | null;
+    filesize: number | null;
+    resolution: string | null;
+    hasDrm: boolean;
+}
+interface YoutubeSelectedDownload {
+    formatId: string | null;
+    ext: string | null;
+    resolution: string | null;
+    video: YoutubeVideoFormat | null;
+    audio: YoutubeAudioFormat | null;
+}
+interface YoutubeDownloadInfo {
+    enabled: boolean;
+    tool: "yt-dlp";
+    sourceUrl: string | null;
+    recommendedAudioFormat: YoutubeAudioFormat | null;
+    fallbackAudioFormats: YoutubeAudioFormat[];
+    recommendedVideoFormat: YoutubeVideoFormat | null;
+    fallbackVideoFormats: YoutubeVideoFormat[];
+    selectedDownload: YoutubeSelectedDownload | null;
+    commandHint: string | null;
+}
+interface YoutubeVideoMetadata {
+    provider: "youtube";
+    extractor: string | null;
+    id: string;
+    displayId: string | null;
+    title: string;
+    fullTitle: string | null;
+    url: string;
+    originalUrl: string | null;
+    durationSeconds: number | null;
+    durationString: string | null;
+    mediaType: string | null;
+    availability: string | null;
+    isLive: boolean;
+    wasLive: boolean;
+    playableInEmbed: boolean | null;
+    ageLimit: number | null;
+    uploadDate: string | null;
+    timestamp: number | null;
+    description: string | null;
+    thumbnail: string | null;
+    thumbnails: YoutubeThumbnail[];
+    channel: YoutubeChannel;
+    uploader: YoutubeUploader;
+    stats: YoutubeStats;
+    categories: string[];
+    tags: string[];
+    formats: {
+        audio: YoutubeAudioFormat[];
+        video: YoutubeVideoFormat[];
+    };
+    download: YoutubeDownloadInfo;
+}
+interface YoutubeSearchResult {
+    query: string;
+    total: number;
+    items: YoutubeVideoMetadata[];
+}
+interface YoutubePlaylistEntry {
+    id: string | null;
+    title: string | null;
+    url: string | null;
+    durationSeconds: number | null;
+}
+interface YoutubePlaylistData {
+    id: string | null;
+    title: string | null;
+    url: string | null;
+    uploader: string | null;
+    channel: string | null;
+    entriesTotal: number;
+    entries: YoutubePlaylistEntry[];
+}
+interface YoutubeChannelData {
+    id: string | null;
+    title: string | null;
+    url: string | null;
+    channel: string | null;
+    channelId: string | null;
+    uploader: string | null;
+    uploaderId: string | null;
+    entriesTotal: number;
+    entries: YoutubePlaylistEntry[];
+}
+interface YoutubeDownloadResult {
+    sourceUrl: string;
+    outputDir: string;
+    format: string;
+    type: "video" | "audio";
+    command: string[];
+}
+interface YoutubeAudioExtractResult {
+    inputPath: string;
+    outputPath: string;
+    format: string;
+    bitrate: string | null;
+}
+type YoutubeAudioFormatId = "mp3" | "m4a" | "opus" | "flac" | "wav";
+
+declare class YouTubeScraper {
+    #private;
+    constructor(options?: YouTubeScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getVideo(input: string): Promise<WsperResponse<YoutubeVideoMetadata>>;
+    searchVideos(query: string, options?: {
+        limit?: number;
+    }): Promise<WsperResponse<YoutubeSearchResult>>;
+    downloadVideo(input: string, options?: {
+        outputDir?: string;
+        fileName?: string;
+        format?: string;
+    }): Promise<WsperResponse<YoutubeDownloadResult>>;
+    downloadAudio(input: string, options?: {
+        outputDir?: string;
+        fileName?: string;
+        audioFormat?: YoutubeAudioFormatId;
+    }): Promise<WsperResponse<YoutubeDownloadResult>>;
+    extractAudio(inputPath: string, options?: {
+        outputPath?: string;
+        outputDir?: string;
+        audioFormat?: YoutubeAudioFormatId;
+        audioBitrate?: string;
+    }): Promise<WsperResponse<YoutubeAudioExtractResult>>;
+    getPlaylist(input: string): Promise<WsperResponse<YoutubePlaylistData>>;
+    getChannel(input: string): Promise<WsperResponse<YoutubeChannelData>>;
+}
+
+interface YoutubeBasicInfo {
+    id: string | null;
+    title: string | null;
+    url: string | null;
+    durationSeconds: number | null;
+    channel: {
+        name: string | null;
+        id: string | null;
+        url: string | null;
+    };
+    thumbnails: unknown[];
+}
+
+interface ThreadsMediaCandidate {
+    url: string;
+    width: number | null;
+    height: number | null;
+}
+interface ThreadsVideoVersion {
+    url: string;
+    width: number | null;
+    height: number | null;
+    type: number | null;
+}
+interface ThreadsBioLink {
+    url: string;
+    title: string | null;
+}
+interface ThreadsCaption {
+    text: string;
+    pk: string | null;
+    hasTranslation: boolean;
+}
+interface ThreadsStats {
+    likeCount: number | null;
+    directReplyCount: number | null;
+    repostCount: number | null;
+    quoteCount: number | null;
+    reshareCount: number | null;
+    impressionCount: number | null;
+}
+interface ThreadsTopic {
+    id: string | null;
+    name: string | null;
+}
+interface ThreadsMedia {
+    images: ThreadsMediaCandidate[];
+    videos: ThreadsVideoVersion[];
+    carousel: ThreadsMediaItem[];
+    bestImage: ThreadsMediaCandidate | null;
+    bestVideo: ThreadsVideoVersion | null;
+}
+interface ThreadsMediaItem {
+    id: string | null;
+    pk: string | null;
+    mediaType: number | null;
+    images: ThreadsMediaCandidate[];
+    videos: ThreadsVideoVersion[];
+    bestImage: ThreadsMediaCandidate | null;
+    bestVideo: ThreadsVideoVersion | null;
+}
+interface ThreadsUser {
+    id: string | null;
+    pk: string | null;
+    username: string | null;
+    fullName: string | null;
+    biography: string | null;
+    profilePicUrl: string | null;
+    hdProfilePics: ThreadsMediaCandidate[];
+    followerCount: number | null;
+    isVerified: boolean | null;
+    isPrivate: boolean | null;
+    bioLinks: ThreadsBioLink[];
+}
+interface ThreadsPost {
+    id: string | null;
+    pk: string | null;
+    fbid: string | null;
+    code: string | null;
+    url: string | null;
+    takenAt: number | null;
+    mediaType: number | null;
+    author: ThreadsUser | null;
+    caption: ThreadsCaption | null;
+    stats: ThreadsStats;
+    topic: ThreadsTopic | null;
+    media: ThreadsMedia;
+    replies: ThreadsPost[];
+}
+interface ThreadsProfile extends ThreadsUser {
+    profileUrl: string | null;
+    threadsCountText: string | null;
+    publicViewCount: number | null;
+    posts: ThreadsPost[];
+}
+interface ThreadsPageInfo {
+    cursor: string | null;
+    hasNextPage: boolean;
+}
+interface ThreadsSearchResult {
+    query: string;
+    serpType: "default" | "tags" | "users";
+    language: string;
+    count: number;
+    results: (ThreadsPost | ThreadsUser)[];
+    pageInfo: ThreadsPageInfo;
+}
+interface ThreadsDownloadAsset {
+    url: string;
+    outputPath: string;
+    type: "image" | "video";
+    index: number;
+}
+interface ThreadsDownloadResult {
+    sourceUrl: string;
+    outputDir: string;
+    metadataPath: string | null;
+    assets: ThreadsDownloadAsset[];
+}
+interface ThreadsSearchOptions {
+    lang?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface ThreadsPostInput {
+    username: string;
+    shortcode: string;
+}
+interface ThreadsDownloadProfileInput {
+    usernameOrUrl: string;
+    outputDir: string;
+    includeProfilePicture?: boolean;
+    includeInitialPosts?: boolean;
+    includeMetadata?: boolean;
+}
+interface ThreadsDownloadPostInput {
+    postUrl: string;
+    outputDir: string;
+    includeMetadata?: boolean;
+}
+interface ThreadsScraperOptions {
+    credentials?: WsperCredentials;
+    debug?: boolean;
+    http?: HttpOptions;
+    queue?: QueueOptions;
+}
+
+declare class ThreadsScraper {
+    #private;
+    constructor(options?: ThreadsScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getProfile(usernameOrUrl: string): Promise<WsperResponse<ThreadsProfile>>;
+    getPost(input: string | ThreadsPostInput): Promise<WsperResponse<ThreadsPost>>;
+    search(query: string, options?: ThreadsSearchOptions): Promise<WsperResponse<ThreadsSearchResult>>;
+    searchByTag(query: string, options?: ThreadsSearchOptions): Promise<WsperResponse<ThreadsSearchResult>>;
+    searchUsers(query: string, options?: ThreadsSearchOptions): Promise<WsperResponse<ThreadsSearchResult>>;
+    downloadPost(input: ThreadsDownloadPostInput): Promise<WsperResponse<ThreadsDownloadResult>>;
+    downloadProfile(input: ThreadsDownloadProfileInput): Promise<WsperResponse<ThreadsDownloadResult>>;
+}
+
+interface PinterestImageVariant {
+    key: string;
+    url: string;
+    width: number | null;
+    height: number | null;
+}
+interface PinterestVideoVariant {
+    url: string;
+    width: number | null;
+    height: number | null;
+    durationMs: number | null;
+    contentType: string | null;
+}
+interface PinterestStoryBlock {
+    type: string;
+    imageUrl: string | null;
+    videoUrl: string | null;
+}
+interface PinterestStoryPage {
+    index: number;
+    blocks: PinterestStoryBlock[];
+}
+interface PinterestMedia {
+    images: PinterestImageVariant[];
+    bestImage: PinterestImageVariant | null;
+    videos: PinterestVideoVariant[];
+    bestVideo: PinterestVideoVariant | null;
+    storyPages: PinterestStoryPage[];
+}
+interface PinterestUser {
+    id: string | null;
+    username: string | null;
+    fullName: string | null;
+    imageMediumUrl: string | null;
+    imageLargeUrl: string | null;
+}
+interface PinterestBoard {
+    id: string | null;
+    nodeId: string | null;
+    name: string | null;
+    url: string | null;
+}
+interface PinterestStats {
+    repinCount: number | null;
+    commentCount: number | null;
+}
+interface PinterestPin {
+    id: string;
+    nodeId: string | null;
+    title: string | null;
+    description: string | null;
+    domain: string | null;
+    link: string | null;
+    url: string;
+    media: PinterestMedia;
+    pinner: PinterestUser | null;
+    board: PinterestBoard | null;
+    stats: PinterestStats;
+}
+interface PinterestPageInfo {
+    bookmark: string | null;
+    hasNextPage: boolean;
+}
+interface PinterestSearchResult {
+    query: string;
+    count: number;
+    pins: PinterestPin[];
+    pageInfo: PinterestPageInfo;
+}
+interface PinterestDownloadAsset {
+    url: string;
+    outputPath: string;
+    type: "image" | "video";
+    index: number;
+}
+interface PinterestDownloadResult {
+    sourceUrl: string;
+    outputDir: string;
+    metadataPath: string | null;
+    assets: PinterestDownloadAsset[];
+}
+interface PinterestSearchOptions {
+    limit?: number;
+    locale?: string;
+    bookmark?: string;
+}
+interface PinterestDownloadPinInput {
+    pinUrlOrId: string;
+    outputDir: string;
+    includeMetadata?: boolean;
+    includeStoryPages?: boolean;
+}
+interface PinterestScraperOptions {
+    credentials?: WsperCredentials;
+    debug?: boolean;
+    http?: HttpOptions;
+    queue?: QueueOptions;
+}
+
+declare class PinterestScraper {
+    #private;
+    constructor(options?: PinterestScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getPin(input: string): Promise<WsperResponse<PinterestPin>>;
+    searchPins(query: string, options?: PinterestSearchOptions): Promise<WsperResponse<PinterestSearchResult>>;
+    downloadPin(input: PinterestDownloadPinInput): Promise<WsperResponse<PinterestDownloadResult>>;
+}
+
+interface PhotoAiScraperOptions {
+    baseUrl?: string | undefined;
+    maxImageSizeBytes?: number | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+interface PhotoAiUploadResult {
+    code: string;
+}
+interface PhotoAiCheckResult {
+    status: string;
+    downloadUrl: string | null;
+    raw: Record<string, unknown>;
+}
+
+declare class PhotoAiScraper {
+    #private;
+    constructor(options?: PhotoAiScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    upload(filePath: string): Promise<WsperResponse<PhotoAiUploadResult>>;
+    uploadBuffer(imageBuffer: Buffer, filename?: string, startedAt?: number): Promise<WsperResponse<PhotoAiUploadResult>>;
+    checkStatus(code: string): Promise<WsperResponse<PhotoAiCheckResult>>;
+}
+
+declare function parsePhotoAiUploadResponse(input: unknown): PhotoAiUploadResult;
+declare function parsePhotoAiCheckResponse(input: unknown): PhotoAiCheckResult;
+
+interface TwitterUser {
+    id: string;
+    screenName: string;
+    name: string;
+    description: string | null;
+    createdAt: string | null;
+    location: string | null;
+    profilePicUrl: string | null;
+    profileBannerUrl: string | null;
+    url: string | null;
+    followersCount: number | null;
+    followingCount: number | null;
+    favouritesCount: number | null;
+    listedCount: number | null;
+    mediaCount: number | null;
+    statusesCount: number | null;
+    isBlueVerified: boolean | null;
+    isVerified: boolean | null;
+}
+interface TwitterTweetStats {
+    bookmarkCount: number | null;
+    favoriteCount: number | null;
+    retweetCount: number | null;
+    replyCount: number | null;
+    quoteCount: number | null;
+    viewCount: number | null;
+}
+interface TwitterEntityUrl {
+    url: string;
+    expandedUrl: string | null;
+    displayUrl: string | null;
+}
+interface TwitterHashtag {
+    text: string;
+}
+interface TwitterMention {
+    screenName: string;
+    name: string | null;
+    id: string | null;
+}
+interface TwitterEntities {
+    urls: TwitterEntityUrl[];
+    hashtags: TwitterHashtag[];
+    mentions: TwitterMention[];
+}
+interface TwitterVideoVariant {
+    url: string;
+    contentType: string;
+    bitrate: number | null;
+}
+interface TwitterVideoInfo {
+    durationMs: number | null;
+    aspectRatio: [number, number] | null;
+    variants: TwitterVideoVariant[];
+    bestMp4: TwitterVideoVariant | null;
+    hlsUrl: string | null;
+}
+interface TwitterMedia {
+    id: string | null;
+    mediaKey: string | null;
+    type: "photo" | "video" | "animated_gif" | string;
+    mediaUrl: string | null;
+    originalWidth: number | null;
+    originalHeight: number | null;
+    videoInfo: TwitterVideoInfo | null;
+}
+interface TwitterTweet {
+    id: string;
+    url: string;
+    fullText: string;
+    createdAt: string | null;
+    lang: string | null;
+    conversationId: string | null;
+    author: TwitterUser | null;
+    stats: TwitterTweetStats;
+    entities: TwitterEntities;
+    media: TwitterMedia[];
+    source: string | null;
+    isTranslatable: boolean | null;
+}
+interface TwitterCursor {
+    type: "top" | "bottom" | string;
+    value: string;
+}
+interface TwitterPageInfo {
+    topCursor: string | null;
+    bottomCursor: string | null;
+    hasNextPage: boolean;
+}
+interface TwitterTweetDetail {
+    tweet: TwitterTweet;
+    replies: TwitterTweet[];
+    sourceUrl: string;
+}
+interface TwitterSearchResult {
+    query: string;
+    querySource: string;
+    product: string;
+    tweets: TwitterTweet[];
+    count: number;
+    pageInfo: TwitterPageInfo;
+    sourceUrl: string;
+}
+interface TwitterUserSearchResult {
+    query: string;
+    count: number;
+    users: TwitterUser[];
+    pageInfo: TwitterPageInfo;
+    sourceUrl: string;
+}
+interface TwitterUserTimeline {
+    userId: string;
+    tweets: TwitterTweet[];
+    pinnedTweet: TwitterTweet | null;
+    count: number;
+    pageInfo: TwitterPageInfo;
+    sourceUrl: string;
+}
+interface TwitterDownloadAsset {
+    url: string;
+    outputPath: string;
+    type: "photo" | "video" | "animated_gif";
+    mediaIndex: number;
+}
+interface TwitterDownloadResult {
+    tweetId: string;
+    sourceUrl: string;
+    outputDir: string;
+    metadataPath: string | null;
+    assets: TwitterDownloadAsset[];
+}
+interface TwitterProfileDownloadAsset {
+    url: string;
+    outputPath: string;
+    type: "profile_image" | "profile_banner" | "photo" | "video" | "animated_gif";
+    tweetId: string | null;
+    mediaIndex: number;
+}
+interface TwitterProfileDownloadResult {
+    user: TwitterUser;
+    sourceUrl: string;
+    outputDir: string;
+    metadataPath: string | null;
+    assets: TwitterProfileDownloadAsset[];
+}
+interface TwitterScraperOptions {
+    credentials?: WsperCredentials;
+    debug?: boolean;
+    http?: HttpOptions;
+    queue?: QueueOptions;
+}
+interface TwitterTweetInput {
+    tweetUrl?: string;
+    tweetId?: string;
+}
+interface TwitterSearchOptions {
+    count?: number;
+    cursor?: string;
+    product?: "Top" | "Latest" | "People" | "Photos" | "Videos";
+    querySource?: string;
+}
+interface TwitterUserTimelineInput {
+    userId?: string;
+    usernameOrUrl?: string;
+    count?: number;
+    cursor?: string;
+}
+interface TwitterDownloadTweetInput {
+    tweetUrl?: string;
+    tweetId?: string;
+    outputDir: string;
+    includeMetadata?: boolean;
+}
+interface TwitterDownloadProfileInput {
+    usernameOrUrl: string;
+    outputDir: string;
+    includeProfileImage?: boolean;
+    includeBanner?: boolean;
+    includeInitialPosts?: boolean;
+    count?: number;
+    includeMetadata?: boolean;
+}
+
+declare class TwitterScraper {
+    #private;
+    constructor(options?: TwitterScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getTweet(input: TwitterTweetInput): Promise<WsperResponse<TwitterTweetDetail>>;
+    searchTweets(query: string, options?: TwitterSearchOptions): Promise<WsperResponse<TwitterSearchResult>>;
+    searchTrend(query: string, options?: TwitterSearchOptions): Promise<WsperResponse<TwitterSearchResult>>;
+    searchByTag(tag: string, options?: TwitterSearchOptions): Promise<WsperResponse<TwitterSearchResult>>;
+    searchUsers(query: string, options?: Omit<TwitterSearchOptions, "product">): Promise<WsperResponse<TwitterUserSearchResult>>;
+    getProfile(usernameOrUrl: string): Promise<WsperResponse<TwitterUser>>;
+    getUserTimeline(input: TwitterUserTimelineInput): Promise<WsperResponse<TwitterUserTimeline>>;
+    downloadTweetMedia(input: TwitterDownloadTweetInput): Promise<WsperResponse<TwitterDownloadResult>>;
+    downloadPost(input: TwitterDownloadTweetInput): Promise<WsperResponse<TwitterDownloadResult>>;
+    downloadProfile(input: TwitterDownloadProfileInput): Promise<WsperResponse<TwitterProfileDownloadResult>>;
+}
+
+interface UguuScraperOptions extends ScraperOptions {
+    uploadUrl?: string | undefined;
+    maxFileSizeBytes?: number | undefined;
+}
+interface UguuUploadResult {
+    url: string;
+}
+
+declare class UguuScraper {
+    #private;
+    constructor(options?: UguuScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    upload(buffer: Buffer, filename?: string): Promise<WsperResponse<UguuUploadResult>>;
+}
+
+declare function parseUguuUploadResponse(raw: unknown): UguuUploadResult;
+
+interface UpscalerScraperOptions {
+    baseUrl?: string | undefined;
+    maxImageSizeBytes?: number | undefined;
+    maxPollAttempts?: number | undefined;
+    pollIntervalMs?: number | undefined;
+    model?: number | undefined;
+    functionName?: string | undefined;
+    settings?: string | undefined;
+    debug?: boolean | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+}
+interface UpscalerResult {
+    id: string;
+    input: string | null;
+    output: string;
+}
+
+declare class UpscalerScraper {
+    #private;
+    constructor(options?: UpscalerScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    upscale(imageInput: string | Buffer): Promise<WsperResponse<UpscalerResult>>;
+    upscaleBuffer(imageBuffer: Buffer, mimeType?: string, startedAt?: number): Promise<WsperResponse<UpscalerResult>>;
+}
+
+declare function parseUpscalerCreateResponse(input: unknown): string;
+declare function parseUpscalerResultResponse(input: unknown, taskId: string): UpscalerResult | null;
+
+interface VideyScraperOptions extends ScraperOptions {
+    uploadUrl?: string | undefined;
+    maxFileSizeBytes?: number | undefined;
+    visitorId?: string | undefined;
+}
+interface VideyUploadResult {
+    output: unknown;
+}
+
+declare class VideyScraper {
+    #private;
+    constructor(options?: VideyScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    upload(filePath: string): Promise<WsperResponse<VideyUploadResult>>;
+    uploadBuffer(buffer: Buffer, filename?: string, startedAt?: number): Promise<WsperResponse<VideyUploadResult>>;
+}
+
+declare function parseVideyUploadResponse(raw: unknown): VideyUploadResult;
+
+interface WallpaperScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface WallpaperItem {
+    title: string;
+    resolution: string;
+    image: string;
+    page: string;
+}
+interface WallpaperResult {
+    total: number;
+    results: WallpaperItem[];
+}
+
+declare class WallpaperScraper {
+    #private;
+    constructor(options?: WallpaperScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    search(query: string): Promise<WsperResponse<WallpaperResult>>;
+}
+
+declare function parseWallpaperSearchHtml(html: string, pageUrl: string): WallpaperResult;
+
+interface Webp2Mp4ScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+    maxFileSizeBytes?: number | undefined;
+}
+interface Webp2Mp4Result {
+    url: string;
+}
+type Webp2Mp4Source = Buffer | string;
+
+declare class Webp2Mp4Scraper {
+    #private;
+    constructor(options?: Webp2Mp4ScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    toMp4(source: Webp2Mp4Source): Promise<WsperResponse<Webp2Mp4Result>>;
+    toPng(source: Webp2Mp4Source): Promise<WsperResponse<Webp2Mp4Result>>;
+}
+
+declare function parseEzgifUploadForm(html: string, pageUrl: string): Record<string, string>;
+declare function parseEzgifOutputUrl(html: string, pageUrl: string, selector: string, attr: string): string;
+
+interface WwCharScraperOptions extends ScraperOptions {
+    baseUrl?: string | undefined;
+}
+interface WwCharResult {
+    title: string;
+    slug: string;
+    url: string;
+    bio: string | null;
+    profile: Record<string, string>;
+    images: string[];
+}
+
+declare class WwCharScraper {
+    #private;
+    constructor(options?: WwCharScraperOptions);
+    enableLogs(): this;
+    disableLogs(): this;
+    getCharacter(name: string): Promise<WsperResponse<WwCharResult>>;
+}
+
+declare function parseWwCharHtml(html: string, pageUrl: string, slug: string): WwCharResult;
+declare function toWwCharSlug(name: string): string;
+
+interface WsperPlatformCredentialsConfig {
+    instagram?: WsperCredentials | undefined;
+    pinterest?: WsperCredentials | undefined;
+    threads?: WsperCredentials | undefined;
+    twitter?: WsperCredentials | undefined;
+}
+interface WsperScraperConfig {
+    debug?: boolean | undefined;
+    spotifyCredentials?: SpotifyCredentialsConfig | undefined;
+    credentials?: WsperPlatformCredentialsConfig | undefined;
+    http?: HttpOptions | undefined;
+    queue?: QueueOptions | undefined;
+    youtube?: YouTubeScraperOptions | undefined;
+}
+declare class WsperScraper {
+    readonly spotify: SpotifyScraper;
+    readonly twitter: TwitterScraper;
+    readonly threads: ThreadsScraper;
+    readonly instagram: InstagramScraper;
+    readonly pinterest: PinterestScraper;
+    readonly youtube: YouTubeScraper;
+    constructor(config?: WsperScraperConfig);
+}
+
+declare function sleep(ms: number): Promise<void>;
+
+declare function getDefaultUserAgent(): string;
+declare function getRandomUserAgent(): string;
+
+interface BrowserHeaderProfile {
+    userAgent: string;
+    headers: Record<string, string>;
+}
+declare function getDefaultBrowserHeaderProfile(): BrowserHeaderProfile;
+declare function getRandomBrowserHeaderProfile(): BrowserHeaderProfile;
+
+declare function assertNonEmptyString(value: unknown, name: string): string;
+declare function assertSafeHttpUrl(input: unknown, options?: {
+    allowPrivateNetwork?: boolean;
+}): URL;
+declare function clampInteger(value: number, min: number, max: number): number;
+declare function isRetryableHttpError(error: unknown): boolean;
+
+declare function normalizeUrl(input: string): string;
+declare function resolveUrl(base: string | URL, path: string): URL;
+
+declare function zenFetchSource(url: string): Promise<string>;
+declare function zenWafSession(url: string): Promise<{
+    cookie: string;
+    headers: Record<string, string>;
+}>;
+
+export { ANALYTICS_CHART_MODELS, ANALYTICS_CHART_MODEL_NAMES, ANIME_CHARACTERS, AlkitabScraper, type AlkitabScraperOptions, type AlkitabVerse, type AnalyticsChartModel, type AnalyticsChartModelName, type AnalyticsChartVariant, type AnalyticsImageOptions, type AnalyticsTheme, type Android1Item, type Android1Result, type AnimationConfig, type AnimationDirection, type AnimationMode, type AnimationStep, type AnimeCharacter, type AnimeQuoteItem, AnimeQuoteScraper, type AnimeQuoteScraperOptions, type AnimeRandomResult, AnimeRandomScraper, type AnimeRandomScraperOptions, type AptoideItem, type AptoideResult, type BMKGBaseUrls, type BMKGEarthquake, type BMKGEarthquakeFeed, type BMKGForecast, type BMKGNowcasting, BMKGScraper, type BMKGScraperOptions, type BMKGShakemapDownload, BMKG_DEFAULT_BASE_URLS, BMKG_PROVINCE_CODES, BMKG_QUEUE_DEFAULTS, type BackgroundConfig, type BackgroundLinearConfig, type BackgroundRadialConfig, type BackgroundSolidConfig, BiliBiliScraper, type BiliBiliScraperOptions, type BiliBiliSearchItem, type BiliBiliSearchResult, type BiliBiliVideoInfo, type BiliBiliVideoStream, type BratConfig, BratGenerator, type BratResult, type BrowserHeaderProfile, CANVAS_PRESETS, CUACA_CITY_COORDS, CUACA_DEFAULT_BASE_URLS, CUACA_QUEUE_DEFAULTS, CUACA_WIND_DIRECTIONS, type CanvasConfig, type CanvasPreset, type CapCutDownloadResult, CapCutScraper, type CapCutScraperOptions, ChartGenerator, type ConvertOptions, CredentialsManager, type CuacaBaseUrls, type CuacaResult, CuacaScraper, type CuacaScraperOptions, type CuacaSearchResult, type CuacaWarningInfo, DEFAULT_ANIMATION, DEFAULT_CANVAS, DEFAULT_PADDING, DEFAULT_TEXT, type DownloadAudioFormat, DownloadError, type DownloadMetadata, type DownloadOptions, type DownloadResult, Downloader, type DrakorArtist, type DrakorDetail, type DrakorEpisode, type DrakorGenre, type DrakorItem, type DrakorList, type DrakorPagination, DrakorScraper, type DrakorScraperOptions, type DramaboxListItem, type DramaboxResult, DramaboxScraper, type DramaboxScraperOptions, type ExternalSource, FFMPEG_PATH, type FaceswapResult, FaceswapScraper, type FaceswapScraperOptions, type GifOutputConfig, type HokInfoResult, HokInfoScraper, type HokInfoScraperOptions, HtmlMetadataParser, type HtmlToJpgPageOrientation, type HtmlToJpgPageSize, type HtmlToJpgResult, HtmlToJpgScraper, type HtmlToJpgScraperOptions, type HtmlToJpgTask, type HtmlToJpgUploadForm, HttpClient, HttpError, type HttpErrorOptions, type HttpOptions, type HttpRequestOptions, type HttpResponse, type IkiruMangaItem, type IkiruMangaResult, IkiruMangaScraper, type IkiruMangaScraperOptions, type ImageOutputConfig, type ImagePost, ImageScraper, type ImageScraperOptions, type ImageSearchOptions, type ImageSearchResult, type ImageSiteName, type ImgUpscalerResult, type ImgUpscalerScale, ImgUpscalerScraper, type ImgUpscalerScraperOptions, type InstagramCarouselItem, type InstagramDownloadAsset, type InstagramDownloadPostInput, type InstagramDownloadProfileInput, type InstagramDownloadResult, type InstagramFeed, type InstagramFeedOptions, type InstagramMediaItem, type InstagramProfile, type InstagramProfileWithFeed, InstagramScraper, type InstagramScraperOptions, JsonParser, type KomikindoDetail, KomikindoScraper, type KomikindoScraperOptions, type KomikindoSearchItem, type LineLayout, type LinearGradientDirection, type LogLevel, type LyricsResult, LyricsScraper, type LyricsScraperOptions, type MConverterConvertResult, MConverterScraper, type MConverterScraperOptions, type MConverterTarget, type MConverterTargetsResult, type MaybePromise, type McAddonDetail, type McAddonResult, McAddonScraper, type McAddonScraperOptions, type McAddonSearchItem, type MediafireResult, MediafireScraper, type MediafireScraperOptions, ModAndroidScraper, type ModAndroidScraperOptions, type ModAndroidSearchResult, type ModyoloItem, type ModyoloResult, type MonthlyChartStyle, type MonthlyPoint, type NormalizedAnimation, type NormalizedBratConfig, type NormalizedPadding, type NormalizedSpotifyAlbum, type NormalizedSpotifyAlbumTrack, type NormalizedSpotifyArtist, type NormalizedSpotifyPlaylist, type NormalizedSpotifyPlaylistTrackItem, type NormalizedSpotifyTrack, type NpmCollaborator, type NpmInfoItem, type NpmPackage, type Nullable, type OcrScanResult, OcrScraper, type OcrScraperOptions, type Optional, type OutputConfig, PLATFORM_DEFAULT_HEADERS, type PaddingConfig, ParseError, type ParsedHtmlMetadata, type PhotoAiCheckResult, PhotoAiScraper, type PhotoAiScraperOptions, type PhotoAiUploadResult, type PinterestBoard, type PinterestDownloadAsset, type PinterestDownloadPinInput, type PinterestDownloadResult, type PinterestImageVariant, type PinterestMedia, type PinterestPageInfo, type PinterestPin, PinterestScraper, type PinterestScraperOptions, type PinterestSearchOptions, type PinterestSearchResult, type PinterestStats, type PinterestStoryBlock, type PinterestStoryPage, type PinterestUser, type PinterestVideoVariant, type PlayStoreApp, PlayStoreScraper, type PlayStoreScraperOptions, type QueueOptions, type RadialGradientPosition, type RenderFrame, RequestQueue, type ResepItem, ResepScraper, type ResepScraperOptions, type ResolvedSpotifyCredentials, type SakuraNovelChapterContent, type SakuraNovelChapterItem, type SakuraNovelDetail, SakuraNovelScraper, type SakuraNovelScraperOptions, type SakuraNovelSearchItem, ScraperError, type ScraperOptions, type SelectedDownload, type SpotifyCredentialSource, type SpotifyCredentialsConfig, type SpotifyDownloadAsset, type SpotifyDownloadAudioFormat, type SpotifyDownloadPostInput, type SpotifyDownloadProfileInput, type SpotifyDownloadResult, type SpotifyEntityType, type SpotifyExtracted, type SpotifyImage, type SpotifyOAuthToken, SpotifyScraper, type SpotifyScraperOptions, type SpotifySearchResult, type SpotifyTrackMeta, StalkScraper, type StalkScraperOptions, type StickerConfig, type StickerTextOptions, type StylePreset, type TextAlign, type TextConfig, type ThreadsBioLink, type ThreadsCaption, type ThreadsDownloadAsset, type ThreadsDownloadPostInput, type ThreadsDownloadProfileInput, type ThreadsDownloadResult, type ThreadsMedia, type ThreadsMediaCandidate, type ThreadsMediaItem, type ThreadsPageInfo, type ThreadsPost, type ThreadsPostInput, type ThreadsProfile, ThreadsScraper, type ThreadsScraperOptions, type ThreadsSearchOptions, type ThreadsSearchResult, type ThreadsStats, type ThreadsTopic, type ThreadsUser, type ThreadsVideoVersion, type Timestamped, type TopAnimeItem, TopAnimeScraper, type TopAnimeScraperOptions, type TwitterCursor, type TwitterDownloadAsset, type TwitterDownloadProfileInput, type TwitterDownloadResult, type TwitterDownloadTweetInput, type TwitterEntities, type TwitterEntityUrl, type TwitterHashtag, type TwitterMedia, type TwitterMention, type TwitterPageInfo, type TwitterProfileDownloadAsset, type TwitterProfileDownloadResult, TwitterScraper, type TwitterScraperOptions, type TwitterSearchOptions, type TwitterSearchResult, type TwitterTweet, type TwitterTweetDetail, type TwitterTweetInput, type TwitterTweetStats, type TwitterUser, type TwitterUserSearchResult, type TwitterUserTimeline, type TwitterUserTimelineInput, type TwitterVideoInfo, type TwitterVideoVariant, UguuScraper, type UguuScraperOptions, type UguuUploadResult, type UpscalerResult, UpscalerScraper, type UpscalerScraperOptions, type UptodownItem, type UptodownResult, ValidationError, type VideoOutputConfig, VideyScraper, type VideyScraperOptions, type VideyUploadResult, type WallpaperItem, type WallpaperResult, WallpaperScraper, type WallpaperScraperOptions, type Webp2Mp4Result, Webp2Mp4Scraper, type Webp2Mp4ScraperOptions, type Webp2Mp4Source, type WeeklyChartStyle, type WeeklyPoint, type WordPos, type WsperCredentials, WsperError, type WsperErrorOptions, type WsperErrorPayload, WsperLogger, type WsperPlatform, type WsperPlatformCredentialsConfig, type WsperResponse, type WsperResponseMeta, WsperScraper, type WsperScraperConfig, type WwCharResult, WwCharScraper, type WwCharScraperOptions, YouTubeScraper, type YouTubeScraperOptions, type YoutubeAudioExtractResult, type YoutubeAudioFormat, type YoutubeAudioFormatId, type YoutubeBasicInfo, type YoutubeChannel, type YoutubeChannelData, type YoutubeDownloadInfo, type YoutubeDownloadResult, type YoutubePlaylistData, type YoutubeSearchResult, type YoutubeStats, type YoutubeThumbnail, type YoutubeUploader, type YoutubeVideoFormat, type YoutubeVideoMetadata, type YtDlpChannel, type YtDlpOptions, type YtDlpStats, type YtDlpUploader, applyBlur, assertNonEmptyString, assertSafeHttpUrl, bratGenerator, buildLayout, buildPlatformHeaders, buildSteps, buildYtDlpSearchQuery, calcAutoFontSize, chartGenerator, clampInteger, convertImage, createErrorResponse, createSpotifyAuthUrl, createSuccessResponse, defaultWarning, demoAnalyticsData, downloadWithYtDlp, drawLayout, enrichTrackWithYtDlp, exchangeSpotifyCodeForToken, exportGif, exportImage, exportJson, exportVideo, extractSpotifyId, extractStatusCode, generateAnalyticsStatsImage, generateBrat, generateChartImage, getAnalyticsChartModels, getDefaultBrowserHeaderProfile, getDefaultUserAgent, getHtmlToJpgDownloadUrl, getRandomBrowserHeaderProfile, getRandomUserAgent, gifToMp4, gifToWebm, imageToSticker, imagesToSticker, isRetryableHttpError, makeCanvas, measureText, mp4ToGif, normalizeConfig, normalizePathfinderTrack, normalizeUrl, normalizeYtDlpDownload, normalizeYtDlpExternalSource, parseAlkitabSearchHtml, parseAndroid1Results, parseAnimeQuoteDetailHtml, parseAnimeQuoteFeedHtml, parseAptoideResults, parseBMKGEarthquakeFeed, parseBMKGForecastXml, parseBMKGNowcasting, parseBiliBiliPlayUrlResponse, parseBiliBiliSearchResponse, parseBiliBiliViewResponse, parseCapCutResolverResponse, parseCuacaSearchLocations, parseCuacaWarning, parseCuacaWeather, parseDrakorDetailHtml, parseDrakorListHtml, parseDramaboxSearchHtml, parseEzgifOutputUrl, parseEzgifUploadForm, parseFaceswapCreateResponse, parseFaceswapPollResponse, parseHokInfoHtml, parseHtmlToJpgCreateJobResponse, parseHtmlToJpgTasks, parseIkiruMangaSearchHtml, parseImgUpscalerStatusResponse, parseImgUpscalerUploadResponse, parseKomikindoDetailHtml, parseKomikindoSearchHtml, parseLyricsDetailHtml, parseLyricsSearchHtml, parseMConverterPollResponse, parseMConverterTargets, parseMConverterUploadResponse, parseMcAddonDetailHtml, parseMcAddonSearchHtml, parseMediafireHtml, parseModyoloResults, parseNpmPackage, parseOcrResultHtml, parseOcrUploadHtml, parsePhotoAiCheckResponse, parsePhotoAiUploadResponse, parsePlayStoreSearchHtml, parseResepSearchHtml, parseSafebooruSearchResponse, parseSakuraNovelChapterHtml, parseSakuraNovelDetailHtml, parseSakuraNovelSearchHtml, parseTopAnimeHtml, parseUguuUploadResponse, parseUpscalerCreateResponse, parseUpscalerResultResponse, parseUptodownResults, parseVideyUploadResponse, parseWallpaperSearchHtml, parseWwCharHtml, refreshSpotifyAccessToken, renderAnimationFrame, renderBackground, renderFrame, resolveUrl, safeFileName, searchYtDlpByTrack, sleep, toWwCharSlug, totalCharCount, totalLineCount, totalWordCount, wrapText, zenFetchSource, zenWafSession };