Initial import from local backup (Documents-Playground/pakerpale)

node_modules/pinterest-node-api/.jshintignore

@@ -0,0 +1,3 @@
+node_modules
+examples/javascript
+test/

node_modules/pinterest-node-api/.jshintrc

@@ -0,0 +1,63 @@
+{
+  "globals": {
+    "console": false,
+    "process": false,
+    "require": true,
+    "exports": true,
+    "module": true,
+    "Buffer": true,
+    "JSON": true,
+    "async": true,
+    /* MOCHA */
+    "describe": false,
+    "it": false,
+    "before": false,
+    "beforeEach": false,
+    "after": false,
+    "afterEach": false,
+    "use strict": true
+  },
+  "maxparams": 6,
+  "maxdepth": 15,
+  "browser": true,
+  "boss": false,
+  "curly": true,
+  "debug": false,
+  "devel": false,
+  "eqeqeq": true,
+  "evil": true,
+  "forin": true,
+  "immed": true,
+  "laxbreak": false,
+  "newcap": true,
+  "noarg": true,
+  "node": false,
+  "noempty": true,
+  "nonew": true,
+  "nomen": false,
+  "onevar": true,
+  "plusplus": false,
+  "undef": true,
+  "sub": true,
+  "strict": true,
+  "white": true,
+  "esnext": true,
+  "bitwise": true,
+  "camelcase": false,
+  "quotmark": true,
+  "trailing": true,
+  "smarttabs": true,
+  "indent": 2,
+  "latedef": "nofunc",
+  "unused": true,
+  "enforceall": true,
+  "-W024": true,
+  "-W089": false,
+  "-W079": false,
+  "-W040": false,
+  "-W055": false,
+  "globalstrict": true,
+  "singleGroups": false,
+  "freeze": false,
+  "asi": false
+}

node_modules/pinterest-node-api/.travis.yml

@@ -0,0 +1,9 @@
+language: node_js
+node_js:
+  - "4"
+  - "5"
+  - "6"
+  - "7"
+  - "8"
+  - "9"
+sudo: false

node_modules/pinterest-node-api/CHANGELOG.md

@@ -0,0 +1,8 @@
+0.0.3 January 01, 2019
+  - Added support for typescript with examples
+
+0.0.2 December 31, 2018
+  - Initial release with Pins and Sections API
+
+0.0.1 December 31, 2018
+  - Initial release with User and Boards API

node_modules/pinterest-node-api/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2018 Vijay Patoliya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/pinterest-node-api/README.md

@@ -0,0 +1,433 @@
+# pinterest-node-api (Pinterest Node Rest API)
+[![Build Status](https://travis-ci.org/vijaypatoliya/pinterest-node-api.svg?branch=master)](https://travis-ci.org/vijaypatoliya/pinterest-node-api) [![Stackoverflow Thread](https://img.shields.io/badge/stackoverflow-pinterest--node--api-yellowgreen.svg)](https://stackoverflow.com/search?q=nodejs-pinterest-node-api)
+
+This API supported Pinterest standard REST API that accepts/returns JSON requests. Here is the [API reference] (https://developers.pinterest.com/docs/api/overview/)
+
+You can find [examples of JavaScript And TypeScript](https://github.com/vijaypatoliya/pinterest-node-api/tree/master/examples). This will help you for faster implementation of Pinterest APIs.
+
+##### It does supports EcmaScript 5, EcmaScript 6,  EcmaScript 8, TypeScript, async-await, Promises, Callback!!!
+##### It does also supports for AWS Lambda like serverless cloud function call.
+##### It supports pure JSON response.
+##### All methods support Promise and Callback both.
+
+## Get started
+Using the Pinterest API wrapper for Node.js is really simple.
+Given that you already have a Node.js project with NPM setup just follow these steps:
+
+**Install the dependency**
+```
+npm install --save pinterest-node-api
+```
+
+## Get Access Token From Using Below Link and Overview Details
+  [https://developers.pinterest.com/docs/api/overview/](https://developers.pinterest.com/docs/api/overview/)
+
+## Configuration Using JavaScript
+
+```bash
+export PINTEREST_USER_TOKEN=ACCESS_TOKEN
+```
+
+```js
+var pinterest = require('pinterest-node-api')('YOUR_ACCESS_TOKEN');
+```
+
+## Configuration Using TypeScript
+```js
+import * as PinterestAPI from 'pinterest-node-api';
+const pinterest = new PinterestAPI();
+pinterest.setUserToken('YOUR_ACCESS_TOKEN');
+```
+
+## Test Cases
+```bash
+npm run test.mocha
+```
+
+## Debugging
+```bash
+export DEBUG=pinterest:*
+```
+
+```
+Originally by [Vijay Patoliya](https://github.com/vijaypatoliya) (osi.vijay@gmail.com).
+```
+
+## Examples
+
+#### Users
+    Get own information
+    /* Return the logged in user's information */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.users.getUserOwnInfo(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get boards list
+    /* Return the logged in user's Boards */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.users.getUserBoards(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get board suggestions list
+    /* Return Board suggestions for the logged in user */
+
+    pinterest.setUserToken(userToken);
+    var data = {
+      pin: '806144402026290934'
+    };
+    try {
+        var response = pinterest.users.getUserBoardSuggestions(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get user's pins
+    /* Return the logged in user's Pins */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.users.getUserPins(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Search user's boards
+    /* Search the logged in user's Boards */
+
+    pinterest.setUserToken(userToken);
+    var data = {
+      query: 'board 1',
+      fields: 'counts,id,name,url'
+    };
+    try {
+        var response = pinterest.users.searchUserBoards(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Search user's pins
+    /* Search the logged in user's Pins */
+
+    pinterest.setUserToken(userToken);
+    var data = {
+      query: 'test',
+      fields: 'id,board,link,note,url'
+    };
+    try {
+        var response = pinterest.users.searchUserPins(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Follow a Board
+    /* Follow a Board */
+
+    pinterest.setUserToken(userToken);
+    var data = {
+      board: '4teebeat/bodybuilding-t-shirts'
+    };
+    try {
+        var response = pinterest.users.followBoard(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Follow a user
+    /* Follow a user */
+
+    pinterest.setUserToken(userToken);
+    var data = {
+      user: '4teebeat'
+    };
+    try {
+        var response = pinterest.users.followUser(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get user's followers
+    /* Return the users that follow the logged in user */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.users.getUserFollowers(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get user's following boards
+    /* Get the Boards that the logged in user follows */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.users.getUserFollowingBoards(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get user's following interested topics
+    /* Return the Interests the logged in user follows */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.users.getUserFollowingInterests(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get user's following users list
+    /* Return the users that the logged in user follows */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.users.getUserFollowingUsers(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Unfollow a board
+    /* Unfollow a Board */
+
+    pinterest.setUserToken(userToken);
+    var board = '4teebeat/bodybuilding-t-shirts'
+    try {
+        var response = pinterest.users.unfollowBoard(board);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Unfollow a user
+    /* Unfollow a User */
+
+    pinterest.setUserToken(userToken);
+    var user = '4teebeat'
+    try {
+        var response = pinterest.users.unfollowUser(user);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get user's information
+    /* Return a user's information */
+
+    pinterest.setUserToken(userToken);
+    var user = '4teebeat'
+    try {
+        var response = pinterest.users.getUserInfo(user);
+    } catch (error) {
+        return;
+    }
+
+  #### Boards
+    Create a Board
+    /* Create a Board */
+    
+    pinterest.setUserToken(userToken);
+    var data = {
+      name: 'test board',
+      description: 'it\'s a test board'
+    };
+    try {
+        var response = pinterest.boards.createBoard(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get board's information
+    /* Retrieve information about a Board */
+
+    pinterest.setUserToken(userToken);
+    var board = 'pideveloper/test-board';
+    try {
+        var response = pinterest.boards.getBoard(board);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get board's pins list
+    /* Retrieve the Pins on a Board */
+
+    pinterest.setUserToken(userToken);
+    var board = 'pideveloper/test-board';
+    try {
+        var response = pinterest.boards.getBoardPins(board);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get boards list
+    /* Return the logged in user's Boards */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.boards.getUserBoards(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Edit a board
+    /* Edit a Board */
+
+    pinterest.setUserToken(userToken);
+    var data = {
+      name: 'Board 11',
+      description: 'it\'s a board no 11.'
+    };
+    var board = 'pideveloper/test-board';
+    try {
+        var response = pinterest.boards.updateBoard(board, data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Edit a board
+    /* Edit a Board */
+
+    pinterest.setUserToken(userToken);
+    var board = 'pideveloper/board-11';
+    try {
+        var response = pinterest.boards.deleteBoard(board);
+    } catch (error) {
+        return;
+    }
+
+  #### Pins
+    Create a Pin
+    /* Create a Pin */
+
+    pinterest.setUserToken(userToken);
+    var data = {
+      board: 'pideveloper/board-2',
+      note: 'it\'s a test pin desc.',
+      image_url: 'https://localhost:8080/aerospace-engineering.jpg'
+    };
+    try {
+        var response = pinterest.pins.createPin(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get pin information
+    /* Return information about a Pin */
+
+    pinterest.setUserToken(userToken);
+    var pin = '806144402027821208';
+    try {
+        var response = pinterest.pins.getPin(pin);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get board's pins list
+    /* Retrieve the Pins on a Board */
+
+    pinterest.setUserToken(userToken);
+    var board = 'pideveloper/test-board';
+    try {
+        var response = pinterest.pins.getBoardPins(board);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get user's pins
+    /* Return the logged in user's Pins */
+
+    pinterest.setUserToken(userToken);
+    var data = {};
+    try {
+        var response = pinterest.pins.getUserPins(data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Edit a Pin
+    /* Edit a Pin's information */
+
+    pinterest.setUserToken(userToken);
+    var pin = '806144402027821208';
+    var data = {
+      board: 'pideveloper/board-2',
+      note: 'it\'s a aerospace test pin.',
+      link: 'https://aerospace.org/'
+    };
+    try {
+        var response = pinterest.pins.updatePin(pin, data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Delete a Pin
+    /* Delete a Pin */
+
+    pinterest.setUserToken(userToken);
+    var pin = '806144402027821208';
+    try {
+        var response = pinterest.pins.deletePin(pin);
+    } catch (error) {
+        return;
+    }
+
+  #### Sections
+    Create a section of board
+    /* Creates a new board section */
+
+    pinterest.setUserToken(userToken);
+    var board = '806144470738408510';
+    var data = {
+      title: 'test section',
+      // initial_pins: '806144402026288820'
+    };
+    try {
+        var response = pinterest.sections.createBoardSection(board, data);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get board's sections list
+    /* Gets sections for a board */
+
+    pinterest.setUserToken(userToken);
+    var board = '806144470738408510';
+    try {
+        var response = pinterest.sections.getBoardSections(board);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Get pins of board section
+    /* Gets the pins for a board section */
+
+    pinterest.setUserToken(userToken);
+    var section = 'pideveloper/board-2/lighting';
+    try {
+        var response = pinterest.sections.getBoardSectionPins(section);
+    } catch (error) {
+        return;
+    }
+    -------------------------------------------------------------------------------------
+    Delete a board section
+    /* Deletes a board section */
+
+    pinterest.setUserToken(userToken);
+    var section = '5007816082331826124';
+    try {
+        var response = pinterest.sections.deleteBoardSection(section);
+    } catch (error) {
+        return;
+    }

node_modules/pinterest-node-api/examples/javascript/boards/createBoard.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var boardsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * name
+   * description
+   * 
+   * (optional)
+   * fields (counts, created_at, creator, description, id, image, name, privacy, reason, url)
+   */
+  var data = {
+    name: 'test board',
+    description: 'it\'s a test board'
+  };
+  try {
+    var response = await pinterest.boards.createBoard(data);
+  } catch (error) {
+    return;
+  }
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/javascript/boards/deleteBoard.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var boardsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (The board name in the format: <username>/<board_name>)
+   */
+  var board = 'pideveloper/board-11';
+  try {
+    var response = await pinterest.boards.deleteBoard(board);
+  } catch (error) {
+    return;
+  }
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/javascript/boards/getBoard.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var boardsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (The board name in the format: <username>/<board_name>)
+   * 
+   * (optional)
+   * fields (counts, created_at, creator, description, id, image, name, privacy, reason, url)
+   */
+  var board = 'pideveloper/test-board';
+  try {
+    var response = await pinterest.boards.getBoard(board);
+  } catch (error) {
+    return;
+  }
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/javascript/boards/getBoardPins.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var boardsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (The board name in the format: <username>/<board_name>)
+   * 
+   * (optional)
+   * fields (attribution, board, color, counts, created_at, creator, id, image, link, media, metadata, note, original_link, url)
+   */
+  var board = 'pideveloper/test-board';
+  try {
+    var response = await pinterest.boards.getBoardPins(board);
+  } catch (error) {
+    return;
+  }
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/javascript/boards/getUserBoards.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var boardsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (counts, created_at, creator, description, id, image, name, privacy, reason, url)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.boards.getUserBoards(data);
+  } catch (error) {
+    return;
+  }
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/javascript/boards/updateBoard.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var boardsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (The board name in the format: <username>/<board_name>)
+   * name
+   * description
+   * 
+   * (optional)
+   * fields (counts, created_at, creator, description, id, image, name, privacy, reason, url)
+   */
+  var data = {
+    name: 'Board 11',
+    description: 'it\'s a board no 11.'
+  };
+  var board = 'pideveloper/test-board';
+  try {
+    var response = await pinterest.boards.updateBoard(board, data);
+  } catch (error) {
+    return;
+  }
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/javascript/pins/createPin.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var pinsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (required) (The board name in the format: <username>/<board_name>)
+   * note (required)
+   * link
+   * 
+   * (one of the following three options)
+   * image (Upload the image)
+   * image_url (The link of the image)
+   * image_base64 (The link of a Base64 encoded image)
+   * 
+   * (optional)
+   * fields (attribution, board, color, counts, created_at, creator, id, image, link, media, metadata, note, original_link, url)
+   */
+  var data = {
+    board: 'pideveloper/board-2',
+    note: 'it\'s a test pin desc.',
+    image_url: 'https://www.birmingham.ac.uk/Images/College-EPS-only/outreach/engineering/aerospace-engineering.jpg'
+  };
+  try {
+    var response = await pinterest.pins.createPin(data);
+  } catch (error) {
+    return;
+  }
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/javascript/pins/deletePin.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var pinsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * pin (pin ID)
+   */
+  var pin = '806144402027821208';
+  try {
+    var response = await pinterest.pins.deletePin(pin);
+  } catch (error) {
+    return;
+  }
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/javascript/pins/getBoardPins.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var pinsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (The board name in the format: <username>/<board_name>)
+   * 
+   * (optional)
+   * fields (attribution, board, color, counts, created_at, creator, id, image, link, media, metadata, note, original_link, url)
+   */
+  var board = 'pideveloper/test-board';
+  try {
+    var response = await pinterest.pins.getBoardPins(board);
+  } catch (error) {
+    return;
+  }
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/javascript/pins/getPin.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var pinsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * pin (pin ID)
+   * 
+   * (optional)
+   * fields (attribution, board, color, counts, created_at, creator, id, image, link, media, metadata, note, original_link, url)
+   */
+  var pin = '806144402027821208';
+  try {
+    var response = await pinterest.pins.getPin(pin);
+  } catch (error) {
+    return;
+  }
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/javascript/pins/getUserPins.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var pinsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (attribution, board, color, counts, created_at, creator, id, image, link, media, metadata, note, original_link, url)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.pins.getUserPins(data);
+  } catch (error) {
+    return;
+  }
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/javascript/pins/updatePin.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var pinsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * pin (pin ID)
+   * 
+   * board (The board name in the format: <username>/<board_name>)
+   * note
+   * link
+   * 
+   * (optional)
+   * fields (attribution, board, color, counts, created_at, creator, id, image, link, media, metadata, note, original_link, url)
+   */
+  var pin = '806144402027821208';
+  var data = {
+    board: 'pideveloper/board-2',
+    note: 'it\'s a aerospace test pin.',
+    link: 'https://aerospace.org/'
+  };
+  try {
+    var response = await pinterest.pins.updatePin(pin, data);
+  } catch (error) {
+    return;
+  }
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/javascript/sections/createBoardSection.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var sectionsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (required) (The board ID)
+   * title (required) (section name)
+   * initial_pins (pin ID)
+   */
+  var board = '806144470738408510';
+  var data = {
+    title: 'test section',
+    // initial_pins: '806144402026288820'
+  };
+  try {
+    var response = await pinterest.sections.createBoardSection(board, data);
+  } catch (error) {
+    return;
+  }
+};
+
+sectionsRequest();

node_modules/pinterest-node-api/examples/javascript/sections/deleteBoardSection.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var sectionsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * section (required) (The section ID)
+   */
+  var section = '5007816082331826124';
+  try {
+    var response = await pinterest.sections.deleteBoardSection(section);
+  } catch (error) {
+    return;
+  }
+};
+
+sectionsRequest();

node_modules/pinterest-node-api/examples/javascript/sections/getBoardSectionPins.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var sectionsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * section (required) (The section name in the format: <username>/<board_name>/<section_name>)
+   */
+  var section = 'pideveloper/board-2/lighting';
+  try {
+    var response = await pinterest.sections.getBoardSectionPins(section);
+  } catch (error) {
+    return;
+  }
+};
+
+sectionsRequest();

node_modules/pinterest-node-api/examples/javascript/sections/getBoardSections.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var sectionsRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (required) (The board ID)
+   */
+  var board = '806144470738408510';
+  try {
+    var response = await pinterest.sections.getBoardSections(board);
+  } catch (error) {
+    return;
+  }
+};
+
+sectionsRequest();

node_modules/pinterest-node-api/examples/javascript/users/followBoard.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (The board name in the format: <username>/<board_name>)
+   */
+  var data = {
+    board: '4teebeat/bodybuilding-t-shirts'
+  };
+  try {
+    var response = await pinterest.users.followBoard(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/followUser.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * user
+   */
+  var data = {
+    user: '4teebeat'
+  };
+  try {
+    var response = await pinterest.users.followUser(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserBoardSuggestions.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * pin (pass pin_id)
+   * 
+   * (optional)
+   * count
+   * 
+   * fields (counts, created_at, creator, description, id, image, name, privacy, reason, url)
+   */
+  var data = {
+    pin: '806144402026290934'
+  };
+  try {
+    var response = await pinterest.users.getUserBoardSuggestions(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserBoards.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (counts, created_at, creator, description, id, image, name, privacy, reason, url)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.users.getUserBoards(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserFollowers.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (account_type, bio, counts, created_at, first_name, id, image, last_name, url, username)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.users.getUserFollowers(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserFollowingBoards.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (counts, created_at, creator, description, id, image, name, privacy, reason, url)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.users.getUserFollowingBoards(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserFollowingInterests.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (id, name)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.users.getUserFollowingInterests(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserFollowingUsers.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (account_type, bio, counts, created_at, first_name, id, image, last_name, url, username)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.users.getUserFollowingUsers(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserInfo.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * user
+   */
+  var user = '4teebeat'
+  try {
+    var response = await pinterest.users.getUserInfo(user);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserOwnInfo.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (account_type, bio, counts, created_at, first_name, id, image, last_name, url, username)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.users.getUserOwnInfo(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/getUserPins.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * (optional)
+   * fields (attribution, board, color, counts, created_at, creator, id, image, link, media, metadata, note, original_link, url)
+   */
+  var data = {};
+  try {
+    var response = await pinterest.users.getUserPins(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/searchUserBoards.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * query (board names)
+   * 
+   * (optional)
+   * fields (counts, created_at, creator, description, id, image, name, privacy, reason, url)
+   */
+  var data = {
+    query: 'board 1',
+    fields: 'counts,id,name,url'
+  };
+  try {
+    var response = await pinterest.users.searchUserBoards(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/searchUserPins.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * query (Pin descriptions)
+   * 
+   * (optional)
+   * fields (attribution, board, color, counts, created_at, creator, id, image, link, media, metadata, note, original_link, url)
+   */
+  var data = {
+    query: 'test',
+    fields: 'id,board,link,note,url'
+  };
+  try {
+    var response = await pinterest.users.searchUserPins(data);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/unfollowBoard.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * board (The board name in the format: <username>/<board_name>)
+   */
+  var board = '4teebeat/bodybuilding-t-shirts'
+  try {
+    var response = await pinterest.users.unfollowBoard(board);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/javascript/users/unfollowUser.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var userToken = process.env.PINTEREST_USER_TOKEN;
+
+var pinterest = require('../../../lib')(userToken);
+
+var usersRequest = async function () {
+  /**
+   * passing parameters 
+   * -------------------
+   * 
+   * user (The username or user ID )
+   */
+  var user = '4teebeat'
+  try {
+    var response = await pinterest.users.unfollowUser(user);
+  } catch (error) {
+    return;
+  }
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/boards/createBoard.ts

@@ -0,0 +1,23 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const boardsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {
+    name: 'test board',
+    description: 'it\'s a test board'
+  };
+  const response = await pinterest.boards.createBoard(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/typescript/boards/deleteBoard.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const boardsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const board = 'pideveloper/board-11';
+  const response = await pinterest.boards.deleteBoard(board).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/typescript/boards/getBoard.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const boardsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const board = 'pideveloper/test-board';
+  const response = await pinterest.boards.getBoard(board).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/typescript/boards/getBoardPins.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const boardsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const board = 'pideveloper/test-board';
+  const response = await pinterest.boards.getBoardPins(board).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/typescript/boards/getUserBoards.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const boardsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.boards.getUserBoards(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/typescript/boards/updateBoard.ts

@@ -0,0 +1,24 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const boardsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {
+    name: 'Board 11',
+    description: 'it\'s a board no 11.'
+  };
+  const board = 'pideveloper/test-board';
+  const response = await pinterest.boards.updateBoard(board, data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+boardsRequest();

node_modules/pinterest-node-api/examples/typescript/pins/createPin.ts

@@ -0,0 +1,24 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const pinsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {
+    board: 'pideveloper/board-2',
+    note: 'it\'s a test pin desc.',
+    image_url: 'https://www.birmingham.ac.uk/Images/College-EPS-only/outreach/engineering/aerospace-engineering.jpg'
+  };
+  const response = await pinterest.pins.createPin(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/typescript/pins/deletePin.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const pinsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const pin = '806144402027821208';
+  const response = await pinterest.pins.deletePin(pin).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/typescript/pins/getBoardPins.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const pinsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const board = 'pideveloper/test-board';
+  const response = await pinterest.pins.getBoardPins(board).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/typescript/pins/getPin.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const pinsRequest = async function () {
+  pinterest.setUserToken(userToken);
+  
+  const pin = '806144402027821208';
+  const response = await pinterest.pins.getPin(pin).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/typescript/pins/getUserPins.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const pinsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.pins.getUserPins(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/typescript/pins/updatePin.ts

@@ -0,0 +1,25 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const pinsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const pin = '806144402027821208';
+  const data = {
+    board: 'pideveloper/board-2',
+    note: 'it\'s a aerospace test pin.',
+    link: 'https://aerospace.org/'
+  };
+  const response = await pinterest.pins.updatePin(pin, data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+pinsRequest();

node_modules/pinterest-node-api/examples/typescript/sections/createBoardSection.ts

@@ -0,0 +1,24 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const sectionsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const board = '806144470738408510';
+  const data = {
+    title: 'test section',
+    // initial_pins: '806144402026288820'
+  };
+  const response = await pinterest.sections.createBoardSection(board, data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+sectionsRequest();

node_modules/pinterest-node-api/examples/typescript/sections/deleteBoardSection.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const sectionsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const section = '5007816082331826124';
+  const response = await pinterest.sections.deleteBoardSection(section).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+sectionsRequest();

node_modules/pinterest-node-api/examples/typescript/sections/getBoardSectionPins.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const sectionsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const section = 'pideveloper/board-2/lighting';
+  const response = await pinterest.sections.getBoardSectionPins(section).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+sectionsRequest();

node_modules/pinterest-node-api/examples/typescript/sections/getBoardSections.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const sectionsRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const board = '806144470738408510';
+  const response = await pinterest.sections.getBoardSections(board).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+sectionsRequest();

node_modules/pinterest-node-api/examples/typescript/users/followBoard.ts

@@ -0,0 +1,22 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {
+    board: '4teebeat/bodybuilding-t-shirts'
+  };
+  const response = await pinterest.users.followBoard(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/followUser.ts

@@ -0,0 +1,22 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {
+    user: '4teebeat'
+  };
+  const response = await pinterest.users.followUser(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserBoardSuggestions.ts

@@ -0,0 +1,22 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {
+    pin: '806144402026290934'
+  };
+  const response = await pinterest.users.getUserBoardSuggestions(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserBoards.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.users.getUserBoards(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserFollowers.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.users.getUserFollowers(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserFollowingBoards.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.users.getUserFollowingBoards(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserFollowingInterests.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.users.getUserFollowingInterests(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserFollowingUsers.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.users.getUserFollowingUsers(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserInfo.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const user = '4teebeat'
+  const response = await pinterest.users.getUserInfo(user).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserOwnInfo.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.users.getUserOwnInfo(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/getUserPins.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {};
+  const response = await pinterest.users.getUserPins(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/searchUserBoards.ts

@@ -0,0 +1,23 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {
+    query: 'board 1',
+    fields: 'counts,id,name,url'
+  };
+  const response = await pinterest.users.searchUserBoards(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/searchUserPins.ts

@@ -0,0 +1,23 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const data = {
+    query: 'test',
+    fields: 'id,board,link,note,url'
+  };
+  const response = await pinterest.users.searchUserPins(data).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/unfollowBoard.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const board = '4teebeat/bodybuilding-t-shirts'
+  const response = await pinterest.users.unfollowBoard(board).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/examples/typescript/users/unfollowUser.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+const userToken = process.env.PINTEREST_USER_TOKEN;
+
+import * as PinterestAPI from 'pinterest-node-api';
+
+const pinterest = new PinterestAPI();
+
+const usersRequest = async function () {
+  pinterest.setUserToken(userToken);
+
+  const user = '4teebeat'
+  const response = await pinterest.users.unfollowUser(user).catch(error => {
+    if (error) {
+      return;
+    }
+  });
+};
+
+usersRequest();

node_modules/pinterest-node-api/index.d.ts

@@ -0,0 +1,77 @@
+// Type definitions for pinterest-node-api
+
+declare class BaseClient {
+
+}
+
+declare class Users extends BaseClient {
+
+  getUserOwnInfo(params: any): Promise<any>;
+  getUserBoards(params: any): Promise<any>;
+  getUserBoardSuggestions(params: any): Promise<any>;
+  getUserPins(params: any): Promise<any>;
+  searchUserBoards(params: any): Promise<any>;
+  searchUserPins(params: any): Promise<any>;
+  followBoard(params: any): Promise<any>;
+  followUser(params: any): Promise<any>;
+  getUserFollowers(params: any): Promise<any>;
+  getUserFollowingBoards(params: any): Promise<any>;
+  getUserFollowingInterests(params: any): Promise<any>;
+  getUserFollowingUsers(params: any): Promise<any>;
+  unfollowBoard(board: string): Promise<any>;
+  unfollowUser(user: string): Promise<any>;
+  getUserInfo(user: string): Promise<any>;
+
+}
+
+declare class Boards extends BaseClient {
+
+  createBoard(params: any): Promise<any>;
+  getBoard(board: string): Promise<any>;
+  getBoardPins(board: string): Promise<any>;
+  getUserBoards(params: any): Promise<any>;
+  updateBoard(board: string, params: any): Promise<any>;
+  deleteBoard(board: string): Promise<any>;
+
+}
+
+declare class Pins extends BaseClient {
+
+  createPin(params: any): Promise<any>;
+  getPin(pin: string): Promise<any>;
+  getBoardPins(board: string): Promise<any>;
+  getUserPins(params: any): Promise<any>;
+  updatePin(pin: string, params: any): Promise<any>;
+  deletePin(pin: string): Promise<any>;
+
+}
+
+declare class Sections extends BaseClient {
+
+  createBoardSection(board: string, params: any): Promise<any>;
+  getBoardSections(board: string): Promise<any>;
+  getBoardSectionPins(section: string): Promise<any>;
+  deleteBoardSection(section: string): Promise<any>;
+
+}
+
+declare class pinterestNodeClient {
+
+  constructor()
+
+  constructor(accessToken: string);
+
+  setHost(host?: string, port?: string, protocol?: string): void;
+
+  setUserToken(userToken: string): void;
+
+  users: Users;
+  boards: Boards;
+  pins: Pins;
+  sections: Sections;
+}
+
+declare namespace pinterestNodeClient {
+
+}
+export = pinterestNodeClient;

node_modules/pinterest-node-api/lib/Error.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var debug = require('debug')('pinterest:Error');
+var utils = require('./utils');
+
+module.exports = _Error;
+
+/**
+ * Generic Error Class to wrap any errors returned by pinterest-node-api
+ */
+function _Error() {
+  this.populate.apply(this, arguments);
+  var stack = (new Error(this.message)).stack;
+  debug('stack ', stack);
+}
+
+// Extend Native Error
+_Error.prototype = Object.create(Error.prototype);
+
+_Error.prototype.type = 'GenericError';
+_Error.prototype.populate = function (type, message) {
+  this.Type = type;
+  this.Message = message;
+};
+
+_Error.extend = utils.protoExtend;
+
+/**
+ * Create subclass of internal Error class
+ * (Specifically for errors returned from pinterest's REST API)
+ */
+var pinterestError = _Error.pinterestError = _Error.extend({
+  Type: 'pinterestError',
+  Message: '',
+  populate: function (raw) {
+    this.Type = this.type || 'unknown';
+    this.Code = raw.Code || 'GenericError';
+    this.Message = raw.message || raw.error || 'unknown';
+    this.StatusCode = raw.StatusCode || 'unknown';
+  }
+});
+
+/**
+ * Helper factory which takes raw pinterest errors and outputs wrapping instances
+ */
+pinterestError.generate = function () {
+  return new _Error('Generic', 'Unknown Error');
+};
+
+// Specific pinterest Error types:
+_Error.pinterestInvalidRequestError = pinterestError.extend({ type: 'pinterestInvalidRequestError' });
+_Error.pinterestAPIError = pinterestError.extend({ type: 'pinterestAPIError' });
+_Error.pinterestPermissionError = pinterestError.extend({ type: 'pinterestPermissionError' });
+_Error.pinterestRateLimitError = pinterestError.extend({ type: 'pinterestRateLimitError' });
+_Error.pinterestConnectionError = pinterestError.extend({ type: 'pinterestConnectionError' });

node_modules/pinterest-node-api/lib/FormDataGenerator.js

@@ -0,0 +1,43 @@
+'use strict';
+
+// Method for formatting HTTP body for the multipart/form-data specification
+// Mostly taken from Fermata.js
+function formDataDataGenerator(method, data, headers) {
+  var segno = (Math.round(Math.random() * 1e16) + Math.round(Math.random() * 1e16)).toString();
+  headers['Content-Type'] = ('multipart/form-data; boundary=' + segno);
+  var buffer = new Buffer(0);
+
+  function push(l) {
+    var prevBuffer = buffer;
+    var newBuffer = (l instanceof Buffer) ? l : new Buffer(l);
+    buffer = new Buffer(prevBuffer.length + newBuffer.length + 2);
+    prevBuffer.copy(buffer);
+    newBuffer.copy(buffer, prevBuffer.length);
+    buffer.write('\r\n', buffer.length - 2);
+  }
+
+  function q(s) {
+    return '"' + s.replace(/"|"/g, '%22').replace(/\r\n|\r|\n/g, ' ') + '"';
+  }
+
+  for (var k in data) {
+    var v = data[k];
+    push('--' + segno);
+    if (v.hasOwnProperty('data')) {
+      push('Content-Disposition: form-data; name=' + q(k) + '; filename=' + q(v.name || 'blob'));
+      push('Content-Type: ' + (v.type || 'application/octet-stream'));
+      push('');
+      push(v.data);
+    } else {
+      push('Content-Disposition: form-data; name=' + q(k));
+      push('');
+      push(v);
+    }
+  }
+
+  push('--' + segno + '--');
+
+  return buffer;
+}
+
+module.exports = formDataDataGenerator;

node_modules/pinterest-node-api/lib/PinterestHttpClient.js

@@ -0,0 +1,172 @@
+'use strict';
+
+// var debug = require('debug')('pinterest:PinterestHttpClient');
+var Promise = require('bluebird');
+var utils = require('./utils');
+var OPTIONAL_REGEX = /^optional!/;
+var _ = require('lodash');
+
+/**
+ * Create an API method from the declared spec.
+ *
+ * @param [spec.method='GET'] Request Method (POST, GET, DELETE, PUT)
+ * @param [spec.path=''] Path to be appended to the API BASE_PATH, joined with
+ *  the instance's path (e.g. 'users' or 'boards')
+ * @param [spec.required=[]] Array of required arguments in the order that they
+ *  must be passed by the consumer of the API. Subsequent optional arguments are
+ *  optionally passed through a hash (Object) as the penultimate argument
+ *  (preceding the also-optional callback argument
+ * @param [spec.encode] Function for mutating input parameters to a method.
+ *  Usefully for applying transforms to data on a per-method basis.
+ */
+
+module.exports = {
+
+  pinterestMethod: function (spec) {
+    var commandPath = typeof spec.path === 'function' ? spec.path
+      : utils.makeURLInterpolator(spec.path || '');
+    var requestMethod = (spec.method || 'GET').toUpperCase();
+    var urlParams = spec.urlParams || [];
+    var encode = spec.encode || function (data) {
+      return data;
+    };
+    return function () {
+      var self = this;
+      var args = [].slice.call(arguments);
+      var callback = typeof args[args.length - 1] === 'function' && args.pop();
+      var urlData = this.createUrlData();
+
+      return this.wrapTimeout(new Promise((function (resolve, reject) {
+        for (var i = 0, l = urlParams.length; i < l; ++i) {
+          // Note that we shift the args array after every iteration so this just
+          // grabs the "next" argument for use as a URL parameter.
+          var arg = args[0];
+
+          var param = urlParams[i];
+
+          var isOptional = OPTIONAL_REGEX.test(param);
+          param = param.replace(OPTIONAL_REGEX, '');
+
+          if (!arg) {
+            if (isOptional) {
+              urlData[param] = '';
+              continue;
+            }
+
+            return reject(new Error(
+              'pinterest: Argument "' + urlParams[i] + '" required, but got: ' + arg +
+              ' (on API request to ' + requestMethod + ' ' + commandPath + ')'
+            ));
+          }
+
+          urlData[param] = args.shift();
+        }
+
+        var data = encode(utils.getDataFromArgs(args));
+        var opts = utils.getOptionsFromArgs(args);
+
+        if (args.length) {
+          var err = new Error('pinterest: Unknown arguments (' + args + ').');
+          return reject(err);
+        }
+
+
+        var requestPath = this.createFullPath(commandPath, urlData);
+
+        function requestCallback(err, response) {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(
+              spec.transformResponseData ?
+                spec.transformResponseData(response) :
+                response
+            );
+          }
+        }
+
+        var options = { headers: Object.assign(opts.headers, spec.headers) };
+        options.useBody = spec.useBody || false;
+        options.authorization = spec.authorization || '';
+        options.contentType = spec.contentType || '';
+        self._request(requestMethod, requestPath, data, opts.auth, options, requestCallback);
+      }).bind(this)), callback);
+    };
+  },
+
+  setMetadata: function (id, key, value, auth, cb) {
+    var self = this;
+    var data = key;
+    var isObject = _.isPlainObject(key);
+    // We assume null for an empty object
+    var isNull = data === null || (isObject && !Object.keys(data).length);
+
+    // Allow optional passing of auth & cb:
+    if ((isNull || isObject) && typeof value === 'string') {
+      auth = value;
+    } else if (typeof auth !== 'string') {
+      if (!cb && typeof auth === 'function') {
+        cb = auth;
+      }
+      auth = null;
+    }
+
+    var urlData = this.createUrlData();
+    var path = this.createFullPath('/' + id, urlData);
+
+    return this.wrapTimeout(new Promise((function (resolve, reject) {
+      if (isNull) {
+        // Reset metadata:
+        sendMetadata(null, auth);
+      } else if (!isObject) {
+        // Set individual metadata property:
+        var metadata = {};
+        metadata[key] = value;
+        sendMetadata(metadata, auth);
+      } else {
+        // Set entire metadata object after resetting it:
+        this._request('POST', path, {
+          metadata: null
+        }, auth, {}, function (err) {
+          if (err) {
+            return reject(err);
+          }
+          sendMetadata(data, auth);
+        });
+      }
+
+      function sendMetadata(metadata, auth) {
+        self._request('POST', path, {
+          metadata: metadata
+        }, auth, {}, function (err, response) {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(response.metadata);
+          }
+        });
+      }
+    }).bind(this)), cb);
+  },
+
+  getMetadata: function (id, auth, cb) {
+    if (!cb && typeof auth === 'function') {
+      cb = auth;
+      auth = null;
+    }
+
+    var urlData = this.createUrlData();
+    var path = this.createFullPath('/' + id, urlData);
+
+    return this.wrapTimeout(new Promise((function (resolve, reject) {
+      this._request('GET', path, {}, auth, {}, function (err, response) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(response.metadata);
+        }
+      });
+    }).bind(this)), cb);
+  }
+
+};

node_modules/pinterest-node-api/lib/Resource.js

@@ -0,0 +1,358 @@
+'use strict';
+
+var debug = require('debug')('pinterest:Resource');
+var http = require('http');
+var https = require('https');
+var path = require('path');
+var xml2js = require('xml2js');
+var qs = require('qs');
+var iconv = require('iconv-lite');
+
+var utils = require('./utils');
+var Error = require('./Error');
+
+var hasOwn = {}.hasOwnProperty;
+
+var RESPONSE_CONTENT_TYPE = ['text/xml', 'text/xml;charset=utf-8', 'application/xml'];
+// Provide extension mechanism for pinterest Resource Sub-Classes
+pinterestResource.extend = utils.protoExtend;
+
+// Expose method-creator & prepared (basic) methods
+pinterestResource.methods = require('./PinterestHttpClient');
+
+/**
+ * Encapsulates request logic for a pinterest Resource
+ */
+function pinterestResource(pinterest, urlData) {
+  this._pinterest = pinterest;
+  this._urlData = urlData || {};
+
+  this.basePath = utils.makeURLInterpolator(pinterest.getApiField('basePath'));
+  this.path = utils.makeURLInterpolator(this.path);
+
+  if (this.includeBasic) {
+    this.includeBasic.forEach(function (methodName) {
+      this[methodName] = pinterestResource.methods[methodName];
+    }, this);
+  }
+
+  this.initialize.apply(this, arguments);
+}
+
+pinterestResource.prototype = {
+
+  path: '',
+  requestBody: {},
+  requestParamsJSON: {},
+  initialize: function () {
+  },
+
+  // Function to override the default data processor. This allows full control
+  // over how a pinterestResource's request data will get converted into an HTTP
+  // body. This is useful for non-standard HTTP requests. The function should
+  // take method name, data, and headers as arguments.
+  requestDataProcessor: null,
+
+  // String that overrides the base API endpoint. If `overrideHost` is not null
+  // then all requests for a particular resource will be sent to a base API
+  // endpoint as defined by `overrideHost`.
+  overrideHost: null,
+
+  createFullPath: function (commandPath, urlData) {
+    return path.join(
+      this.basePath(urlData),
+      this.path(urlData),
+      typeof commandPath === 'function' ?
+        commandPath(urlData) : commandPath
+    ).replace(/\\/g, '/'); // ugly workaround for Windows
+  },
+
+  createUrlData: function () {
+    var urlData = {};
+    // Merge in baseData
+    for (var i in this._urlData) {
+      if (hasOwn.call(this._urlData, i)) {
+        urlData[i] = this._urlData[i];
+      }
+    }
+    return urlData;
+  },
+
+  wrapTimeout: function (promise, callback) {
+    if (callback) {
+      // Ensure callback is called outside of promise stack.
+      return promise.then(function (res) {
+        setTimeout(function () {
+          callback(null, res);
+        }, 0);
+      }, function (err) {
+        setTimeout(function () {
+          callback(err, null);
+        }, 0);
+      });
+    }
+
+    return promise;
+  },
+
+  _timeoutHandler: function (timeout, req, callback) {
+    var self = this;
+    return function () {
+      var timeoutErr = new Error('ETIMEDOUT');
+      timeoutErr.code = 'ETIMEDOUT';
+
+      req._isAborted = true;
+      req.abort();
+
+      callback.call(self, new Error.pinterestConnectionError({
+        message: 'Request aborted due to timeout being reached (' + timeout + 'ms)'
+      }), null);
+    };
+  },
+
+  _responseHandler: function (requestParamsJSONCopy, req, userOptions, callback) {
+    var self = this;
+
+    function processResponseType(res, responseString, callback) {
+      //debug('res %o ', res);
+      //debug('res.headers %o ', res.headers);
+      if (RESPONSE_CONTENT_TYPE.indexOf(res.headers['content-type'].toLowerCase()) > -1) {
+        debug('It is XML Response');
+        var parser = new xml2js.Parser({
+          explicitArray: false,
+          ignoreAttrs: true
+        });
+
+        parser.parseString(responseString, function (err, response) {
+          //debug('response after parsing JSON %o ', response);
+          return callback(null, response);
+        });
+      } else {
+        debug('It is NON-XML Response');
+        try {
+          var response = JSON.parse(responseString);
+          return callback(null, response);
+        } catch (exception) {
+          debug('exception ', exception);
+          return callback(callback, responseString);
+        }
+
+      }
+    }
+
+    return function (res) {
+      debug('----------- Received Response -------------');
+      var dbgResponseBuffer = [];
+      var headers = res.headers;
+      var statusCode = res.statusCode;
+      // debug('res ', res);
+      try {
+        statusCode = parseInt(statusCode, 10);
+      } catch (Exception) {
+        debug('Failed to parse statusCode as statusCode not provided in the response. ', statusCode);
+      }
+      var charset = '';
+      var content_type = '';
+      var responseString = '';
+      if (headers['content-type']) {
+        content_type = headers['content-type'].toLowerCase();
+      }
+
+      if (content_type && content_type.indexOf('charset') > -1 && content_type.split(';')[0] && content_type.split(';')[1]) {
+        if (content_type.split(';')[1] && content_type.split(';')[1].trim().match(/^((\b[^\s=]+)=(([^=]|\\=)+))*$/)[3]) {
+          charset = content_type.split(';')[1].trim().match(/^((\b[^\s=]+)=(([^=]|\\=)+))*$/)[3];
+        }
+        content_type = content_type.split(';')[0].toLowerCase();
+      }
+
+      var ResponseHeaders = headers;
+      res.on('data', function (chunk) {
+        dbgResponseBuffer.push(chunk);
+      });
+      res.on('end', function () {
+        var bufferString = Buffer.concat(dbgResponseBuffer);
+        /**
+         * You can use Either userRaw or userCharset.
+         * Both of them will not work together.
+         */
+        if (userOptions.userRaw === true) {
+          var response = {
+            data: bufferString,
+            Headers: ResponseHeaders
+          };
+          return callback.call(self, null, response);
+        }
+
+        if (userOptions.userCharset && userOptions.userCharset.length > 0) {
+          debug('Inside user Charset option');
+          charset = userOptions.userCharset;
+          try {
+            var win1251String = iconv.decode(bufferString, 'win1251');
+            responseString = iconv.encode(win1251String, charset);
+          } catch (Exception) {
+            debug('Exception iconv ', Exception);
+            return callback.call(self, new Error.pinterestAPIError({
+              message: 'Failed to parse response received from the pinterest API',
+              StatusCode: statusCode || 'unknown'
+            }), null);
+          }
+        } else {
+          responseString = bufferString.toString('utf8');
+        }
+
+        debug('responseString ', responseString);
+        debug('content_type ', content_type);
+        debug('statusCode ', statusCode);
+        debug('x-ratelimit-remaining ', ResponseHeaders['x-ratelimit-remaining']);
+
+        try {
+          if (!responseString && statusCode < 400) {
+            Object.defineProperty({}, 'lastResponse', {
+              enumerable: false,
+              writable: false,
+              value: res
+            });
+            return callback.call(self, null, {});
+          }
+          processResponseType(res, responseString, function (error, response) {
+            if (response.errors) {
+              debug('It is ErrorResponse');
+              var errorResponse = response.errors;
+              errorResponse.Headers = ResponseHeaders;
+              errorResponse.StatusCode = statusCode || 'unknown';
+              return callback.call(self, errorResponse, null);
+            } else if (response.error) {
+              debug('It is ErrorResponse have a single error');
+              var errorDetail = response;
+              errorDetail.Headers = ResponseHeaders;
+              errorDetail.StatusCode = statusCode || 'unknown';
+              return callback.call(self, errorDetail, null);
+            } else if (error) {
+              return callback.call(self, new Error.pinterestAPIError({
+                message: 'Failed to parse response received from the pinterest API',
+                StatusCode: statusCode || 'unknown'
+              }), null);
+            }
+            debug('-----------------------------------------------------------------');
+            // debug('final response %o ', response);
+            // Expose res object
+            Object.defineProperty(response, 'lastResponse', {
+              enumerable: false,
+              writable: false,
+              value: res
+            });
+            return callback.call(self, null, response);
+          });
+        } catch (exception) {
+          return callback.call(self, new Error.pinterestAPIError({
+            message: 'Invalid response received from the pinterest API',
+            StatusCode: statusCode || 'unknown'
+          }), null);
+        }
+      });
+    };
+  },
+
+  _errorHandler: function (req, callback) {
+    var self = this;
+    return function (error) {
+      if (req._isAborted) {
+        // already handled
+        return;
+      }
+      callback.call(self, new Error.pinterestConnectionError({
+        message: 'An error occurred with our connection to pinterest',
+        error: error
+      }), null);
+    };
+  },
+
+  _request: function (method, path, data, auth, options, callback) {
+    var requestParamsJSONCopy = JSON.parse(JSON.stringify(data));
+    var self = this;
+
+    self.body = '';
+    var userRaw = '';
+    var userCharset = '';
+    /**custom option passed by user, a better way to do this would be nice */
+    if (data.__RAW__) {
+      userRaw = data.__RAW__;
+      delete data.__RAW__;
+    }
+    if (data.__CHARSET__) {
+      userCharset = data.__CHARSET__;
+      delete data.__CHARSET__;
+    }
+
+    var authorization = 'Bearer';
+    if (options.authorization === 'Basic') {
+      authorization = options.authorization;
+      var keySecret = self._pinterest.getApiField('key') + ':' + self._pinterest.getApiField('secret');
+      var buffer = new Buffer(keySecret);
+      var base64String = buffer.toString('base64');
+      authorization = authorization.concat(' ', base64String);
+    } else {
+      authorization = authorization.concat(' ', self._pinterest.getApiField('userToken'));
+    }
+
+    var headers = {
+      // 'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'cache-control': 'no-cache',
+      'Content-Language': 'en-US',
+      'Authorization': authorization
+    };
+
+    if (options.contentType && options.contentType === 'application/json') {
+      self.body = JSON.stringify(data);
+      headers['Content-Length'] = self.body.length;
+    } else if (['POST', 'PUT', 'PATCH'].indexOf(method) > -1) {
+      headers['Content-Type'] = 'application/json';
+      self.body = JSON.stringify(data);
+      headers['Content-Length'] = self.body.length;
+    } else if (['GET'].indexOf(method) > -1) {
+      path = path.concat('?', qs.stringify(data));
+    } else if (['DELETE'].indexOf(method) > -1) {
+      self.body = JSON.stringify(data);
+    }
+
+    makeRequest();
+
+    function makeRequest() {
+      var timeout = self._pinterest.getApiField('timeout');
+      var isInsecureConnection = self._pinterest.getApiField('protocol') === 'http';
+
+      var host = self.overrideHost || self._pinterest.getApiField('host');
+      var params = {
+        hostname: host,
+        port: self._pinterest.getApiField('port'),
+        path: path,
+        method: method,
+        headers: headers
+      };
+      
+      debug('path ', path);
+      debug('params %o ', params);
+      debug('self.body %o ', self.body);
+      var req = (isInsecureConnection ? http : https).request(params);
+
+      req.setTimeout(timeout, self._timeoutHandler(timeout, req, callback));
+      var userOptions = {
+        userCharset: userCharset,
+        userRaw: userRaw
+      };
+      req.on('response', self._responseHandler(requestParamsJSONCopy, req, userOptions, callback));
+      req.on('error', self._errorHandler(req, callback));
+
+      req.on('socket', function (socket) {
+        socket.on((isInsecureConnection ? 'connect' : 'secureConnect'), function () {
+          // Send payload; we're safe:
+          req.write(self.body);
+          req.end();
+        });
+      });
+    }
+  }
+};
+
+module.exports = pinterestResource;

node_modules/pinterest-node-api/lib/index.js

@@ -0,0 +1,95 @@
+'use strict';
+
+// var debug = require('debug')('pinterest:pinterest-node-api-index');
+pinterest.DEFAULT_HOST = 'api.pinterest.com';
+pinterest.DEFAULT_PORT = '443';
+pinterest.DEFAULT_BASE_PATH = '/';
+pinterest.DEFAULT_RESPONSE_FORMAT = '.json';
+pinterest.DEFAULT_API_VERSION = null;
+
+// Use node's default timeout:
+pinterest.DEFAULT_TIMEOUT = require('http').createServer().timeout;
+
+pinterest.PACKAGE_VERSION = require('../package.json').version;
+
+var resources = {
+  users: require('./resources/users'),
+  boards: require('./resources/boards'),
+  pins: require('./resources/pins'),
+  sections: require('./resources/sections')
+};
+
+pinterest.pinterestResource = require('./Resource');
+pinterest.resources = resources;
+
+function pinterest(clientAccessToken) {
+  if (!(this instanceof pinterest)) {
+    return new pinterest(clientAccessToken);
+  }
+
+  this._api = {
+    auth: null,
+    host: pinterest.DEFAULT_HOST,
+    port: pinterest.DEFAULT_PORT,
+    basePath: pinterest.DEFAULT_BASE_PATH,
+    version: pinterest.DEFAULT_API_VERSION,
+    timeout: pinterest.DEFAULT_TIMEOUT
+  };
+
+  this._prepResources();
+  this.setUserToken(clientAccessToken);
+  this.setResponseFormat(pinterest.DEFAULT_RESPONSE_FORMAT);
+}
+
+pinterest.prototype = {
+
+  setHost: function (host, port, protocol) {
+    this._setApiField('host', host);
+    if (port) {
+      this.setPort(port);
+    }
+    if (protocol) {
+      this.setProtocol(protocol);
+    }
+  },
+
+  setProtocol: function (protocol) {
+    this._setApiField('protocol', protocol.toLowerCase());
+  },
+
+  setPort: function (port) {
+    this._setApiField('port', port);
+  },
+
+  setResponseFormat: function (format) {
+    this._setApiField('format', format);
+  },
+
+  setUserToken: function (token) {
+    if (token) {
+      this._setApiField('userToken', token);
+    }
+  },
+
+  setTimeout: function (timeout) {
+    this._setApiField('timeout', timeout === null ? pinterest.DEFAULT_TIMEOUT : timeout);
+  },
+
+  _setApiField: function (key, value) {
+    this._api[key] = value;
+  },
+
+  getApiField: function (key) {
+    return this._api[key];
+  },
+
+  _prepResources: function () {
+    for (var name in resources) {
+      this[name[0].toLowerCase() + name.substring(1)] = new resources[name](this);
+    }
+  }
+};
+
+module.exports = pinterest;
+
+module.exports.pinterest = pinterest;

node_modules/pinterest-node-api/lib/resources/boards.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var pinterestResource = require('../Resource');
+var pinterestMethod = pinterestResource.methods.pinterestMethod;
+
+module.exports = pinterestResource.extend({
+
+  createBoard: pinterestMethod({
+    method: 'POST',
+    path: 'v1/boards/'
+  }),
+
+  getBoard: pinterestMethod({
+    method: 'GET',
+    path: 'v1/boards/{board}/',
+    urlParams: ['board'],
+    required: ['board']
+  }),
+
+  getBoardPins: pinterestMethod({
+    method: 'GET',
+    path: 'v1/boards/{board}/pins/',
+    urlParams: ['board'],
+    required: ['board']
+  }),
+
+  getUserBoards: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/boards/'
+  }),
+
+  updateBoard: pinterestMethod({
+    method: 'PATCH',
+    path: 'v1/boards/{board}/',
+    urlParams: ['board'],
+    required: ['board']
+  }),
+
+  deleteBoard: pinterestMethod({
+    method: 'DELETE',
+    path: 'v1/boards/{board}/',
+    urlParams: ['board'],
+    required: ['board']
+  })
+});

node_modules/pinterest-node-api/lib/resources/pins.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var pinterestResource = require('../Resource');
+var pinterestMethod = pinterestResource.methods.pinterestMethod;
+
+module.exports = pinterestResource.extend({
+
+  createPin: pinterestMethod({
+    method: 'POST',
+    path: 'v1/pins/'
+  }),
+
+  getPin: pinterestMethod({
+    method: 'GET',
+    path: 'v1/pins/{pin}/',
+    urlParams: ['pin'],
+    required: ['pin']
+  }),
+
+  getBoardPins: pinterestMethod({
+    method: 'GET',
+    path: 'v1/boards/{board}/pins/',
+    urlParams: ['board'],
+    required: ['board']
+  }),
+
+  getUserPins: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/pins/'
+  }),
+
+  updatePin: pinterestMethod({
+    method: 'PATCH',
+    path: 'v1/pins/{pin}/',
+    urlParams: ['pin'],
+    required: ['pin']
+  }),
+
+  deletePin: pinterestMethod({
+    method: 'DELETE',
+    path: 'v1/pins/{pin}/',
+    urlParams: ['pin'],
+    required: ['pin']
+  })
+});

node_modules/pinterest-node-api/lib/resources/sections.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var pinterestResource = require('../Resource');
+var pinterestMethod = pinterestResource.methods.pinterestMethod;
+
+module.exports = pinterestResource.extend({
+
+  createBoardSection: pinterestMethod({
+    method: 'PUT',
+    path: 'v1/board/{board}/sections/',
+    urlParams: ['board'],
+    required: ['board']
+  }),
+
+  getBoardSections: pinterestMethod({
+    method: 'GET',
+    path: 'v1/board/{board}/sections/',
+    urlParams: ['board'],
+    required: ['board']
+  }),
+
+  getBoardSectionPins: pinterestMethod({
+    method: 'GET',
+    path: 'v1/board/sections/{section}/pins/',
+    urlParams: ['section'],
+    required: ['section']
+  }),
+
+  deleteBoardSection: pinterestMethod({
+    method: 'DELETE',
+    path: 'v1/board/sections/{section}/',
+    urlParams: ['section'],
+    required: ['section']
+  })
+});

node_modules/pinterest-node-api/lib/resources/users.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var pinterestResource = require('../Resource');
+var pinterestMethod = pinterestResource.methods.pinterestMethod;
+
+module.exports = pinterestResource.extend({
+
+  getUserOwnInfo: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/'
+  }),
+
+  getUserBoards: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/boards/'
+  }),
+
+  getUserBoardSuggestions: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/boards/suggested/'
+  }),
+
+  getUserPins: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/pins/'
+  }),
+
+  searchUserBoards: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/search/boards/'
+  }),
+
+  searchUserPins: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/search/pins/'
+  }),
+
+  followBoard: pinterestMethod({
+    method: 'POST',
+    path: 'v1/me/following/boards/'
+  }),
+
+  followUser: pinterestMethod({
+    method: 'POST',
+    path: 'v1/me/following/users/'
+  }),
+
+  getUserFollowers: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/followers/'
+  }),
+
+  getUserFollowingBoards: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/following/boards/'
+  }),
+
+  getUserFollowingInterests: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/following/interests/'
+  }),
+
+  getUserFollowingUsers: pinterestMethod({
+    method: 'GET',
+    path: 'v1/me/following/users/'
+  }),
+
+  unfollowBoard: pinterestMethod({
+    method: 'DELETE',
+    path: 'v1/me/following/boards/{board}/',
+    urlParams: ['board'],
+    required: ['board']
+  }),
+
+  unfollowUser: pinterestMethod({
+    method: 'DELETE',
+    path: 'v1/me/following/users/{user}/',
+    urlParams: ['user'],
+    required: ['user']
+  }),
+
+  getUserInfo: pinterestMethod({
+    method: 'GET',
+    path: 'v1/users/{user}/',
+    urlParams: ['user'],
+    required: ['user']
+  })
+});

node_modules/pinterest-node-api/lib/utils/index.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var hasOwn = {}.hasOwnProperty;
+var _ = require('lodash');
+
+var utils = module.exports = {
+
+  isAuthKey: function (key) {
+    return typeof key === 'string' && /^(?:[a-z]{2}_)?[A-z0-9]{32}$/.test(key);
+  },
+
+  isOptionsHash: function (o) {
+    o = JSON.parse(JSON.stringify(o));
+    return _.isPlainObject(o) && ['api_key'].some(function (key) {
+      return o.hasOwnProperty(key);
+    });
+  },
+
+  /**
+   * Outputs a new function with interpolated object property values.
+   * Use like so:
+   *   var fn = makeURLInterpolator('some/url/{param1}/{param2}');
+   *   fn({ param1: 123, param2: 456 }); // => 'some/url/123/456'
+   */
+  makeURLInterpolator: (function () {
+    var rc = {
+      '\n': '\\n', '\"': '\\\"',
+      '\u2028': '\\u2028', '\u2029': '\\u2029'
+    };
+    return function makeURLInterpolator(str) {
+      var cleanString = str.replace(/["\n\r\u2028\u2029]/g, function ($0) {
+        return rc[$0];
+      });
+      return function (outputs) {
+        return cleanString.replace(/\{([\s\S]+?)\}/g, function ($0, $1) {
+          return encodeURIComponent(outputs[$1] || '');
+        });
+      };
+    };
+  }()),
+
+  /**
+   * Return the data argument from a list of arguments
+   */
+  getDataFromArgs: function (args) {
+    if (args.length > 0) {
+      if (_.isPlainObject(args[0]) && !utils.isOptionsHash(args[0])) {
+        return args.shift();
+      }
+    }
+    return {};
+  },
+
+  /**
+   * Return the options hash from a list of arguments
+   */
+  getOptionsFromArgs: function (args) {
+    var opts = {
+      auth: null,
+      headers: {}
+    };
+    if (args.length > 0) {
+      var arg = args[args.length - 1];
+      if (utils.isAuthKey(arg)) {
+        opts.auth = args.pop();
+      }
+    }
+    return opts;
+  },
+
+  /**
+   * Provide simple "Class" extension mechanism
+   */
+  protoExtend: function (sub) {
+    var Super = this;
+    var Constructor = hasOwn.call(sub, 'constructor') ? sub.constructor : function () {
+      Super.apply(this, arguments);
+    };
+    Constructor.prototype = Object.create(Super.prototype);
+    for (var i in sub) {
+      if (hasOwn.call(sub, i)) {
+        Constructor.prototype[i] = sub[i];
+      }
+    }
+    for (i in Super) {
+      if (hasOwn.call(Super, i)) {
+        Constructor[i] = Super[i];
+      }
+    }
+    return Constructor;
+  }
+};

node_modules/pinterest-node-api/package.json

@@ -0,0 +1,92 @@
+{
+  "_from": "pinterest-node-api",
+  "_id": "pinterest-node-api@0.0.3",
+  "_inBundle": false,
+  "_integrity": "sha512-OqlF1rnU0AYMWEcWJUSwGjw42/xmVCVBRcSXFDoIK+ml7H6UyA55H+dqkNZ0xZdrg8cm8gr5OZxWD0Tw6SYANQ==",
+  "_location": "/pinterest-node-api",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "pinterest-node-api",
+    "name": "pinterest-node-api",
+    "escapedName": "pinterest-node-api",
+    "rawSpec": "",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/pinterest-node-api/-/pinterest-node-api-0.0.3.tgz",
+  "_shasum": "83d6812e30454845adec1ce6ee2c86ba42f1f65e",
+  "_spec": "pinterest-node-api",
+  "_where": "D:\\dev\\crossmap\\backend-services\\cm-app-pinterestapiclient",
+  "author": {
+    "name": "Vijay Patoliya",
+    "email": "osi.vijay@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/vijaypatoliya/pinterest-node-api/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Vijay Patoliya",
+      "url": "osi.vijay@gmail.com"
+    }
+  ],
+  "dependencies": {
+    "bluebird": "^3.5.3",
+    "chai": "^4.2.0",
+    "debug": "^4.1.0",
+    "iconv-lite": "^0.4.24",
+    "lodash": "^4.17.11",
+    "mocha": "^5.2.0",
+    "qs": "^6.6.0",
+    "xml2js": "^0.4.19"
+  },
+  "deprecated": false,
+  "description": "pinterest api wrapper",
+  "devDependencies": {
+    "jshint": "^2.9.7"
+  },
+  "directories": {
+    "example": "examples",
+    "lib": "lib",
+    "test": "test"
+  },
+  "engines": {
+    "node": ">= v0.10.0"
+  },
+  "homepage": "https://github.com/vijaypatoliya/pinterest-node-api",
+  "keywords": [
+    "pinterest",
+    "pinterest node",
+    "pinterest node API",
+    "pinterest API",
+    "pinterest sdk",
+    "pinterest users API",
+    "pinterest boards API",
+    "pinterest pins API",
+    "pinterest sections API",
+    "pinterest-node",
+    "pinterest-node-api",
+    "pinterest-client",
+    "pinterest-sdk"
+  ],
+  "license": "MIT",
+  "main": "lib/index.js",
+  "name": "pinterest-node-api",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vijaypatoliya/pinterest-node-api.git"
+  },
+  "scripts": {
+    "lint": "jshint ./",
+    "test": "npm run lint",
+    "test.mocha": "npm run lint && mocha"
+  },
+  "version": "0.0.3"
+}

node_modules/pinterest-node-api/test/intialize/config.js

@@ -0,0 +1,3 @@
+module.exports = {
+    USER_TOKEN: process.env.PINTEREST_USER_TOKEN
+};

node_modules/pinterest-node-api/test/mocha.opts

@@ -0,0 +1,11 @@
+###
+### mocha.opts
+###
+
+--bail
+--silly
+--full-trace
+--recursive
+--timeout 20000
+--reporter spec
+./test/specs/**/*.spec.js

node_modules/pinterest-node-api/test/specs/resources/app.spec.js

@@ -0,0 +1,638 @@
+'use strict';
+
+var config = require('../../intialize/config');
+var userToken = config.USER_TOKEN;
+
+var chai = require('chai');
+var expect = chai.expect;
+
+var pinterest = require('../../../lib')(userToken);
+
+describe('GetUserOwnInfo', function () {
+  it('It should get the logged in user\'s information', async function () {
+    var data = {};
+    try {
+      var response = await pinterest.users.getUserOwnInfo(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserBoards', function () {
+  it('It should get the logged in user\'s boards', async function () {
+    var data = {};
+    try {
+      var response = await pinterest.users.getUserBoards(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserBoardSuggestions', function () {
+  it('It should get the logged in user\'s board suggestions', async function () {
+    var data = {
+      pin: '806144402026290934'
+    };
+    try {
+      var response = await pinterest.users.getUserBoardSuggestions(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserPins', function () {
+  it('It should get the logged in user\'s Pins', async function () {
+    var data = {};
+    try {
+      var response = await pinterest.users.getUserPins(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('SearchUserBoards', function () {
+  it('It should Search the logged in user\'s Boards', async function () {
+    var data = {
+      query: 'board 1',
+      fields: 'counts,id,name,url'
+    };
+    try {
+      var response = await pinterest.users.searchUserBoards(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('SearchUserPins', function () {
+  it('It should Search the logged in user\'s Pins', async function () {
+    var data = {
+      query: 'test',
+      fields: 'id,board,link,note,url'
+    };
+    try {
+      var response = await pinterest.users.searchUserPins(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('FollowBoard', function () {
+  it('It should follow the specified board by the authenticated user', async function () {
+    var data = {
+      board: '4teebeat/bodybuilding-t-shirts'
+    };
+    try {
+      var response = await pinterest.users.followBoard(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('FollowUser', function () {
+  it('It should follow the specified user by the authenticated user', async function () {
+    var data = {
+      user: '4teebeat'
+    };
+    try {
+      var response = await pinterest.users.followUser(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserFollowers', function () {
+  it('It should return the users that follow the logged in user', async function () {
+    var data = {
+      fields: 'id,first_name,last_name,url'
+    };
+    try {
+      var response = await pinterest.users.getUserFollowers(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserFollowingBoards', function () {
+  it('It should get the Boards that the logged in user follows', async function () {
+    var data = {
+      fields: 'id,name,url'
+    };
+    try {
+      var response = await pinterest.users.getUserFollowingBoards(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserFollowingInterests', function () {
+  it('It should return the Interests the logged in user follows', async function () {
+    var data = {
+      fields: 'id,name'
+    };
+    try {
+      var response = await pinterest.users.getUserFollowingInterests(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserFollowingUsers', function () {
+  it('It should return the users that the logged in user follows', async function () {
+    var data = {
+      fields: 'id,first_name,last_name,url'
+    };
+    try {
+      var response = await pinterest.users.getUserFollowingUsers(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('UnfollowBoard', function () {
+  it('It should unfollow the specified board', async function () {
+    var board = '4teebeat/bodybuilding-t-shirts'
+    try {
+      var response = await pinterest.users.unfollowBoard(board).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('UnfollowUser', function () {
+  it('It should unfollow the specified user', async function () {
+    var user = '4teebeat'
+    try {
+      var response = await pinterest.users.unfollowUser(user).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserInfo', function () {
+  it('It should return a user\'s information', async function () {
+    var user = '4teebeat'
+    try {
+      var response = await pinterest.users.getUserInfo(user).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('CreateBoard', function () {
+  it('It should create board', async function () {
+    var data = {
+      name: 'test board',
+      description: 'it\'s a test board'
+    };
+    try {
+      var response = await pinterest.boards.createBoard(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetBoard', function () {
+  it('It should retrieve information about a Board', async function () {
+    var board = 'pideveloper/test-board';
+    try {
+      var response = await pinterest.boards.getBoard(board).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetBoardPins', function () {
+  it('It should retrieve the Pins on a Board', async function () {
+    var board = 'pideveloper/test-board';
+    try {
+      var response = await pinterest.boards.getBoardPins(board).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserBoards', function () {
+  it('It should get the logged in user\'s boards', async function () {
+    var data = {};
+    try {
+      var response = await pinterest.boards.getUserBoards(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('UpdateBoard', function () {
+  it('It should edit a Board', async function () {
+    var data = {
+      name: 'Board 11',
+      description: 'it\'s a board no 11.'
+    };
+    var board = 'pideveloper/test-board';
+    try {
+      var response = await pinterest.boards.updateBoard(board, data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('DeleteBoard', function () {
+  it('It should delete a Board', async function () {
+    var board = 'pideveloper/board-11';
+    try {
+      var response = await pinterest.boards.deleteBoard(board).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('CreatePin', function () {
+  it('It should create a pin', async function () {
+    var data = {
+      board: 'pideveloper/board-2',
+      note: 'it\'s a test pin desc.',
+      image_url: 'https://www.birmingham.ac.uk/Images/College-EPS-only/outreach/engineering/aerospace-engineering.jpg'
+    };
+    try {
+      var response = await pinterest.pins.createPin(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetPin', function () {
+  it('It should return information about a Pin', async function () {
+    var pin = '806144402027821208';
+    try {
+      var response = await pinterest.pins.getPin(pin).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetBoardPins', function () {
+  it('It should retrieve the Pins on a Board', async function () {
+    var board = 'pideveloper/test-board';
+    try {
+      var response = await pinterest.pins.getBoardPins(board).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetUserPins', function () {
+  it('It should get the logged in user\'s Pins', async function () {
+    var data = {};
+    try {
+      var response = await pinterest.pins.getUserPins(data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('UpdatePin', function () {
+  it('It should edit a Pin\'s information', async function () {
+    var pin = '806144402027821208';
+    var data = {
+      board: 'pideveloper/board-2',
+      note: 'it\'s a aerospace test pin.',
+      link: 'https://aerospace.org/'
+    };
+    try {
+      var response = await pinterest.pins.updatePin(pin, data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('DeletePin', function () {
+  it('It should delete a Pin', async function () {
+    var pin = '806144402027821208';
+    try {
+      var response = await pinterest.pins.deletePin(pin).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('CreateBoardSection', function () {
+  it('It should creates a new board section', async function () {
+    var board = '806144470738408510';
+    var data = {
+      title: 'test_section',
+      // initial_pins: '806144402026288820'
+    };
+    try {
+      var response = await pinterest.sections.createBoardSection(board, data).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetBoardSections', function () {
+  it('It should gets sections for a board', async function () {
+    var board = '806144470738408510';
+    try {
+      var response = await pinterest.sections.getBoardSections(board).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('GetBoardSectionPins', function () {
+  it('It should gets the pins for a board section', async function () {
+    var section = 'pideveloper/board-2/lighting';
+    try {
+      var response = await pinterest.sections.getBoardSectionPins(section).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});
+
+describe('DeleteBoardSection', function () {
+  it('It should deletes a board section', async function () {
+    var section = '5007819528581703555';
+    try {
+      var response = await pinterest.sections.deleteBoardSection(section).catch(error => {
+        if (error) {
+          console.log('error ', error);
+          return;
+        }
+      });
+      console.log('response', response);
+      expect(response).to.be.a('object');
+    } catch (error) {
+      console.log('error ', error);
+      expect(response).to.be.a(undefined);
+    }
+  });
+});