node_modules

node_modules/@octokit/rest/plugins/authentication-deprecated/authenticate.js

@@ -0,0 +1,41 @@
+module.exports = authenticate
+
+const { Deprecation } = require('deprecation')
+const once = require('once')
+
+const deprecateAuthenticate = once((log, deprecation) => log.warn(deprecation))
+
+function authenticate (state, options) {
+  deprecateAuthenticate(state.octokit.log, new Deprecation('[@octokit/rest] octokit.authenticate() is deprecated. Use "auth" constructor option instead.'))
+
+  if (!options) {
+    state.auth = false
+    return
+  }
+
+  switch (options.type) {
+    case 'basic':
+      if (!options.username || !options.password) {
+        throw new Error('Basic authentication requires both a username and password to be set')
+      }
+      break
+
+    case 'oauth':
+      if (!options.token && !(options.key && options.secret)) {
+        throw new Error('OAuth2 authentication requires a token or key & secret to be set')
+      }
+      break
+
+    case 'token':
+    case 'app':
+      if (!options.token) {
+        throw new Error('Token authentication requires a token to be set')
+      }
+      break
+
+    default:
+      throw new Error("Invalid authentication type, must be 'basic', 'oauth', 'token' or 'app'")
+  }
+
+  state.auth = options
+}

node_modules/@octokit/rest/plugins/authentication-deprecated/before-request.js

@@ -0,0 +1,40 @@
+module.exports = authenticationBeforeRequest
+
+const btoa = require('btoa-lite')
+const uniq = require('lodash.uniq')
+
+function authenticationBeforeRequest (state, options) {
+  if (!state.auth.type) {
+    return
+  }
+
+  if (state.auth.type === 'basic') {
+    const hash = btoa(`${state.auth.username}:${state.auth.password}`)
+    options.headers.authorization = `Basic ${hash}`
+    return
+  }
+
+  if (state.auth.type === 'token') {
+    options.headers.authorization = `token ${state.auth.token}`
+    return
+  }
+
+  if (state.auth.type === 'app') {
+    options.headers.authorization = `Bearer ${state.auth.token}`
+    const acceptHeaders = options.headers.accept.split(',')
+      .concat('application/vnd.github.machine-man-preview+json')
+    options.headers.accept = uniq(acceptHeaders).filter(Boolean).join(',')
+    return
+  }
+
+  options.url += options.url.indexOf('?') === -1 ? '?' : '&'
+
+  if (state.auth.token) {
+    options.url += `access_token=${encodeURIComponent(state.auth.token)}`
+    return
+  }
+
+  const key = encodeURIComponent(state.auth.key)
+  const secret = encodeURIComponent(state.auth.secret)
+  options.url += `client_id=${key}&client_secret=${secret}`
+}

node_modules/@octokit/rest/plugins/authentication-deprecated/index.js

@@ -0,0 +1,26 @@
+module.exports = authenticationPlugin
+
+const { Deprecation } = require('deprecation')
+const once = require('once')
+
+const deprecateAuthenticate = once((log, deprecation) => log.warn(deprecation))
+
+const authenticate = require('./authenticate')
+const beforeRequest = require('./before-request')
+const requestError = require('./request-error')
+
+function authenticationPlugin (octokit, options) {
+  if (options.auth) {
+    octokit.authenticate = () => {
+      deprecateAuthenticate(octokit.log, new Deprecation('[@octokit/rest] octokit.authenticate() is deprecated and has no effect when "auth" option is set on Octokit constructor'))
+    }
+    return
+  }
+  const state = {
+    octokit,
+    auth: false
+  }
+  octokit.authenticate = authenticate.bind(null, state)
+  octokit.hook.before('request', beforeRequest.bind(null, state))
+  octokit.hook.error('request', requestError.bind(null, state))
+}

node_modules/@octokit/rest/plugins/authentication-deprecated/request-error.js

@@ -0,0 +1,39 @@
+module.exports = authenticationRequestError
+
+const { RequestError } = require('@octokit/request-error')
+
+function authenticationRequestError (state, error, options) {
+  /* istanbul ignore next */
+  if (!error.headers) throw error
+
+  const otpRequired = /required/.test(error.headers['x-github-otp'] || '')
+  // handle "2FA required" error only
+  if (error.status !== 401 || !otpRequired) {
+    throw error
+  }
+
+  if (error.status === 401 && otpRequired && error.request && error.request.headers['x-github-otp']) {
+    throw new RequestError('Invalid one-time password for two-factor authentication', 401, {
+      headers: error.headers,
+      request: options
+    })
+  }
+
+  if (typeof state.auth.on2fa !== 'function') {
+    throw new RequestError('2FA required, but options.on2fa is not a function. See https://github.com/octokit/rest.js#authentication', 401, {
+      headers: error.headers,
+      request: options
+    })
+  }
+
+  return Promise.resolve()
+    .then(() => {
+      return state.auth.on2fa()
+    })
+    .then((oneTimePassword) => {
+      const newOptions = Object.assign(options, {
+        headers: Object.assign({ 'x-github-otp': oneTimePassword }, options.headers)
+      })
+      return state.octokit.request(newOptions)
+    })
+}

node_modules/@octokit/rest/plugins/authentication/before-request.js

@@ -0,0 +1,61 @@
+module.exports = authenticationBeforeRequest
+
+const btoa = require('btoa-lite')
+
+const withAuthorizationPrefix = require('./with-authorization-prefix')
+
+function authenticationBeforeRequest (state, options) {
+  if (typeof state.auth === 'string') {
+    options.headers.authorization = withAuthorizationPrefix(state.auth)
+
+    // https://developer.github.com/v3/previews/#integrations
+    if (/^bearer /i.test(state.auth) && !/machine-man/.test(options.headers.accept)) {
+      const acceptHeaders = options.headers.accept.split(',')
+        .concat('application/vnd.github.machine-man-preview+json')
+      options.headers.accept = acceptHeaders.filter(Boolean).join(',')
+    }
+
+    return
+  }
+
+  if (state.auth.username) {
+    const hash = btoa(`${state.auth.username}:${state.auth.password}`)
+    options.headers.authorization = `Basic ${hash}`
+    if (state.otp) {
+      options.headers['x-github-otp'] = state.otp
+    }
+    return
+  }
+
+  if (state.auth.clientId) {
+    // There is a special case for OAuth applications, when `clientId` and `clientSecret` is passed as
+    // Basic Authorization instead of query parameters. The only routes where that applies share the same
+    // URL though: `/applications/:client_id/tokens/:access_token`.
+    //
+    //  1. [Check an authorization](https://developer.github.com/v3/oauth_authorizations/#check-an-authorization)
+    //  2. [Reset an authorization](https://developer.github.com/v3/oauth_authorizations/#reset-an-authorization)
+    //  3. [Revoke an authorization for an application](https://developer.github.com/v3/oauth_authorizations/#revoke-an-authorization-for-an-application)
+    //
+    // We identify by checking the URL. It must merge both "/applications/:client_id/tokens/:access_token"
+    // as well as "/applications/123/tokens/token456"
+    if (/\/applications\/:?[\w_]+\/tokens\/:?[\w_]+($|\?)/.test(options.url)) {
+      const hash = btoa(`${state.auth.clientId}:${state.auth.clientSecret}`)
+      options.headers.authorization = `Basic ${hash}`
+      return
+    }
+
+    options.url += options.url.indexOf('?') === -1 ? '?' : '&'
+    options.url += `client_id=${state.auth.clientId}&client_secret=${state.auth.clientSecret}`
+    return
+  }
+
+  return Promise.resolve()
+
+    .then(() => {
+      return state.auth()
+    })
+
+    .then((authorization) => {
+      options.headers.authorization = withAuthorizationPrefix(authorization)
+    })
+}

node_modules/@octokit/rest/plugins/authentication/index.js

@@ -0,0 +1,21 @@
+module.exports = authenticationPlugin
+
+const beforeRequest = require('./before-request')
+const requestError = require('./request-error')
+const validate = require('./validate')
+
+function authenticationPlugin (octokit, options) {
+  if (!options.auth) {
+    return
+  }
+
+  validate(options.auth)
+
+  const state = {
+    octokit,
+    auth: options.auth
+  }
+
+  octokit.hook.before('request', beforeRequest.bind(null, state))
+  octokit.hook.error('request', requestError.bind(null, state))
+}

node_modules/@octokit/rest/plugins/authentication/request-error.js

@@ -0,0 +1,47 @@
+module.exports = authenticationRequestError
+
+const { RequestError } = require('@octokit/request-error')
+
+function authenticationRequestError (state, error, options) {
+  if (!error.headers) throw error
+
+  const otpRequired = /required/.test(error.headers['x-github-otp'] || '')
+  // handle "2FA required" error only
+  if (error.status !== 401 || !otpRequired) {
+    throw error
+  }
+
+  if (error.status === 401 && otpRequired && error.request && error.request.headers['x-github-otp']) {
+    if (state.otp) {
+      delete state.otp // no longer valid, request again
+    } else {
+      throw new RequestError('Invalid one-time password for two-factor authentication', 401, {
+        headers: error.headers,
+        request: options
+      })
+    }
+  }
+
+  if (typeof state.auth.on2fa !== 'function') {
+    throw new RequestError('2FA required, but options.on2fa is not a function. See https://github.com/octokit/rest.js#authentication', 401, {
+      headers: error.headers,
+      request: options
+    })
+  }
+
+  return Promise.resolve()
+    .then(() => {
+      return state.auth.on2fa()
+    })
+    .then((oneTimePassword) => {
+      const newOptions = Object.assign(options, {
+        headers: Object.assign(options.headers, { 'x-github-otp': oneTimePassword })
+      })
+      return state.octokit.request(newOptions)
+        .then(response => {
+          // If OTP still valid, then persist it for following requests
+          state.otp = oneTimePassword
+          return response
+        })
+    })
+}

node_modules/@octokit/rest/plugins/authentication/validate.js

@@ -0,0 +1,21 @@
+module.exports = validateAuth
+
+function validateAuth (auth) {
+  if (typeof auth === 'string') {
+    return
+  }
+
+  if (typeof auth === 'function') {
+    return
+  }
+
+  if (auth.username && auth.password) {
+    return
+  }
+
+  if (auth.clientId && auth.clientSecret) {
+    return
+  }
+
+  throw new Error(`Invalid "auth" option: ${JSON.stringify(auth)}`)
+}

node_modules/@octokit/rest/plugins/authentication/with-authorization-prefix.js

@@ -0,0 +1,23 @@
+module.exports = withAuthorizationPrefix
+
+const atob = require('atob-lite')
+
+const REGEX_IS_BASIC_AUTH = /^[\w-]+:/
+
+function withAuthorizationPrefix (authorization) {
+  if (/^(basic|bearer|token) /i.test(authorization)) {
+    return authorization
+  }
+
+  try {
+    if (REGEX_IS_BASIC_AUTH.test(atob(authorization))) {
+      return `basic ${authorization}`
+    }
+  } catch (error) { }
+
+  if (authorization.split(/\./).length === 3) {
+    return `bearer ${authorization}`
+  }
+
+  return `token ${authorization}`
+}

node_modules/@octokit/rest/plugins/log/index.js

@@ -0,0 +1,22 @@
+module.exports = octokitDebug
+
+function octokitDebug (octokit) {
+  octokit.hook.wrap('request', (request, options) => {
+    octokit.log.debug('request', options)
+    const start = Date.now()
+    const requestOptions = octokit.request.endpoint.parse(options)
+    const path = requestOptions.url.replace(options.baseUrl, '')
+
+    return request(options)
+
+      .then(response => {
+        octokit.log.info(`${requestOptions.method} ${path} - ${response.status} in ${Date.now() - start}ms`)
+        return response
+      })
+
+      .catch(error => {
+        octokit.log.info(`${requestOptions.method} ${path} - ${error.status} in ${Date.now() - start}ms`)
+        throw error
+      })
+  })
+}

node_modules/@octokit/rest/plugins/normalize-git-reference-responses/index.js

@@ -0,0 +1,53 @@
+module.exports = octokitRestNormalizeGitReferenceResponses
+
+const { RequestError } = require('@octokit/request-error')
+
+function octokitRestNormalizeGitReferenceResponses (octokit) {
+  octokit.hook.wrap('request', (request, options) => {
+    const isGetOrListRefRequest = /\/repos\/:?\w+\/:?\w+\/git\/refs\/:?\w+/.test(options.url)
+
+    if (!isGetOrListRefRequest) {
+      return request(options)
+    }
+
+    const isGetRefRequest = 'ref' in options
+
+    return request(options)
+      .then(response => {
+        // request single reference
+        if (isGetRefRequest) {
+          if (Array.isArray(response.data)) {
+            throw new RequestError(`More than one reference found for "${options.ref}"`, 404, {
+              request: options
+            })
+          }
+
+          // ✅ received single reference
+          return response
+        }
+
+        // request list of references
+        if (!Array.isArray(response.data)) {
+          response.data = [response.data]
+        }
+
+        return response
+      })
+
+      .catch(error => {
+        if (isGetRefRequest) {
+          throw error
+        }
+
+        if (error.status === 404) {
+          return {
+            status: 200,
+            headers: error.headers,
+            data: []
+          }
+        }
+
+        throw error
+      })
+  })
+}

node_modules/@octokit/rest/plugins/pagination/index.js

@@ -0,0 +1,9 @@
+module.exports = paginatePlugin
+
+const iterator = require('./iterator')
+const paginate = require('./paginate')
+
+function paginatePlugin (octokit) {
+  octokit.paginate = paginate.bind(null, octokit)
+  octokit.paginate.iterator = iterator.bind(null, octokit)
+}

node_modules/@octokit/rest/plugins/pagination/iterator.js

@@ -0,0 +1,31 @@
+module.exports = iterator
+
+const normalizePaginatedListResponse = require('./normalize-paginated-list-response')
+
+function iterator (octokit, options) {
+  const headers = options.headers
+  let url = octokit.request.endpoint(options).url
+
+  return {
+    [Symbol.asyncIterator]: () => ({
+      next () {
+        if (!url) {
+          return Promise.resolve({ done: true })
+        }
+
+        return octokit.request({ url, headers })
+
+          .then((response) => {
+            normalizePaginatedListResponse(octokit, url, response)
+
+            // `response.headers.link` format:
+            // '<https://api.github.com/users/aseemk/followers?page=2>; rel="next", <https://api.github.com/users/aseemk/followers?page=2>; rel="last"'
+            // sets `url` to undefined if "next" URL is not present or `link` header is not set
+            url = ((response.headers.link || '').match(/<([^>]+)>;\s*rel="next"/) || [])[1]
+
+            return { value: response }
+          })
+      }
+    })
+  }
+}

node_modules/@octokit/rest/plugins/pagination/normalize-paginated-list-response.js

@@ -0,0 +1,91 @@
+/**
+ * Some “list” response that can be paginated have a different response structure
+ *
+ * They have a `total_count` key in the response (search also has `incomplete_results`,
+ * /installation/repositories also has `repository_selection`), as well as a key with
+ * the list of the items which name varies from endpoint to endpoint:
+ *
+ * - https://developer.github.com/v3/search/#example (key `items`)
+ * - https://developer.github.com/v3/checks/runs/#response-3 (key: `check_runs`)
+ * - https://developer.github.com/v3/checks/suites/#response-1 (key: `check_suites`)
+ * - https://developer.github.com/v3/apps/installations/#list-repositories (key: `repositories`)
+ * - https://developer.github.com/v3/apps/installations/#list-installations-for-a-user (key `installations`)
+ *
+ * Octokit normalizes these responses so that paginated results are always returned following
+ * the same structure. One challenge is that if the list response has only one page, no Link
+ * header is provided, so this header alone is not sufficient to check wether a response is
+ * paginated or not. For the exceptions with the namespace, a fallback check for the route
+ * paths has to be added in order to normalize the response. We cannot check for the total_count
+ * property because it also exists in the response of Get the combined status for a specific ref.
+ */
+
+module.exports = normalizePaginatedListResponse
+
+const { Deprecation } = require('deprecation')
+const once = require('once')
+
+const deprecateIncompleteResults = once((log, deprecation) => log.warn(deprecation))
+const deprecateTotalCount = once((log, deprecation) => log.warn(deprecation))
+const deprecateNamespace = once((log, deprecation) => log.warn(deprecation))
+
+const REGEX_IS_SEARCH_PATH = /^\/search\//
+const REGEX_IS_CHECKS_PATH = /^\/repos\/[^/]+\/[^/]+\/commits\/[^/]+\/(check-runs|check-suites)/
+const REGEX_IS_INSTALLATION_REPOSITORIES_PATH = /^\/installation\/repositories/
+const REGEX_IS_USER_INSTALLATIONS_PATH = /^\/user\/installations/
+
+function normalizePaginatedListResponse (octokit, url, response) {
+  const path = url.replace(octokit.request.endpoint.DEFAULTS.baseUrl, '')
+  if (
+    !REGEX_IS_SEARCH_PATH.test(path) &&
+    !REGEX_IS_CHECKS_PATH.test(path) &&
+    !REGEX_IS_INSTALLATION_REPOSITORIES_PATH.test(path) &&
+    !REGEX_IS_USER_INSTALLATIONS_PATH.test(path)
+  ) {
+    return
+  }
+
+  // keep the additional properties intact to avoid a breaking change,
+  // but log a deprecation warning when accessed
+  const incompleteResults = response.data.incomplete_results
+  const repositorySelection = response.data.repository_selection
+  const totalCount = response.data.total_count
+  delete response.data.incomplete_results
+  delete response.data.repository_selection
+  delete response.data.total_count
+
+  const namespaceKey = Object.keys(response.data)[0]
+
+  response.data = response.data[namespaceKey]
+
+  Object.defineProperty(response.data, namespaceKey, {
+    get () {
+      deprecateNamespace(octokit.log, new Deprecation(`[@octokit/rest] "result.data.${namespaceKey}" is deprecated. Use "result.data" instead`))
+      return response.data
+    }
+  })
+
+  if (typeof incompleteResults !== 'undefined') {
+    Object.defineProperty(response.data, 'incomplete_results', {
+      get () {
+        deprecateIncompleteResults(octokit.log, new Deprecation('[@octokit/rest] "result.data.incomplete_results" is deprecated.'))
+        return incompleteResults
+      }
+    })
+  }
+
+  if (typeof repositorySelection !== 'undefined') {
+    Object.defineProperty(response.data, 'repository_selection', {
+      get () {
+        deprecateTotalCount(octokit.log, new Deprecation('[@octokit/rest] "result.data.repository_selection" is deprecated.'))
+        return repositorySelection
+      }
+    })
+  }
+
+  Object.defineProperty(response.data, 'total_count', {
+    get () {
+      deprecateTotalCount(octokit.log, new Deprecation('[@octokit/rest] "result.data.total_count" is deprecated.'))
+      return totalCount
+    }
+  })
+}

node_modules/@octokit/rest/plugins/pagination/paginate.js

@@ -0,0 +1,34 @@
+module.exports = paginate
+
+const iterator = require('./iterator')
+
+function paginate (octokit, route, options, mapFn) {
+  if (typeof options === 'function') {
+    mapFn = options
+    options = undefined
+  }
+  options = octokit.request.endpoint.merge(route, options)
+  return gather(octokit, [], iterator(octokit, options)[Symbol.asyncIterator](), mapFn)
+}
+
+function gather (octokit, results, iterator, mapFn) {
+  return iterator.next()
+    .then(result => {
+      if (result.done) {
+        return results
+      }
+
+      let earlyExit = false
+      function done () {
+        earlyExit = true
+      }
+
+      results = results.concat(mapFn ? mapFn(result.value, done) : result.value.data)
+
+      if (earlyExit) {
+        return results
+      }
+
+      return gather(octokit, results, iterator, mapFn)
+    })
+}

node_modules/@octokit/rest/plugins/register-endpoints/index.js

@@ -0,0 +1,7 @@
+module.exports = octokitRegisterEndpoints
+
+const registerEndpoints = require('./register-endpoints')
+
+function octokitRegisterEndpoints (octokit) {
+  octokit.registerEndpoints = registerEndpoints.bind(null, octokit)
+}

node_modules/@octokit/rest/plugins/register-endpoints/register-endpoints.js

@@ -0,0 +1,87 @@
+module.exports = registerEndpoints
+
+const { Deprecation } = require('deprecation')
+
+function registerEndpoints (octokit, routes) {
+  Object.keys(routes).forEach(namespaceName => {
+    if (!octokit[namespaceName]) {
+      octokit[namespaceName] = {}
+    }
+
+    Object.keys(routes[namespaceName]).forEach(apiName => {
+      const apiOptions = routes[namespaceName][apiName]
+
+      const endpointDefaults = ['method', 'url', 'headers'].reduce((map, key) => {
+        if (typeof apiOptions[key] !== 'undefined') {
+          map[key] = apiOptions[key]
+        }
+
+        return map
+      }, {})
+
+      endpointDefaults.request = {
+        validate: apiOptions.params
+      }
+
+      let request = octokit.request.defaults(endpointDefaults)
+
+      // patch request & endpoint methods to support deprecated parameters.
+      // Not the most elegant solution, but we don’t want to move deprecation
+      // logic into octokit/endpoint.js as it’s out of scope
+      const hasDeprecatedParam = Object.keys(apiOptions.params || {}).find(key => apiOptions.params[key].deprecated)
+      if (hasDeprecatedParam) {
+        const patch = patchForDeprecation.bind(null, octokit, apiOptions)
+        request = patch(
+          octokit.request.defaults(endpointDefaults),
+          `.${namespaceName}.${apiName}()`
+        )
+        request.endpoint = patch(
+          request.endpoint,
+          `.${namespaceName}.${apiName}.endpoint()`
+        )
+        request.endpoint.merge = patch(
+          request.endpoint.merge,
+          `.${namespaceName}.${apiName}.endpoint.merge()`
+        )
+      }
+
+      if (apiOptions.deprecated) {
+        octokit[namespaceName][apiName] = function deprecatedEndpointMethod () {
+          octokit.log.warn(new Deprecation(`[@octokit/rest] ${apiOptions.deprecated}`))
+          octokit[namespaceName][apiName] = request
+          return request.apply(null, arguments)
+        }
+
+        return
+      }
+
+      octokit[namespaceName][apiName] = request
+    })
+  })
+}
+
+function patchForDeprecation (octokit, apiOptions, method, methodName) {
+  const patchedMethod = (options) => {
+    options = Object.assign({}, options)
+
+    Object.keys(options).forEach(key => {
+      if (apiOptions.params[key] && apiOptions.params[key].deprecated) {
+        const aliasKey = apiOptions.params[key].alias
+
+        octokit.log.warn(new Deprecation(`[@octokit/rest] "${key}" parameter is deprecated for "${methodName}". Use "${aliasKey}" instead`))
+
+        if (!(aliasKey in options)) {
+          options[aliasKey] = options[key]
+        }
+        delete options[key]
+      }
+    })
+
+    return method(options)
+  }
+  Object.keys(method).forEach(key => {
+    patchedMethod[key] = method[key]
+  })
+
+  return patchedMethod
+}

node_modules/@octokit/rest/plugins/rest-api-endpoints/index.js

@@ -0,0 +1,13 @@
+module.exports = octokitRestApiEndpoints
+
+const ROUTES = require('./routes.json')
+
+function octokitRestApiEndpoints (octokit) {
+  // Aliasing scopes for backward compatibility
+  // See https://github.com/octokit/rest.js/pull/1134
+  ROUTES.gitdata = ROUTES.git
+  ROUTES.authorization = ROUTES.oauthAuthorizations
+  ROUTES.pullRequests = ROUTES.pulls
+
+  octokit.registerEndpoints(ROUTES)
+}

node_modules/@octokit/rest/plugins/validate/index.js

@@ -0,0 +1,7 @@
+module.exports = octokitValidate
+
+const validate = require('./validate')
+
+function octokitValidate (octokit) {
+  octokit.hook.before('request', validate.bind(null, octokit))
+}

node_modules/@octokit/rest/plugins/validate/validate.js

@@ -0,0 +1,113 @@
+'use strict'
+
+module.exports = validate
+
+const { RequestError } = require('@octokit/request-error')
+const get = require('lodash.get')
+const set = require('lodash.set')
+
+function validate (octokit, options) {
+  if (!options.request.validate) {
+    return
+  }
+  const { validate: params } = options.request
+
+  Object.keys(params).forEach(parameterName => {
+    const parameter = get(params, parameterName)
+
+    const expectedType = parameter.type
+    let parentParameterName
+    let parentValue
+    let parentParamIsPresent = true
+    let parentParameterIsArray = false
+
+    if (/\./.test(parameterName)) {
+      parentParameterName = parameterName.replace(/\.[^.]+$/, '')
+      parentParameterIsArray = parentParameterName.slice(-2) === '[]'
+      if (parentParameterIsArray) {
+        parentParameterName = parentParameterName.slice(0, -2)
+      }
+      parentValue = get(options, parentParameterName)
+      parentParamIsPresent = parentParameterName === 'headers' || (typeof parentValue === 'object' && parentValue !== null)
+    }
+
+    const values = parentParameterIsArray
+      ? (get(options, parentParameterName) || []).map(value => value[parameterName.split(/\./).pop()])
+      : [get(options, parameterName)]
+
+    values.forEach((value, i) => {
+      const valueIsPresent = typeof value !== 'undefined'
+      const valueIsNull = value === null
+      const currentParameterName = parentParameterIsArray
+        ? parameterName.replace(/\[\]/, `[${i}]`)
+        : parameterName
+
+      if (!parameter.required && !valueIsPresent) {
+        return
+      }
+
+      // if the parent parameter is of type object but allows null
+      // then the child parameters can be ignored
+      if (!parentParamIsPresent) {
+        return
+      }
+
+      if (parameter.allowNull && valueIsNull) {
+        return
+      }
+
+      if (!parameter.allowNull && valueIsNull) {
+        throw new RequestError(`'${currentParameterName}' cannot be null`, 400, {
+          request: options
+        })
+      }
+
+      if (parameter.required && !valueIsPresent) {
+        throw new RequestError(`Empty value for parameter '${currentParameterName}': ${JSON.stringify(value)}`, 400, {
+          request: options
+        })
+      }
+
+      // parse to integer before checking for enum
+      // so that string "1" will match enum with number 1
+      if (expectedType === 'integer') {
+        const unparsedValue = value
+        value = parseInt(value, 10)
+        if (isNaN(value)) {
+          throw new RequestError(`Invalid value for parameter '${currentParameterName}': ${JSON.stringify(unparsedValue)} is NaN`, 400, {
+            request: options
+          })
+        }
+      }
+
+      if (parameter.enum && parameter.enum.indexOf(value) === -1) {
+        throw new RequestError(`Invalid value for parameter '${currentParameterName}': ${JSON.stringify(value)}`, 400, {
+          request: options
+        })
+      }
+
+      if (parameter.validation) {
+        const regex = new RegExp(parameter.validation)
+        if (!regex.test(value)) {
+          throw new RequestError(`Invalid value for parameter '${currentParameterName}': ${JSON.stringify(value)}`, 400, {
+            request: options
+          })
+        }
+      }
+
+      if (expectedType === 'object' && typeof value === 'string') {
+        try {
+          value = JSON.parse(value)
+        } catch (exception) {
+          throw new RequestError(`JSON parse error of value for parameter '${currentParameterName}': ${JSON.stringify(value)}`, 400, {
+            request: options
+          })
+        }
+      }
+
+      set(options, parameter.mapTo || currentParameterName, value)
+    })
+  })
+
+  return options
+}