google-img-scrap 1.0.4 → 1.0.7

package/CHANGELOG.md

@@ -1,8 +1,18 @@
 # Changelog
 
+### 1.0.7
+- Readme update
+
+### 1.0.6
+- Fixed types
+- Added ```limit``` to limit the size of the results
+
+### 1.0.5
+- Added types (by christophe77)
+
 ### v1.0.4
 
-- New option ```urlMatch```. You know get image when an url match a string (example: "cdn")
+- New option ```urlMatch```. You now get image when an url match a string (example: "cdn")
 - New option ```filterByTitles```. Filter images by titles
 
 ### v1.0.3

package/README.md

@@ -1,6 +1,6 @@
-# Google-img-scrap v1.0.4
+# Google-img-scrap v1.0.7
 
-Scrap images from google image with lot of tools and options.
+Scrap images from google images with customs pre filled options
 
 ## Update
 
@@ -18,67 +18,93 @@ npm i google-img-scrap
 
 ## Import
 
-- NPM
-
 ```js
 const { GOOGLE_IMG_SCRAP , GOOGLE_QUERY } = require('google-img-scrap');
 ```
 
-- From GITHUB
-
-```js
-const { GOOGLE_IMG_SCRAP , GOOGLE_QUERY } = require('./src/google-img-scrap');
-```
-
-## Params
+## Query Params
 
 - "search" (String) what you want to search
 - "execute" (Function) allow you to execute a function to remove "gstatic.com" domains for example
-- "excludeWords" (Array of String) exclude some words from the search
-- "domains" (Array of String) filter by domains
-- "excludeDomains" (Array of String) exclude some domains
+- "excludeWords" (String[]) exclude some words from the search
+- "domains" (String[]) filter by domains
+- "excludeDomains" (String[]) exclude some domains
 - "safeSearch" (Boolean) active safe search or not for nsfw for example
 - "custom" (String) add extra query
-- "urlMatch" (Array of Array) get image when an url match a string (example: "cdn") | ```example below```
-- "filterByTitles" (Array of Array) filter images by titles | ```example below```
+- "urlMatch" (String[][]) get image when an url match a string (example: "cdn") | ```example below```
+- "filterByTitles" (String[][]) filter images by titles | ```example below```
 - "query" (Object) set a query (can be [TYPE, DATE, COLOR, SIZE, LICENCE, EXTENSION]) (use GOOGLE_QUERY items | ```example below```
+- "limit" (Int) to limit the size of the results
 
 ## Result
 
 ```js
-}
 {
-  url: 'https://images.google.com/search?tbm=isch&tbs=itp:clipart,qdr:y,ic:gray,isz:l,il:ol,ift:jpg&q=cats',
+  url: 'https://images.google.com/search?tbm=isch&tbs=itp:clipart,qdr:y,ic:gray,isz:l,il:ol,ift:jpg&q=cats%20%20%20-%22black%22%20-%22white%22&name=content&name2=content2',
   result: [
     {
-      url: 'https://media.istockphoto.com/vectors/black-cats-set-vector-id599123506',
-      height: '806',
+      url: 'https://media.gettyimages.com/vectors/cat-eating-fish-vector-id1216628506',
+      height: '1024',
       width: '1024'
     },
     {
-      url: 'https://media.istockphoto.com/vectors/cats-vector-id455327075',
-      height: '860',
+      url: 'https://www.ariatrade.gr/images/products/2021/10/110294_1.jpg',
+      height: '768',
       width: '1024'
     },
     {
-      url: 'https://media.istockphoto.com/vectors/purring-cats-vector-silhouette-vector-id165749810?s=2048x2048',
-      height: '1895',
+      url: 'https://media.gettyimages.com/illustrations/panther-leaping-illustration-id152406879?s=2048x2048',
+      height: '2048',
       width: '2048'
     },
-    ...
+    {
+      url: 'https://media.gettyimages.com/illustrations/botany-plants-antique-engraving-illustration-erythrina-variegata-illustration-id970781520',
+      height: '1024',
+      width: '828'
+    }
   ]
+  ...
 }
 ```
 
 ## How to use ?
 
-- For the query parameter you need to set the name in upper case !
+- **For the query parameter you need to set the name in upper case !**
+
+## Simple example
+
+Search cats images
 
 ```js
-const { GOOGLE_IMG_SCRAP , GOOGLE_QUERY } = require('google-img-scrap');
+(async function(){
+    const test = await GOOGLE_IMG_SCRAP({
+        search: "cats",
+    });
+
+    console.log(test);
+})();
+```
+
+## Removing gstatic.com
+
+```js
+(async function(){
+    const test = await GOOGLE_IMG_SCRAP({
+        search: "demon slayer background hd",
+        execute: function(element){
+            if(!element.url.match('gstatic.com')) return element;
+        }
+    });
+
+    console.log(test);
+})();
+```
+
+## Custom query
 
-console.log(GOOGLE_QUERY);
+All query options are optional (see below for all the options)
 
+```js
 (async function(){
     const test = await GOOGLE_IMG_SCRAP({
         search: "cats",
@@ -90,50 +116,91 @@ console.log(GOOGLE_QUERY);
             LICENCE: GOOGLE_QUERY.LICENCE.COMMERCIAL_AND_OTHER,
             EXTENSION: GOOGLE_QUERY.EXTENSION.JPG
         },
+    });
+
+    console.log(test);
+})();
+```
+
+## Limit result size
+
+```js
+(async function(){
+    const test = await GOOGLE_IMG_SCRAP({
+        search: "cats",
+        limit: 5,
+    });
+
+    console.log(test);
+})();
+```
+
+## Domains
+
+Only scrap from a specific domain
+
+```js
+(async function(){
+    const test = await GOOGLE_IMG_SCRAP({
+        search: "cats",
         domains: ["alamy.com", "istockphoto.com", "vecteezy.com"],
-        excludeWords: ["black", "white"], //If you don't like black and white cats
-        custom: "name=content&name2=content2",
-        safeSearch: false,
-        // excludeDomains: ["istockphoto.com", "alamy.com"]
     });
 
-    console.log(test, test.result.length);
+    console.log(test);
 })();
 ```
 
-OR ALSO
+## Exclude domains
 
 ```js
-const { GOOGLE_IMG_SCRAP , GOOGLE_QUERY } = require('google-img-scrap');
+(async function(){
+    const test = await GOOGLE_IMG_SCRAP({
+        search: "cats",
+        excludeDomains: ["istockphoto.com", "alamy.com"]
+    });
+
+    console.log(test);
+})();
+```
+
+## Exclude words
 
+If you don' like black cats and white cats
+
+```js
 (async function(){
     const test = await GOOGLE_IMG_SCRAP({
         search: "cats",
+        excludeWords: ["black", "white"], //If you don't like black cats and white cats
     });
 
     console.log(test, test.result.length);
 })();
 ```
 
-## Removing gstatic.com
+## Safe search (no nsfw)
 
 ```js
-const { GOOGLE_IMG_SCRAP , GOOGLE_QUERY } = require('google-img-scrap');
-
 (async function(){
     const test = await GOOGLE_IMG_SCRAP({
-        search: "demon slayer background hd",
-        query: {
-            SIZE: GOOGLE_QUERY.SIZE.LARGE,
-        },
-        domains: ["alphacoders.com"],
+        search: "cats",
         safeSearch: false,
-        execute: function(element){
-            if(!element.url.match('gstatic.com')) return element;
-        }
     });
 
-    console.log(test, test.result[test.result.length-1].url, test.result.length);
+    console.log(test);
+})();
+```
+
+## Custom query params
+
+```js
+(async function(){
+    const test = await GOOGLE_IMG_SCRAP({
+        search: "cats",
+        custom: "name=content&name2=content2",
+    });
+
+    console.log(test);
 })();
 ```
 
@@ -142,8 +209,6 @@ const { GOOGLE_IMG_SCRAP , GOOGLE_QUERY } = require('google-img-scrap');
 - urlMatch work like filterByTiles
 
 ```js
-const { GOOGLE_IMG_SCRAP } = require('google-img-scrap');
-
 (async function(){
     const test = await GOOGLE_IMG_SCRAP({
         search: "cats",
@@ -152,12 +217,9 @@ const { GOOGLE_IMG_SCRAP } = require('google-img-scrap');
             ["draw", "white"],
             ["albino", "white"]
         ],
-        execute: function(element){
-            if(!element.url.match('gstatic.com')) return element;
-        }
     });
 
-    console.log(test, test.result.length);
+    console.log(test);
 })();
 ```
 
@@ -212,4 +274,4 @@ const { GOOGLE_IMG_SCRAP } = require('google-img-scrap');
     COMMERCIAL_AND_OTHER 
   }
 }
-```
+```

package/package.json

@@ -1,41 +1,48 @@
-{
-  "name": "google-img-scrap",
-  "version": "1.0.4",
-  "description": "Scrap images from google images with a lot of options",
-  "main": "./src/google-img-scrap.js",
-  "directories": {
-    "test": "test"
-  },
-  "scripts": {
-    "test": "node ./test/test.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yoannchb-pro/google-img-scrap.git"
-  },
-  "keywords": [
-    "google",
-    "image",
-    "scrap",
-    "options",
-    "query",
-    "powerfull",
-    "easy",
-    "type",
-    "color",
-    "extension",
-    "filter",
-    "date",
-    "licence"
-  ],
-  "author": "yoannchb",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/yoannchb-pro/google-img-scrap/issues"
-  },
-  "homepage": "https://github.com/yoannchb-pro/google-img-scrap#readme",
-  "dependencies": {
-    "fast-html-dom-parser": "^1.0.5",
-    "got": "^11.0.0"
-  }
-}
+{
+  "name": "google-img-scrap",
+  "version": "1.0.7",
+  "description": "Scrap images from google images with customs pre filled options",
+  "main": "./src/google-img-scrap.js",
+  "types": "./types/index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "node ./test/test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yoannchb-pro/google-img-scrap.git"
+  },
+  "keywords": [
+    "google",
+    "image",
+    "scrap",
+    "options",
+    "query",
+    "powerfull",
+    "easy",
+    "type",
+    "color",
+    "extension",
+    "filter",
+    "date",
+    "licence"
+  ],
+  "author": "yoannchb",
+  "contributors": [
+    {
+      "name": "christophe77",
+      "url": "https://github.com/christophe77"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/yoannchb-pro/google-img-scrap/issues"
+  },
+  "homepage": "https://github.com/yoannchb-pro/google-img-scrap#readme",
+  "dependencies": {
+    "fast-html-dom-parser": "^1.0.5",
+    "got": "^11.0.0"
+  }
+}

package/src/google-img-scrap.js

@@ -1,150 +1,178 @@
-const got = require('got');
-const { FastHTMLParser } = require('fast-html-dom-parser');
+const got = require("got");
+const { FastHTMLParser } = require("fast-html-dom-parser");
 
-const { GOOGLE_CONSTANT } = require('./constant/GOOGLE_CONSTANT');
-const { GOOGLE_QUERY } = require('./constant/query/GOOGLE_QUERY');
+const { GOOGLE_CONSTANT } = require("./constant/GOOGLE_CONSTANT");
+const { GOOGLE_QUERY } = require("./constant/query/GOOGLE_QUERY");
 const { TRANSLATOR } = require("./constant/translator/TRANSLATOR");
-const EXTENSIONS = require('./constant/extensions/IMAGES_EXTENSIONS.json');
+const EXTENSIONS = require("./constant/extensions/IMAGES_EXTENSIONS.json");
 
-const { buildQuery, unicodeToChar } = require('./utils/UTILS');
+const { buildQuery, unicodeToChar } = require("./utils/UTILS");
 
 //verify good configuration
-function verify(config){
-    if(config.excludeDomains && config.domains) throw "Can not set 'excludeDomains' and 'domains' as same times";
+function verify(config) {
+  if (config.excludeDomains && config.domains)
+    throw "Can not set 'excludeDomains' and 'domains' as same times";
 
-    if(!config.search || config.search.trim() == "") throw "'search' can not be empty";
+  if (!config.search || config.search.trim() == "")
+    throw "'search' can not be empty";
 
-    if(config.query){
-        const queryToVerify = Object.keys(GOOGLE_QUERY);
-    
-        for(const key of Object.keys(config.query)){
-            if(!queryToVerify.includes(key)) throw `Invalide query name '${key}'`;
+  if (config.query) {
+    const queryToVerify = Object.keys(GOOGLE_QUERY);
 
-            const VALUES = Object.values(GOOGLE_QUERY[key]);
-            const ACTUAL_VALUE = config.query[key];
-            if(!VALUES.includes(ACTUAL_VALUE)) throw `'${ACTUAL_VALUE}' is not a valide argument for the query : '${key}'`;
-        };
+    for (const key of Object.keys(config.query)) {
+      if (!queryToVerify.includes(key)) throw `Invalide query name '${key}'`;
+
+      const VALUES = Object.values(GOOGLE_QUERY[key]);
+      const ACTUAL_VALUE = config.query[key];
+      if (!VALUES.includes(ACTUAL_VALUE))
+        throw `'${ACTUAL_VALUE}' is not a valide argument for the query : '${key}'`;
     }
-};
+  }
+}
 
 //verify imag extension
-function containImage(content = ""){
-    for(const EXTENSION of EXTENSIONS){
-        if(content.includes(EXTENSION)) return true;
-    }
+function containImage(content = "") {
+  for (const EXTENSION of EXTENSIONS) {
+    if (content.includes(EXTENSION)) return true;
+  }
 
-    return false;
+  return false;
 }
 
 //parse HTML
-async function parse(url){
-    const result = [];
+async function parse(url) {
+  const result = [];
 
-    const response = await got(url, {
-        headers: GOOGLE_CONSTANT.headers
-    });
-    const parser = new FastHTMLParser(response.body);
+  const response = await got(url, {
+    headers: GOOGLE_CONSTANT.headers,
+  });
+  const parser = new FastHTMLParser(response.body);
 
-    const scripts = parser.getElementsByTagName('script');
+  const scripts = parser.getElementsByTagName("script");
 
-    if(!scripts) return result;
+  if (!scripts) return result;
 
-    for(const script of scripts){
-        const body = script.innerHTML;
+  for (const script of scripts) {
+    const body = script.innerHTML;
 
-        const valide = containImage(body);
+    const valide = containImage(body);
 
-        if(valide){
-            const regex = /\["(http.+?)",(\d+),(\d+)\]/gi;
+    if (valide) {
+      const regex = /\["(http.+?)",(\d+),(\d+)\]/gi;
 
-            let res = null;
+      let res = null;
 
-            while((res = regex.exec(body)) != null){
-                if(res.length >= 4 && res[1].match(/http/gi).length < 2) result.push({
-                    url: unicodeToChar(res[1]),
-                    height: res[2],
-                    width: res[3]
-                });
-            }
-        }
+      while ((res = regex.exec(body)) != null) {
+        if (res.length >= 4 && res[1].match(/http/gi).length < 2)
+          result.push({
+            url: unicodeToChar(res[1]),
+            height: res[2],
+            width: res[3],
+          });
+      }
     }
+  }
 
-    return result;
-};
+  return result;
+}
 
 //main
-async function GOOGLE_IMG_SCRAP(config = {}){
-    //verify config
-    verify(config);
-
-    //exclude domains
-    const EXCLUDE_DOMAINS = [];
-    if(config.excludeDomains) config.excludeDomains.forEach((domain) => EXCLUDE_DOMAINS.push(`-site:"${domain}"`));
-
-    //domains
-    const DOMAINS = [];
-    if(config.domains) config.domains.forEach((domain) => DOMAINS.push(`site:"${domain}"`));
-
-    //exclude words
-    const EXCLUDE_WORDS = [];
-    if(config.excludeWords) config.excludeWords.forEach((word) => EXCLUDE_WORDS.push(`-"${word}"`));
-
-    //filter by titles
-    const FILTER_TITLE = [];
-    if(config.filterByTitles) config.filterByTitles.forEach((titleFilter) => {
-
-        const value = titleFilter.map((title) => {
-            return `intitle:"${title}"`;
-        });
-
-        FILTER_TITLE.push(`(${value.join(' AND ')})`);
-
+async function GOOGLE_IMG_SCRAP(config = {}) {
+  //verify config
+  verify(config);
+
+  //exclude domains
+  const EXCLUDE_DOMAINS = [];
+  if (config.excludeDomains)
+    config.excludeDomains.forEach((domain) =>
+      EXCLUDE_DOMAINS.push(`-site:"${domain}"`)
+    );
+
+  //domains
+  const DOMAINS = [];
+  if (config.domains)
+    config.domains.forEach((domain) => DOMAINS.push(`site:"${domain}"`));
+
+  //exclude words
+  const EXCLUDE_WORDS = [];
+  if (config.excludeWords)
+    config.excludeWords.forEach((word) => EXCLUDE_WORDS.push(`-"${word}"`));
+
+  //filter by titles
+  const FILTER_TITLE = [];
+  if (config.filterByTitles)
+    config.filterByTitles.forEach((titleFilter) => {
+      const value = titleFilter.map((title) => {
+        return `intitle:"${title}"`;
+      });
+
+      FILTER_TITLE.push(`(${value.join(" AND ")})`);
     });
 
-    //url match words
-    const URL_MATCH = [];
-    if(config.urlMatch) config.urlMatch.forEach((urlMatch) => {
-
-        const value = urlMatch.map((content) => {
-            return `inurl:${content}`;
-        });
-
-        URL_MATCH.push(`(${value.join(' AND ')})`);
-
-    });
+  //url match words
+  const URL_MATCH = [];
+  if (config.urlMatch)
+    config.urlMatch.forEach((urlMatch) => {
+      const value = urlMatch.map((content) => {
+        return `inurl:${content}`;
+      });
 
-    //building url
-    const SEARCH_TERM = config.search + 
-    " " + URL_MATCH.join(" OR ") +
-    " " + FILTER_TITLE.join(" OR ") +
-    " " + EXCLUDE_WORDS.join(" ") + 
-    " " + EXCLUDE_DOMAINS.join(" ") + 
-    " " + DOMAINS.join(" OR ");
-
-    const SEARCH = encodeURIComponent(SEARCH_TERM.trim())
-    const QUERY = Object.assign(GOOGLE_CONSTANT.forceGoogleImage, {
-        [GOOGLE_CONSTANT.queryParam]: Object.values(config.query || {}).join(','),
-        q: SEARCH,
+      URL_MATCH.push(`(${value.join(" AND ")})`);
     });
 
-    const CUSTOM_PARAM = config.custom ? `&${config.custom}` : "";
-    const SAFE_SEARCH = config.safeSearch ? `&safe=active` : "";
-
-    const URL = GOOGLE_CONSTANT.url + buildQuery(QUERY, TRANSLATOR) + CUSTOM_PARAM + SAFE_SEARCH;
-
-    //parsing
-    const result = await parse(URL);
-
-    //excute function
-    let finalResult = [];
-    if(config.execute) result.forEach((element) => {
-        const value = config.execute(element);
-        if(value) finalResult.push(value);
+  //building url
+  const SEARCH_TERM =
+    config.search +
+    " " +
+    URL_MATCH.join(" OR ") +
+    " " +
+    FILTER_TITLE.join(" OR ") +
+    " " +
+    EXCLUDE_WORDS.join(" ") +
+    " " +
+    EXCLUDE_DOMAINS.join(" ") +
+    " " +
+    DOMAINS.join(" OR ");
+
+  const SEARCH = encodeURIComponent(SEARCH_TERM.trim());
+  const QUERY = Object.assign(GOOGLE_CONSTANT.forceGoogleImage, {
+    [GOOGLE_CONSTANT.queryParam]: Object.values(config.query || {}).join(","),
+    q: SEARCH,
+  });
+
+  const CUSTOM_PARAM = config.custom ? `&${config.custom}` : "";
+  const SAFE_SEARCH = config.safeSearch ? `&safe=active` : "";
+
+  const URL =
+    GOOGLE_CONSTANT.url +
+    buildQuery(QUERY, TRANSLATOR) +
+    CUSTOM_PARAM +
+    SAFE_SEARCH;
+
+  //parsing
+  const result = await parse(URL);
+
+  //excute function
+  let finalResult = [];
+  if (config.execute)
+    result.forEach((element) => {
+      const value = config.execute(element);
+      if (value) finalResult.push(value);
     });
-    else finalResult = result;
-
-    //result
-    return {url: URL, result: finalResult};
-};
+  else finalResult = result;
+
+  //limit result
+  let slicedResult = [];
+  const { limit } = config;
+
+  if (limit && limit > 0 && finalResult.length > limit) {
+    slicedResult = finalResult.slice(0, limit);
+  }
+  //result
+  return {
+    url: URL,
+    result: slicedResult.length > 0 ? slicedResult : finalResult,
+  };
+}
 
-module.exports = { GOOGLE_IMG_SCRAP , GOOGLE_QUERY };
+module.exports = { GOOGLE_IMG_SCRAP, GOOGLE_QUERY };

package/src/utils/UTILS.js

@@ -1,11 +1,11 @@
 function buildQuery(query, translator){
-    let result = [];
+    const result = [];
 
-    let params = Object.keys(query);
-    let toTranslate = Object.keys(translator);
+    const params = Object.keys(query);
+    const toTranslate = Object.keys(translator);
 
     for(const param of params){
-        let queryName = param;
+        const queryName = param;
         if(toTranslate.includes(param)) queryName = toTranslate[param];
 
         result.push(`${queryName}=${query[param]}`);

package/test/test-result-limit.js

@@ -0,0 +1,25 @@
+const { GOOGLE_IMG_SCRAP } = require("../src/google-img-scrap");
+
+(async function () {
+  const limit = 5;
+  const testNoLimit = await GOOGLE_IMG_SCRAP({
+    search: "cats",
+    execute: function (element) {
+      if (!element.url.match("gstatic.com")) return element;
+    },
+  });
+  const testLimit = await GOOGLE_IMG_SCRAP({
+    search: "cats",
+    limit,
+    execute: function (element) {
+      if (!element.url.match("gstatic.com")) return element;
+    },
+  });
+  try {
+    console.log(
+      `limit : ${limit}, testNoLimit length : ${testNoLimit.result.length}, testLimit length : ${testLimit.result.length}`
+    );
+  } catch (error) {
+    console.log(error);
+  }
+})();

package/test/test.js

@@ -13,7 +13,6 @@ const { GOOGLE_IMG_SCRAP , GOOGLE_QUERY } = require('../src/google-img-scrap');
             LICENCE: GOOGLE_QUERY.LICENCE.COMMERCIAL_AND_OTHER,
             EXTENSION: GOOGLE_QUERY.EXTENSION.JPG
         },
-        domains: ["alamy.com", "istockphoto.com", "vecteezy.com"],
         excludeWords: ["black", "white"], //If you don't like black and white cats
         custom: "name=content&name2=content2",
         safeSearch: false,

package/types/index.d.ts

@@ -0,0 +1,96 @@
+type Config = {
+  search: string;
+  limit?:number;
+  query?: {
+    TYPE?: string;
+    DATE?: string;
+    COLOR?: string;
+    SIZE?: string;
+    LICENCE?: string;
+    EXTENSION?: string;
+  };
+  domains?: string[];
+  excludeWords?: string[];
+  custom?: string;
+  safeSearch?: boolean;
+  excludeDomains?: string[];
+  execute?: (element: FinalResult) => FinalResult | undefined;
+  filterByTitles?: [string[]];
+};
+type FinalResult = {
+  url: string;
+  height: string;
+  width: string;
+};
+type Results = {
+  url: string;
+  result: FinalResult[];
+};
+type GoogleQuery = {
+  SIZE: {
+    LARGE: string;
+    MEDIUM: string;
+    ICON: string;
+  };
+
+  COLOR: {
+    BLACK_AND_WHITE: string;
+    TRANSPARENT: string;
+    RED: string;
+    BLUE: string;
+    PURPLE: string;
+    ORANGE: string;
+    YELLOW: string;
+    GREEN: string;
+    TEAL: string;
+    PINK: string;
+    WHITE: string;
+    GRAY: string;
+    BLACK: string;
+    BROWN: string;
+  };
+
+  TYPE: {
+    CLIPART: string;
+    DRAW: string;
+    GIF: string;
+  };
+
+  EXTENSION: {
+    JPG: "jpg";
+    GIF: "gif";
+    BMP: "bmp";
+    PNG: "png";
+    SVG: "svg";
+    WEBP: "webp";
+    ICO: "ico";
+    RAW: "raw";
+  };
+
+  DATE: {
+    DAY: string;
+    WEEK: string;
+    MONTH: string;
+    YEAR: string;
+  };
+
+  LICENCE: {
+    CREATIVE_COMMONS: string;
+    COMMERCIAL_AND_OTHER: string;
+  };
+};
+
+/**
+ * GOOGLE_IMG_SCRAP
+ *
+ * @param {Config} config
+ * @returns {Results}
+ */
+export declare function GOOGLE_IMG_SCRAP(config: Config): Results;
+
+/**
+ * GOOGLE_QUERY
+ *
+ * @returns {GoogleQuery}
+ */
+export declare const GOOGLE_QUERY: GoogleQuery;