export interface WeatherNowcasting {
    success: boolean;
    data: any; // Ideally more specific if possible, but BMKG ArcGIS response can be complex
    totalFeatures: number;
    timestamp: string;
}

export interface EarthquakeInfo {
    Tanggal: string;
    Jam: string;
    DateTime: string;
    Coordinates: string;
    Lintang: string;
    Bujur: string;
    Magnitude: string;
    Kedalaman: string;
    Wilayah: string;
    Potensi: string;
    Dirasakan: string;
    Shakemap?: string;
}

export interface EarthquakeData {
    Infogempa: {
        gempa: EarthquakeInfo | EarthquakeInfo[];
    };
}

export interface EarthquakeResponse {
    success: boolean;
    data: EarthquakeData;
    timestamp: string;
    totalGempa?: number;
}

export interface ShakemapDownload {
    success: boolean;
    filename: string;
    path: string;
    size: number;
    url: string;
    timestamp: string;
}

export interface ForecastResponse {
    success: boolean;
    data: any; // XML converted to JSON or raw XML string? The original code returns axios response.data, which is XML string usually unless parsed.
    // However, looking at original code: `const response = await axios.get(url); return { ... data: response.data }`.
    // Axios usually returns string for XML unless configured otherwise or using a transformer.
    // We'll assume string for now, or maybe the user wants JSON?
    // The original code doesn't parse XML.
    provinsi: string;
    timestamp: string;
}

export interface FormattedEarthquake {
    tanggal: string;
    jam: string;
    datetime: string;
    coordinates: string;
    lintang: string;
    bujur: string;
    magnitude: string;
    kedalaman: string;
    wilayah: string;
    potensi: string;
    dirasakan: string;
    shakemap?: string;
}

export interface BratConfig {
    size?: number;
    bg?: string;
    color?: string;
    padding?: number;
    gifDelay?: number;
    gifHoldMs?: number;
    gifSize?: number;
    gifQuality?: number;
}

export interface BratStickerConfig {
    fontSize?: number;
    fontFamily?: string;
    color?: string;
    strokeColor?: string;
    strokeWidth?: number;
}

/**
 * Clean Response Types
 * Simplified response types containing only essential data fields
 */

// TikTok Clean Types
export interface CleanTikTokUser {
    uniqueId: string;
    nickname: string;
    avatar: string;
    signature?: string;
    verified: boolean;
    followers: number;
    following: number;
    likes: number;
    videos: number;
}

export interface CleanTikTokVideo {
    id: string;
    description: string;
    createdAt: string;
    duration: number;
    author: {
        uniqueId: string;
        nickname: string;
        verified: boolean;
    };
    stats: {
        likes: number;
        comments: number;
        shares: number;
        plays: number;
    };
    downloadURL: string;
    cover?: string;
}

export interface CleanTikTokMusic {
    title: string;
    author: string;
    duration: number;
    playUrl: string;
}

// Instagram Clean Types
export interface CleanInstagramUser {
    username: string;
    full_name: string;
    profile_pic_url: string;
    is_verified: boolean;
    is_private: boolean;
}

export interface CleanInstagramHashtag {
    name: string;
    media_count: number;
}

export interface CleanInstagramSearchResponse {
    users: CleanInstagramUser[];
    hashtags: CleanInstagramHashtag[];
    has_more: boolean;
}

// Twitter Clean Types (for future use)
export interface CleanTwitterUser {
    username: string;
    name: string;
    profile_image_url: string;
    verified: boolean;
    followers_count: number;
}

// Spotify Clean Types (for future use)
export interface CleanSpotifyTrack {
    name: string;
    artist: string;
    album: string;
    duration_ms: number;
    preview_url?: string;
}

export interface DrakorConfig {
    debug?: boolean;
}

export interface Genre {
    name: string;
    url: string;
}

export interface Artist {
    name: string;
    url: string;
}

export interface DramaItem {
    title: string;
    url: string;
    image: string;
    type: string; // Movie or TV
    duration?: string;
    quality?: string;
    rating?: string;
    releaseDate?: string;
    slug: string;
}

export interface Episode {
    title: string;
    url: string | undefined;
    episode: string;
    date: string;
}

export interface DramaDetail {
    title: string; // English title
    koreanTitle?: string;
    image: string | undefined;
    synopsis: string;
    rating: string;
    type: string;
    status: string;
    episodeCount?: string;
    season?: string;
    firstAirDate?: string;
    country?: string;
    director?: string;
    videoLength?: string;
    views?: string;
    postedOn?: string;
    genres: Genre[];
    artists: Artist[];
    episodes: Episode[];
}

export interface Pagination {
    currentPage: number;
    hasNext: boolean;
    hasPrev: boolean;
}

export interface DramaList {
    dramas: DramaItem[];
    pagination: Pagination;
}

export interface FaceswapConfig {
    timeout?: number;
    userAgent?: string;
}

export interface FaceswapResult {
    job_id: string;
    image: string;
}

declare module 'gif-encoder-2';

// ===== Tag Types (ported from Pascal BooruScraper.Interfaces) =====
export enum BooruTagType {
    General = 'general',
    Copyright = 'copyright',
    Character = 'character',
    Artist = 'artist',
    Metadata = 'metadata',
    Species = 'species',  // e621 specific
}

export interface BooruTag {
    value: string;
    kind: BooruTagType;
    count?: number;
}

export interface BooruComment {
    id: number;
    postId?: number;
    creatorId?: number;
    username?: string;
    timestamp?: string;
    text: string;
    score?: number;
    isDeleted?: boolean;
}

// ===== Unified BooruPost (ported from Pascal IBooruPost) =====
export interface BooruPost {
    id: number;
    thumbnail?: string;       // Preview image URL
    contentUrl?: string;      // Full-size image/video URL (file_url)
    sampleUrl?: string;       // Sample/large size URL
    score?: number;
    uploader?: string;
    uploaderId?: number;
    tags?: string[];          // Simple tag strings
    tagDetails?: BooruTag[];  // Rich tag objects with type + count
    comments?: BooruComment[];
    rating?: string;          // s=safe, q=questionable, e=explicit
    md5?: string;
    width?: number;
    height?: number;
    sampleWidth?: number;
    sampleHeight?: number;
    previewWidth?: number;
    previewHeight?: number;
    fileSize?: number;
    fileExt?: string;
    sourceUrl?: string;
    createdAt?: string;
    parentId?: number | null;
    hasChildren?: boolean;
    hasComments?: boolean;
    hasNotes?: boolean;
    favCount?: number;
    [key: string]: any;
}

// ===== Booru Search Options =====
export interface BooruSearchOptions {
    tags: string;
    page?: number;
    limit?: number;
    safe?: boolean;
}

// ===== Booru Search Result =====
export interface BooruSearchResult {
    site: string;
    posts: BooruPost[];
    total?: number;
    page: number;
    limit: number;
}

// ===== Supported sites enum =====
export type BooruSiteName =
    | 'gelbooru'
    | 'rule34xxx'
    | 'danbooru'
    | 'safebooru'
    | 'konachan'
    | 'yandere'
    | 'e621'
    | 'realbooru'
    | 'xbooru'
    | 'tbib'
    | 'rule34us'
    | 'lolibooru'
    | 'zerochan';

// ===== Legacy types (backward compat) =====
export interface ImageScraperConfig {
    debug?: boolean;
    timeout?: number;
    headers?: Record<string, string>;
    httpsAgent?: any;
}

export interface BooruResult {
    result: any;
    random: BooruPost;
    posts: BooruPost[];
}

export interface KonachanPost extends BooruPost {
    author?: string;
    jpeg_url?: string;
    jpeg_width?: number;
    jpeg_height?: number;
    jpeg_file_size?: number;
    actual_preview_width?: number;
    actual_preview_height?: number;
}

export interface ImgUpscalerConfig {
    pollInterval?: number;
    maxRetries?: number;
    timeout?: number;
    userAgent?: string;
}

export interface ImgUpscalerResult {
    originalPath: string;
    outputPath: string;
    resultUrl: string;
    scale: number;
}

/**
 * Instagram data type definitions
 */

export interface InstagramDimensions {
  height: number;
  width: number;
}

export interface InstagramDisplayResource {
  src: string;
  config_width: number;
  config_height: number;
}

export interface InstagramOwner {
  id: string;
  username: string;
  full_name?: string;
  profile_pic_url?: string;
  is_verified?: boolean;
}

export interface InstagramLocation {
  id: string;
  name: string;
  slug?: string;
  address_json?: string;
}

export interface InstagramClipsMusicInfo {
  artist_name?: string;
  song_name?: string;
  uses_original_audio?: boolean;
  should_mute_audio?: boolean;
  audio_id?: string;
}

export interface InstagramSidecarEdge {
  node: {
    __typename: string;
    id: string;
    shortcode: string;
    dimensions: InstagramDimensions;
    display_url: string;
    display_resources: InstagramDisplayResource[];
    is_video: boolean;
    video_url?: string;
    has_audio?: boolean;
  };
}

export interface InstagramPostData {
  __typename?: string;
  shortcode?: string;
  dimensions?: InstagramDimensions;
  display_url?: string;
  display_resources?: InstagramDisplayResource[];
  has_audio?: boolean;
  video_url?: string;
  video_view_count?: number;
  video_play_count?: number;
  is_video?: boolean;
  caption?: string;
  is_paid_partnership?: boolean;
  location?: InstagramLocation;
  owner?: InstagramOwner;
  product_type?: string;
  video_duration?: number;
  thumbnail_src?: string;
  clips_music_attribution_info?: InstagramClipsMusicInfo;
  sidecar?: InstagramSidecarEdge[];
}

export interface InstagramRawMedia {
  __typename?: string;
  shortcode?: string;
  dimensions?: InstagramDimensions;
  display_url?: string;
  display_resources?: InstagramDisplayResource[];
  has_audio?: boolean;
  video_url?: string;
  video_view_count?: number;
  video_play_count?: number;
  is_video?: boolean;
  edge_media_to_caption?: {
    edges: Array<{
      node: {
        text: string;
      };
    }>;
  };
  is_paid_partnership?: boolean;
  location?: InstagramLocation;
  owner?: InstagramOwner;
  product_type?: string;
  video_duration?: number;
  thumbnail_src?: string;
  clips_music_attribution_info?: InstagramClipsMusicInfo;
  edge_sidecar_to_children?: {
    edges: InstagramSidecarEdge[];
  };
}

export interface InstagramGraphQLResponse {
  data: {
    xdt_shortcode_media: InstagramRawMedia;
  };
}

// Search result types
export interface InstagramSearchUser {
  pk?: string;
  username?: string;
  full_name?: string;
  is_private?: boolean;
  is_verified?: boolean;
  profile_pic_url?: string;
  profile_pic_id?: string;
  follower_count?: number;
  latest_reel_media?: number;
}

export interface InstagramSearchHashtag {
  id?: string;
  name?: string;
  media_count?: number;
  profile_pic_url?: string;
  search_result_subtitle?: string;
}

export interface InstagramSearchPlace {
  location?: {
    pk?: string;
    name?: string;
    address?: string;
    city?: string;
    short_name?: string;
    lng?: number;
    lat?: number;
    external_source?: string;
    facebook_places_id?: string;
  };
  title?: string;
  subtitle?: string;
}

export interface InstagramTopSearchResponse {
  users?: Array<{
    position?: number;
    user?: InstagramSearchUser;
  }>;
  places?: Array<{
    position?: number;
    place?: InstagramSearchPlace;
  }>;
  hashtags?: Array<{
    position?: number;
    hashtag?: InstagramSearchHashtag;
  }>;
  has_more?: boolean;
  rank_token?: string;
  clear_client_cache?: boolean;
  status?: string;
  [key: string]: any;
}

export type PostType = 'p' | 'reels' | 'reel' | 'stories';

export interface ScraperConfig {
  userAgent?: string;
  xIgAppId?: string;
  xFbLsd?: string;
  xAsbdId?: string;
  timeout?: number;
  /** Cookie string for authenticated requests (required for search) */
  cookie?: string;
  /** CSRF token extracted from cookie (required for search) */
  csrfToken?: string;
  /** Use automatic token generator for search (alternative to manual cookie) */
  useTokenGenerator?: boolean;
}

// Alias untuk konsistensi
export type InstagramConfig = ScraperConfig;

export interface Liputan6News {
    title: string;
    link: string;
    image: string;
    tag: string;
    source: string;
}

export interface MediafireConfig {
    timeout?: number;
    userAgent?: string;
}

export interface MediafireResult {
    downloadUrl: string;
    fileName: string;
    fileSize: string;
    fileType: string;
}

export interface MalSeasonAnime {
    id: string | null;
    title: string;
    image: string | undefined;
    type: string;
    episodes: string;
    source: string;
    genres: string[];
    synopsis: string;
    score: string;
    members: string;
}

export interface MalSearchResult {
    type: string;
    id: string | null;
    title: string;
    image: string | undefined;
    synopsis: string;
    type_detail: string;
    episodes: string;
    score: string;
}

export interface MalAnimeStaff {
    name: string;
    url: string;
    role: string;
    image: string;
}

export interface MalAnimeCharacter {
    name: string;
    url: string;
    image: string;
    role: string;
    voice_actor: {
        name: string;
        url: string;
        language: string;
        image: string;
    }[];
}

export interface MalAnimeDetail {
    title: string;
    image: string | undefined;
    synopsis: string;
    synonim: {
        synonym?: string;
        japanese?: string;
        english?: string;
        [key: string]: string | undefined;
    };
    type: string;
    episodes: string;
    status: string;
    aired: string;
    premiered: string;
    broadcast: string;
    producers: { name: string; url: string }[];
    licensors: { name: string; url: string }[];
    studios: { name: string; url: string }[];
    source: string;
    genres: { name: string; url: string }[];
    themes: { name: string; url: string }[];
    demographic: string;
    duration: string;
    rating: string;
    score: string;
    scoreCount: string;
    ranked: string;
    popularity: string;
    members: string;
    favorites: string;
    characters: MalAnimeCharacter[];
    staff: MalAnimeStaff[];
}

export interface MalCharacterDetail {
    id: string | null;
    name: string;
    nameKanji: string | null;
    image: string | undefined;
    description: string;
    nicknames: string[];
    animeography: {
        id: string | null;
        title: string;
        role: string;
        image: string | undefined;
    }[];
    mangaography: string[]; // Not scraped in current implementation but kept for structure
    voiceActors: {
        id: string | null;
        name: string;
        language: string;
        image: string | undefined;
    }[];
    memberFavorites: string | null;
}

export interface MalVoiceActorDetail {
    id: string | null;
    name: string;
    nameKanji: string | null;
    image: string | undefined;
    givenName: string | null;
    familyName: string | null;
    birthday: string | null;
    website: string | null;
    memberFavorites: string | null;
    more: string | null;
    voiceActingRoles: {
        animeId: string | null;
        animeTitle: string;
        characterId: string | null;
        characterName: string;
        role: string;
        image: string | undefined;
    }[];
    animeStaffPositions: string[]; // Not scraped in current implementation but kept for structure
}

export interface MalNewsArticle {
    id: string | null;
    title: string;
    image: string | undefined;
    text: string;
    author: string;
    date: string;
    comments: string;
    tags: string[];
}

export interface MalRecommendation {
    user: string;
    date: string;
    animes: {
        id: string | null;
        title: string | undefined;
        image: string | undefined;
    }[];
    description: string;
}

export interface MalPopularAnime {
    rank: string;
    id: string | null;
    title: string;
    image: string | undefined;
    type: string | null;
    episodes: string | null;
    aired: string | null;
    members: string;
    score: string;
}

export interface Holiday {
    summary: string;
    days: string;
    dateMonth: string;
}

export interface NationalHolidayResult {
    nextLibur: string;
    libnas_content: Holiday[];
}

export interface MyInstantsResult {
    title: string;
    soundLink: string;
    pageLink: string;
}

export interface WallpaperResult {
    type: string;
    source: string;
    image: string[];
}

export interface TranscriptionResult {
    author: string;
    transcribe: string;
}

/**
 * Pinterest data type definitions
 */

export interface PinterestPin {
  id: string;
  title?: string;
  description?: string;
  link?: string;
  image_url?: string;
  image_large_url?: string;
  image_medium_url?: string;
  image_small_url?: string;
  video_url?: string;
  is_video?: boolean;
  board?: {
    id: string;
    name: string;
    url?: string;
  };
  created_at?: string;
  pinner?: {
    username?: string;
    full_name?: string;
    profile_url?: string;
    image_url?: string;
  };
  domain?: string;
  media_type?: string;
  alt_text?: string;
  product_type?: string;
}

export interface PinterestSearchResponse {
  resource_response?: {
    status?: string;
    code?: number;
    message?: string;
    endpoint_name?: string;
    data?: {
      results?: any[];
      bookmark?: string;
    };
  };
  client_context?: any;
  resource?: any;
}

export interface PinterestImageVariant {
  url: string;
  width: number;
  height: number;
}

export interface PinterestMedia {
  images?: {
    orig?: PinterestImageVariant;
    '170x'?: PinterestImageVariant;
    '236x'?: PinterestImageVariant;
    '474x'?: PinterestImageVariant;
    '736x'?: PinterestImageVariant;
    '1200x'?: PinterestImageVariant;
    [key: string]: PinterestImageVariant | undefined;
  };
  videos?: {
    video_list?: {
      [key: string]: {
        url: string;
        width: number;
        height: number;
        duration?: number;
      };
    };
  };
  type?: string;
  has_video?: boolean;
}

export interface PinterestSearchOptions {
  scope?: 'pins' | 'boards' | 'users';
  bookmark?: string;
  page_size?: number;
}

export interface PinterestConfig {
  userAgent?: string;
  timeout?: number;
  cookie?: string;
  csrfToken?: string;
}

export interface PinterestDownloadOptions {
  quality?: 'orig' | '1200x' | '736x' | '474x' | '236x' | '170x';
  videoQuality?: 'V_720P' | 'V_HLSV4' | 'V_HLSV3_WEB';
}

/**
 * RemoveBg data type definitions
 */

export interface RemoveBgConfig {
  timeout?: number;
  userAgent?: string;
}

export interface RemoveBgResult {
  success: boolean;
  url?: string;
  output?: string;  // Alias untuk url untuk konsistensi dengan upscaler
  message?: string;
  error?: string;
}

export interface RemoveBgUploadResponse {
  server_filename: string;
  [key: string]: any;
}

export interface RemoveBgTokens {
  token: string;
  task: string;
}

export interface UguuUploadResponse {
  success: boolean;
  files: Array<{
    hash: string;
    name: string;
    url: string;
    size: number;
  }>;
}

// Alias untuk konsistensi penamaan
export type RemovebgConfig = RemoveBgConfig;
export type RemovebgResult = RemoveBgResult;

/**
 * Common response wrapper types
 */

export interface SuccessResponse<T> {
  success: true;
  data: T;
}

export interface ErrorResponse {
  success: false;
  error: string;
}

export type ApiResponse<T> = SuccessResponse<T> | ErrorResponse;

/**
 * Spotify Scraper Types
 */

export interface SpotifyConfig {
    clientId?: string;
    clientSecret?: string;
    timeout?: number;
    userAgent?: string;
}

export interface SpotifyArtist {
    id: string;
    name: string;
    uri: string;
    external_urls?: {
        spotify: string;
    };
}

export interface SpotifyImage {
    url: string;
    height: number;
    width: number;
}

export interface SpotifyAlbumSimple {
    id: string;
    name: string;
    uri: string;
    album_type: string;
    release_date: string;
    total_tracks: number;
    images: SpotifyImage[];
    artists: Array<{
        id: string;
        name: string;
    }>;
    external_urls?: {
        spotify: string;
    };
}

export interface SpotifyTrack {
    id: string;
    uri: string;
    name: string;
    duration: number;
    explicit: boolean;
    popularity: number;
    preview_url: string | null;
    track_number: number;
    disc_number: number;
    is_playable: boolean;
    audiodownload?: string | null;
    artists: SpotifyArtist[];
    album: SpotifyAlbumSimple | null;
    external_urls?: {
        spotify: string;
    };
    external_ids?: {
        isrc?: string;
    };
}

export interface SpotifyAlbum {
    id: string;
    uri: string;
    name: string;
    album_type: string;
    total_tracks: number;
    release_date: string;
    label: string;
    popularity: number;
    genres: string[];
    images: SpotifyImage[];
    copyrights: Array<{
        text: string;
        type: string;
    }>;
    artists: SpotifyArtist[];
    tracks: SpotifyTrack[];
    external_urls?: {
        spotify: string;
    };
}

export interface SpotifyPlaylist {
    id: string;
    name: string;
    description: string;
    owner: {
        id: string;
        display_name: string;
    };
    public: boolean;
    collaborative: boolean;
    followers: number;
    total_tracks: number;
    images: SpotifyImage[];
    tracks: Array<{
        added_at: string;
        track: {
            id: string;
            name: string;
            duration: number;
            audio: string | null;
            audiodownload?: string | null;
            artists: Array<{
                id: string;
                name: string;
            }>;
            album: {
                id: string;
                name: string;
                images: SpotifyImage[];
            } | null;
        };
    }>;
    external_urls?: {
        spotify: string;
    };
}

export interface SpotifySearchResults {
    tracks: SpotifyTrack[];
    albums: SpotifyAlbumSimple[];
    artists: Array<{
        id: string;
        uri: string;
        name: string;
        popularity: number;
        followers: number;
        genres: string[];
        images: SpotifyImage[];
        external_urls?: {
            spotify: string;
        };
    }>;
    playlists: Array<{
        id: string;
        uri: string;
        name: string;
        description: string;
        owner: string;
        total_tracks: number;
        images: SpotifyImage[];
        public: boolean;
        external_urls?: {
            spotify: string;
        };
    }>;
}

export interface SpotifyDownloadResult {
    success: boolean;
    track?: SpotifyTrack;
    audioBuffer?: Buffer;
    message?: string;
    source?: 'spotify' | 'youtube';  // Indicates where audio was downloaded from
    youtubeUrl?: string;              // YouTube URL if YouTube was used
}

export interface SpotifyAlbumDownloadResult {
    success: boolean;
    type: 'album';
    metadata: {
        title: string;
        artists: string;
        cover: string;
        releaseDate: string;
    };
    trackList: Array<{
        success: boolean;
        metadata: SpotifyTrack;
        audioBuffer?: Buffer;
        error?: string;
    }>;
}

export interface SpotifyPlaylistDownloadResult {
    success: boolean;
    type: 'playlist';
    metadata: {
        title: string;
        artists: string;
        cover: string;
    };
    trackList: Array<{
        success: boolean;
        metadata: any;
        audioBuffer?: Buffer;
        error?: string;
    }>;
}

// Twitter Types
export interface TwitterTweet {
    author: {
        username: string;
        nickname: string;
        profile_pic: string;
        upload_at: string;
    };
    title: string;
    media: string;
    retweet: string;
    likes: string;
}

export interface TwitterProfile {
    username: string;
    nickname: string;
    background: string;
    profile: string;
    desc_text: string;
    join_at: string;
    map: string;
    tweets_count: string;
    followers: string;
    following: string;
    media_count: number;
    media: TwitterTweet[] | string;
}

export interface TwitterDownloadMedia {
    quality: string;
    type: string;
    url: string;
}

export interface TwitterDownload {
    username?: string;
    caption?: string;
    thumbnail?: string;
    likes?: string;
    media: TwitterDownloadMedia[];
    source: 'ssstwitter' | 'twmate' | 'twitter';
}

// NPM Types
export interface NpmCollaborator {
    name: string;
    url: string;
}

export interface NpmInfoItem {
    type: string;
    result: string;
}

export 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[];
}

// YouTube Types
export interface YoutubeImage {
    url: string;
    sizes: string;
}

export interface YoutubeProfileImage {
    image: string | undefined;
    images: YoutubeImage[];
}

export interface YoutubeBannerImage {
    image: string | undefined;
    images: YoutubeImage[];
}

export interface YoutubeChannel {
    status: number;
    name: string;
    channel_url: string | undefined;
    id: string;
    profile: string | undefined;
    creation_date: string;
    video_count: string;
    subscriber_count: string;
    total_views: string;
    country: string;
    monetization: string | undefined;
    description: string;
    profile_image: YoutubeProfileImage;
    banner_image: YoutubeBannerImage;
}

// Game Types
export interface FreeFireProfile {
    status: number;
    id: string;
    nickname: string;
}

export interface MobileLegendsProfile {
    status: number;
    id: string;
    zoneId: string;
    nickname: string;
    // The structure depends on what duniagames API returns, assuming similar to FF or minimal info
    // Looking at original code: return response.data.gameDetail;
    // We should probably type `gameDetail` as any or specific if known.
    // Let's use `any` for gameDetail properties for now as it's external API response without clear schema in original code.
    [key: string]: any;
}

/**
 * TikTok Scraper Types
 * Converted from scraper-x JavaScript interfaces to TypeScript
 */

export interface TikTokConfig {
    cookiesPath?: string;
    timeout?: number;
    userAgent?: string;
    /** @deprecated No longer used - tikwm API is used instead */
    usePuppeteer?: boolean;
    /** Return cleaned responses with only essential fields (default: true) */
    cleanResponse?: boolean;
}

export interface TikTokAuthor {
    id: string;
    uniqueId: string;
    nickname: string;
    avatarThumb?: string;
    avatarMedium?: string;
    avatarLarger?: string;
    signature?: string;
    verified?: boolean;
    secUid?: string;
    privateAccount?: boolean;
}

export interface TikTokVideo {
    id: string;
    description: string;
    createdAt: string;
    height: number;
    width: number;
    duration: number;
    resolution: string;
    shareCount: number;
    likesCount: number;
    commentCount: number;
    playCount: number;
    downloadURL: string;
    cover?: string;
    dynamicCover?: string;
    playURL?: string;
    format?: string;
    author?: TikTokAuthor;
    directVideoUrl?: string;
}

export interface TikTokUser {
    id: string;
    uniqueId: string;
    nickname: string;
    avatar: string;
    signature: string;
    createdAt: string;
    verified: boolean;
    secretUID: string;
    bioLink: string;
    privateAccount: boolean;
    followers: number;
    following: number;
    likes: number;
    videos: number;
}

export interface TikTokMusic {
    id: string;
    title: string;
    playUrl: string;
    coverLarge: string;
    coverThumb: string;
    authorName: string;
    duration: number;
    original: boolean;
    album: string;
}

export interface TikTokDownloadOptions {
    path?: string;
    watermark?: boolean;
}

export interface TikTokDownloadResult {
    success: boolean;
    videoPath?: string;
    videoInfo?: TikTokVideo;
    videoBuffer?: Buffer;
    message?: string;
    error?: string;
}

export interface TikTokNoWatermarkResult {
    success: boolean;
    downloadUrl?: string;
    error?: string;
}

export interface TikTokSearchResult {
    videos: TikTokVideo[];
    hasMore: boolean;
    cursor?: string;
}

export interface UnwatermarkConfig {
    timeout?: number;
    userAgent?: string;
}

export interface UnwatermarkResult {
    job_id: string;
    input_url: string;
    output_url: string;
}

export interface UpscalerResult {
  success: boolean;
  id?: string;
  input?: string;
  output?: string;
  error?: string;
}

export interface UpscalerConfig {
  timeout?: number;
  pollInterval?: number;
  maxPoll?: number;
  userAgent?: string;
}

/**
 * YouTube Scraper Types
 */

export interface YouTubeConfig {
    timeout?: number;
    userAgent?: string;
    quality?: 'highest' | 'lowest' | 'highestaudio' | 'lowestaudio';
}

export interface YouTubeVideoFormat {
    itag: number;
    url: string;
    mimeType: string;
    bitrate: number;
    width?: number;
    height?: number;
    quality: string;
    qualityLabel?: string;
    fps?: number;
    hasVideo: boolean;
    hasAudio: boolean;
    container: string;
    codecs: string;
    audioQuality?: string;
    approxDurationMs?: string;
    audioBitrate?: number;
}

export interface YouTubeVideoInfo {
    videoId: string;
    title: string;
    description: string;
    lengthSeconds: string;
    channelId: string;
    channelName: string;
    thumbnail: string;
    thumbnails: Array<{
        url: string;
        width: number;
        height: number;
    }>;
    viewCount: string;
    publishDate: string;
    uploadDate: string;
    formats: YouTubeVideoFormat[];
    category: string;
    keywords?: string[];
    isLiveContent: boolean;
    averageRating?: number;
}

export interface YouTubeDownloadOptions {
    quality?: 'highest' | 'lowest' | 'highestaudio' | 'lowestaudio';
    filter?: 'audioandvideo' | 'videoonly' | 'audioonly';
    format?: string;
}

export interface YouTubeSearchResult {
    id: string;
    title: string;
    description: string;
    thumbnail: string;
    channelName: string;
    channelId: string;
    duration: string;
    viewCount: string;
    publishedTime: string;
    url: string;
}

export interface YouTubePlaylistInfo {
    id: string;
    title: string;
    description: string;
    channelName: string;
    channelId: string;
    thumbnail: string;
    videoCount: number;
    videos: Array<{
        id: string;
        title: string;
        thumbnail: string;
        duration: string;
        url: string;
    }>;
}

export interface YouTubeDownloadResult {
    success: boolean;
    videoInfo?: YouTubeVideoInfo;
    audioBuffer?: Buffer;
    videoPath?: string;
    error?: string;
}