!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.swaggerAjaxClient=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
// shim for using process in browser

var process = module.exports = {};

process.nextTick = (function () {
    var canSetImmediate = typeof window !== 'undefined'
    && window.setImmediate;
    var canPost = typeof window !== 'undefined'
    && window.postMessage && window.addEventListener
    ;

    if (canSetImmediate) {
        return function (f) { return window.setImmediate(f) };
    }

    if (canPost) {
        var queue = [];
        window.addEventListener('message', function (ev) {
            var source = ev.source;
            if ((source === window || source === null) && ev.data === 'process-tick') {
                ev.stopPropagation();
                if (queue.length > 0) {
                    var fn = queue.shift();
                    fn();
                }
            }
        }, true);

        return function nextTick(fn) {
            queue.push(fn);
            window.postMessage('process-tick', '*');
        };
    }

    return function nextTick(fn) {
        setTimeout(fn, 0);
    };
})();

process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;

process.binding = function (name) {
    throw new Error('process.binding is not supported');
}

// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};

},{}],2:[function(_dereq_,module,exports){
"use strict";
var Promise = _dereq_("./promise/promise").Promise;
var polyfill = _dereq_("./promise/polyfill").polyfill;
exports.Promise = Promise;
exports.polyfill = polyfill;
},{"./promise/polyfill":6,"./promise/promise":7}],3:[function(_dereq_,module,exports){
"use strict";
/* global toString */

var isArray = _dereq_("./utils").isArray;
var isFunction = _dereq_("./utils").isFunction;

/**
  Returns a promise that is fulfilled when all the given promises have been
  fulfilled, or rejected if any of them become rejected. The return promise
  is fulfilled with an array that gives all the values in the order they were
  passed in the `promises` array argument.

  Example:

  ```javascript
  var promise1 = RSVP.resolve(1);
  var promise2 = RSVP.resolve(2);
  var promise3 = RSVP.resolve(3);
  var promises = [ promise1, promise2, promise3 ];

  RSVP.all(promises).then(function(array){
    // The array here would be [ 1, 2, 3 ];
  });
  ```

  If any of the `promises` given to `RSVP.all` are rejected, the first promise
  that is rejected will be given as an argument to the returned promises's
  rejection handler. For example:

  Example:

  ```javascript
  var promise1 = RSVP.resolve(1);
  var promise2 = RSVP.reject(new Error("2"));
  var promise3 = RSVP.reject(new Error("3"));
  var promises = [ promise1, promise2, promise3 ];

  RSVP.all(promises).then(function(array){
    // Code here never runs because there are rejected promises!
  }, function(error) {
    // error.message === "2"
  });
  ```

  @method all
  @for RSVP
  @param {Array} promises
  @param {String} label
  @return {Promise} promise that is fulfilled when all `promises` have been
  fulfilled, or rejected if any of them become rejected.
*/
function all(promises) {
  /*jshint validthis:true */
  var Promise = this;

  if (!isArray(promises)) {
    throw new TypeError('You must pass an array to all.');
  }

  return new Promise(function(resolve, reject) {
    var results = [], remaining = promises.length,
    promise;

    if (remaining === 0) {
      resolve([]);
    }

    function resolver(index) {
      return function(value) {
        resolveAll(index, value);
      };
    }

    function resolveAll(index, value) {
      results[index] = value;
      if (--remaining === 0) {
        resolve(results);
      }
    }

    for (var i = 0; i < promises.length; i++) {
      promise = promises[i];

      if (promise && isFunction(promise.then)) {
        promise.then(resolver(i), reject);
      } else {
        resolveAll(i, promise);
      }
    }
  });
}

exports.all = all;
},{"./utils":11}],4:[function(_dereq_,module,exports){
(function (process,global){
"use strict";
var browserGlobal = (typeof window !== 'undefined') ? window : {};
var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
var local = (typeof global !== 'undefined') ? global : (this === undefined? window:this);

// node
function useNextTick() {
  return function() {
    process.nextTick(flush);
  };
}

function useMutationObserver() {
  var iterations = 0;
  var observer = new BrowserMutationObserver(flush);
  var node = document.createTextNode('');
  observer.observe(node, { characterData: true });

  return function() {
    node.data = (iterations = ++iterations % 2);
  };
}

function useSetTimeout() {
  return function() {
    local.setTimeout(flush, 1);
  };
}

var queue = [];
function flush() {
  for (var i = 0; i < queue.length; i++) {
    var tuple = queue[i];
    var callback = tuple[0], arg = tuple[1];
    callback(arg);
  }
  queue = [];
}

var scheduleFlush;

// Decide what async method to use to triggering processing of queued callbacks:
if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
  scheduleFlush = useNextTick();
} else if (BrowserMutationObserver) {
  scheduleFlush = useMutationObserver();
} else {
  scheduleFlush = useSetTimeout();
}

function asap(callback, arg) {
  var length = queue.push([callback, arg]);
  if (length === 1) {
    // If length is 1, that means that we need to schedule an async flush.
    // If additional callbacks are queued before the queue is flushed, they
    // will be processed by this flush that we are scheduling.
    scheduleFlush();
  }
}

exports.asap = asap;
}).call(this,_dereq_("0yPD3/"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"0yPD3/":1}],5:[function(_dereq_,module,exports){
"use strict";
var config = {
  instrument: false
};

function configure(name, value) {
  if (arguments.length === 2) {
    config[name] = value;
  } else {
    return config[name];
  }
}

exports.config = config;
exports.configure = configure;
},{}],6:[function(_dereq_,module,exports){
(function (global){
"use strict";
/*global self*/
var RSVPPromise = _dereq_("./promise").Promise;
var isFunction = _dereq_("./utils").isFunction;

function polyfill() {
  var local;

  if (typeof global !== 'undefined') {
    local = global;
  } else if (typeof window !== 'undefined' && window.document) {
    local = window;
  } else {
    local = self;
  }

  var es6PromiseSupport = 
    "Promise" in local &&
    // Some of these methods are missing from
    // Firefox/Chrome experimental implementations
    "resolve" in local.Promise &&
    "reject" in local.Promise &&
    "all" in local.Promise &&
    "race" in local.Promise &&
    // Older version of the spec had a resolver object
    // as the arg rather than a function
    (function() {
      var resolve;
      new local.Promise(function(r) { resolve = r; });
      return isFunction(resolve);
    }());

  if (!es6PromiseSupport) {
    local.Promise = RSVPPromise;
  }
}

exports.polyfill = polyfill;
}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./promise":7,"./utils":11}],7:[function(_dereq_,module,exports){
"use strict";
var config = _dereq_("./config").config;
var configure = _dereq_("./config").configure;
var objectOrFunction = _dereq_("./utils").objectOrFunction;
var isFunction = _dereq_("./utils").isFunction;
var now = _dereq_("./utils").now;
var all = _dereq_("./all").all;
var race = _dereq_("./race").race;
var staticResolve = _dereq_("./resolve").resolve;
var staticReject = _dereq_("./reject").reject;
var asap = _dereq_("./asap").asap;

var counter = 0;

config.async = asap; // default async is asap;

function Promise(resolver) {
  if (!isFunction(resolver)) {
    throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
  }

  if (!(this instanceof Promise)) {
    throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
  }

  this._subscribers = [];

  invokeResolver(resolver, this);
}

function invokeResolver(resolver, promise) {
  function resolvePromise(value) {
    resolve(promise, value);
  }

  function rejectPromise(reason) {
    reject(promise, reason);
  }

  try {
    resolver(resolvePromise, rejectPromise);
  } catch(e) {
    rejectPromise(e);
  }
}

function invokeCallback(settled, promise, callback, detail) {
  var hasCallback = isFunction(callback),
      value, error, succeeded, failed;

  if (hasCallback) {
    try {
      value = callback(detail);
      succeeded = true;
    } catch(e) {
      failed = true;
      error = e;
    }
  } else {
    value = detail;
    succeeded = true;
  }

  if (handleThenable(promise, value)) {
    return;
  } else if (hasCallback && succeeded) {
    resolve(promise, value);
  } else if (failed) {
    reject(promise, error);
  } else if (settled === FULFILLED) {
    resolve(promise, value);
  } else if (settled === REJECTED) {
    reject(promise, value);
  }
}

var PENDING   = void 0;
var SEALED    = 0;
var FULFILLED = 1;
var REJECTED  = 2;

function subscribe(parent, child, onFulfillment, onRejection) {
  var subscribers = parent._subscribers;
  var length = subscribers.length;

  subscribers[length] = child;
  subscribers[length + FULFILLED] = onFulfillment;
  subscribers[length + REJECTED]  = onRejection;
}

function publish(promise, settled) {
  var child, callback, subscribers = promise._subscribers, detail = promise._detail;

  for (var i = 0; i < subscribers.length; i += 3) {
    child = subscribers[i];
    callback = subscribers[i + settled];

    invokeCallback(settled, child, callback, detail);
  }

  promise._subscribers = null;
}

Promise.prototype = {
  constructor: Promise,

  _state: undefined,
  _detail: undefined,
  _subscribers: undefined,

  then: function(onFulfillment, onRejection) {
    var promise = this;

    var thenPromise = new this.constructor(function() {});

    if (this._state) {
      var callbacks = arguments;
      config.async(function invokePromiseCallback() {
        invokeCallback(promise._state, thenPromise, callbacks[promise._state - 1], promise._detail);
      });
    } else {
      subscribe(this, thenPromise, onFulfillment, onRejection);
    }

    return thenPromise;
  },

  'catch': function(onRejection) {
    return this.then(null, onRejection);
  }
};

Promise.all = all;
Promise.race = race;
Promise.resolve = staticResolve;
Promise.reject = staticReject;

function handleThenable(promise, value) {
  var then = null,
  resolved;

  try {
    if (promise === value) {
      throw new TypeError("A promises callback cannot return that same promise.");
    }

    if (objectOrFunction(value)) {
      then = value.then;

      if (isFunction(then)) {
        then.call(value, function(val) {
          if (resolved) { return true; }
          resolved = true;

          if (value !== val) {
            resolve(promise, val);
          } else {
            fulfill(promise, val);
          }
        }, function(val) {
          if (resolved) { return true; }
          resolved = true;

          reject(promise, val);
        });

        return true;
      }
    }
  } catch (error) {
    if (resolved) { return true; }
    reject(promise, error);
    return true;
  }

  return false;
}

function resolve(promise, value) {
  if (promise === value) {
    fulfill(promise, value);
  } else if (!handleThenable(promise, value)) {
    fulfill(promise, value);
  }
}

function fulfill(promise, value) {
  if (promise._state !== PENDING) { return; }
  promise._state = SEALED;
  promise._detail = value;

  config.async(publishFulfillment, promise);
}

function reject(promise, reason) {
  if (promise._state !== PENDING) { return; }
  promise._state = SEALED;
  promise._detail = reason;

  config.async(publishRejection, promise);
}

function publishFulfillment(promise) {
  publish(promise, promise._state = FULFILLED);
}

function publishRejection(promise) {
  publish(promise, promise._state = REJECTED);
}

exports.Promise = Promise;
},{"./all":3,"./asap":4,"./config":5,"./race":8,"./reject":9,"./resolve":10,"./utils":11}],8:[function(_dereq_,module,exports){
"use strict";
/* global toString */
var isArray = _dereq_("./utils").isArray;

/**
  `RSVP.race` allows you to watch a series of promises and act as soon as the
  first promise given to the `promises` argument fulfills or rejects.

  Example:

  ```javascript
  var promise1 = new RSVP.Promise(function(resolve, reject){
    setTimeout(function(){
      resolve("promise 1");
    }, 200);
  });

  var promise2 = new RSVP.Promise(function(resolve, reject){
    setTimeout(function(){
      resolve("promise 2");
    }, 100);
  });

  RSVP.race([promise1, promise2]).then(function(result){
    // result === "promise 2" because it was resolved before promise1
    // was resolved.
  });
  ```

  `RSVP.race` is deterministic in that only the state of the first completed
  promise matters. For example, even if other promises given to the `promises`
  array argument are resolved, but the first completed promise has become
  rejected before the other promises became fulfilled, the returned promise
  will become rejected:

  ```javascript
  var promise1 = new RSVP.Promise(function(resolve, reject){
    setTimeout(function(){
      resolve("promise 1");
    }, 200);
  });

  var promise2 = new RSVP.Promise(function(resolve, reject){
    setTimeout(function(){
      reject(new Error("promise 2"));
    }, 100);
  });

  RSVP.race([promise1, promise2]).then(function(result){
    // Code here never runs because there are rejected promises!
  }, function(reason){
    // reason.message === "promise2" because promise 2 became rejected before
    // promise 1 became fulfilled
  });
  ```

  @method race
  @for RSVP
  @param {Array} promises array of promises to observe
  @param {String} label optional string for describing the promise returned.
  Useful for tooling.
  @return {Promise} a promise that becomes fulfilled with the value the first
  completed promises is resolved with if the first completed promise was
  fulfilled, or rejected with the reason that the first completed promise
  was rejected with.
*/
function race(promises) {
  /*jshint validthis:true */
  var Promise = this;

  if (!isArray(promises)) {
    throw new TypeError('You must pass an array to race.');
  }
  return new Promise(function(resolve, reject) {
    var results = [], promise;

    for (var i = 0; i < promises.length; i++) {
      promise = promises[i];

      if (promise && typeof promise.then === 'function') {
        promise.then(resolve, reject);
      } else {
        resolve(promise);
      }
    }
  });
}

exports.race = race;
},{"./utils":11}],9:[function(_dereq_,module,exports){
"use strict";
/**
  `RSVP.reject` returns a promise that will become rejected with the passed
  `reason`. `RSVP.reject` is essentially shorthand for the following:

  ```javascript
  var promise = new RSVP.Promise(function(resolve, reject){
    reject(new Error('WHOOPS'));
  });

  promise.then(function(value){
    // Code here doesn't run because the promise is rejected!
  }, function(reason){
    // reason.message === 'WHOOPS'
  });
  ```

  Instead of writing the above, your code now simply becomes the following:

  ```javascript
  var promise = RSVP.reject(new Error('WHOOPS'));

  promise.then(function(value){
    // Code here doesn't run because the promise is rejected!
  }, function(reason){
    // reason.message === 'WHOOPS'
  });
  ```

  @method reject
  @for RSVP
  @param {Any} reason value that the returned promise will be rejected with.
  @param {String} label optional string for identifying the returned promise.
  Useful for tooling.
  @return {Promise} a promise that will become rejected with the given
  `reason`.
*/
function reject(reason) {
  /*jshint validthis:true */
  var Promise = this;

  return new Promise(function (resolve, reject) {
    reject(reason);
  });
}

exports.reject = reject;
},{}],10:[function(_dereq_,module,exports){
"use strict";
function resolve(value) {
  /*jshint validthis:true */
  if (value && typeof value === 'object' && value.constructor === this) {
    return value;
  }

  var Promise = this;

  return new Promise(function(resolve) {
    resolve(value);
  });
}

exports.resolve = resolve;
},{}],11:[function(_dereq_,module,exports){
"use strict";
function objectOrFunction(x) {
  return isFunction(x) || (typeof x === "object" && x !== null);
}

function isFunction(x) {
  return typeof x === "function";
}

function isArray(x) {
  return Object.prototype.toString.call(x) === "[object Array]";
}

// Date.now is not available in browsers < IE9
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
var now = Date.now || function() { return new Date().getTime(); };


exports.objectOrFunction = objectOrFunction;
exports.isFunction = isFunction;
exports.isArray = isArray;
exports.now = now;
},{}],12:[function(_dereq_,module,exports){
module.exports = _dereq_('./src/createClient');
},{"./src/createClient":21}],13:[function(_dereq_,module,exports){
'use strict';

function DataTypeValidationError(message){
  this.name = 'DataTypeValidationError';
  this.message = message || 'Invalid data type';
}
DataTypeValidationError.prototype = Object.create(Error.prototype);
DataTypeValidationError.prototype.constructor = DataTypeValidationError;
exports.DataTypeValidationError = DataTypeValidationError;

function NotAnIntegerError(value){
  this.name = 'NotAnIntegerError';
  this.message = '"' + value + '" is not an integer';
  this.value = value;
}
NotAnIntegerError.prototype = Object.create(DataTypeValidationError.prototype);
NotAnIntegerError.prototype.constructor = NotAnIntegerError;
exports.NotAnIntegerError = NotAnIntegerError;

function NotANumberError(value, actualType){
  this.name = 'NotANumberError';
  this.message = '"' + value + '" is not a number';
  if(actualType) this.message += ' (got a ' + actualType + ' instead)';

  this.value = value;
}
NotANumberError.prototype = Object.create(DataTypeValidationError.prototype);
NotANumberError.prototype.constructor = NotANumberError;
exports.NotANumberError = NotANumberError;

function NumberTooLargeError(value, max){
  this.name = 'NumberTooLargeError';
  this.message = '"' + value + '" is above the maximum of ' + max.toString();
  this.value = value;
}
NumberTooLargeError.prototype = Object.create(DataTypeValidationError.prototype);
NumberTooLargeError.prototype.constructor = NumberTooLargeError;
exports.NumberTooLargeError = NumberTooLargeError;

function NumberTooSmallError(value, max){
  this.name = 'NumberTooSmallError';
  this.message = '"' + value + '" is above the maximum of ' + max.toString();
  this.value = value;
}
NumberTooSmallError.prototype = Object.create(DataTypeValidationError.prototype);
NumberTooSmallError.prototype.constructor = NumberTooSmallError;
exports.NumberTooSmallError = NumberTooSmallError;

function NotABooleanError(value, actualType){
  this.name = 'NotABooleanError';
  this.message = '"' + value + '" is not a boolean';
  if(actualType) this.message += ' (got a ' + actualType + ' instead)';

  this.value = value;
}
NotABooleanError.prototype = Object.create(DataTypeValidationError.prototype);
NotABooleanError.prototype.constructor = NotABooleanError;
exports.NotABooleanError = NotABooleanError;

function NotAnArrayError(value, actualType){
  this.name = 'NotAnArrayError';
  this.message = '"' + value + '" is not an array';
  if(actualType) this.message += ' (got a ' + actualType + ' instead)';

  this.value = value;
}
NotAnArrayError.prototype = Object.create(DataTypeValidationError.prototype);
NotAnArrayError.prototype.constructor = NotAnArrayError;
exports.NotAnArrayError = NotAnArrayError;

function DuplicateInSetError(arr, dupes){
  this.name = 'DuplicateInSetError';
  this.message = 'Duplicates ("' + dupes.join('", "') + '") found in set: ["' + arr.join('", "') + '"';
  this.dupes = dupes;
  this.value = arr;
}
DuplicateInSetError.prototype = Object.create(DataTypeValidationError.prototype);
DuplicateInSetError.prototype.constructor = DuplicateInSetError;
exports.DuplicateInSetError = DuplicateInSetError;

function NotVoidError(value, actualType){
  this.name = 'NotVoidError';
  this.message = '"' + value + '" is not null or undefined';
  if(actualType) this.message += ' (got a ' + actualType + ' instead)';

  this.value = value;
}
NotVoidError.prototype = Object.create(DataTypeValidationError.prototype);
NotVoidError.prototype.constructor = NotVoidError;
exports.NotVoidError = NotVoidError;

function NotAStringError(value, actualType){
  this.name = 'NotAStringError';
  this.message = '"' + value + '" is not a string';
  if(actualType) this.message += ' (got a ' + actualType + ' instead)';

  this.value = value;
}
NotAStringError.prototype = Object.create(DataTypeValidationError.prototype);
NotAStringError.prototype.constructor = NotAStringError;
exports.NotAStringError = NotAStringError;

function StringNotInEnumError(value, acceptableValues){
  this.name = 'StringNotInEnumError';
  this.message = '"' + value + '" is not an acceptable value: "' + acceptableValues.join('", "') + '"';
 
  this.value = value;
}
StringNotInEnumError.prototype = Object.create(DataTypeValidationError.prototype);
StringNotInEnumError.prototype.constructor = StringNotInEnumError;
exports.StringNotInEnumError = StringNotInEnumError;


function ErrorsInArrayElementsError(errors){
  this.name = 'ErrorsInArrayElementsError';
  this.message = 'Errors in array elements:\n\t' + errors.join(',\n\t');
  this.errors = errors;
}
ErrorsInArrayElementsError.prototype = Object.create(DataTypeValidationError.prototype);
ErrorsInArrayElementsError.prototype.constructor = ErrorsInArrayElementsError;
exports.ErrorsInArrayElementsError = ErrorsInArrayElementsError;

function MissingValueError(){
  this.name = 'MissingValueError';
  
  this.message = 'This value is required but missing';
}
MissingValueError.prototype = Object.create(DataTypeValidationError.prototype);
MissingValueError.prototype.constructor = MissingValueError;
exports.MissingValueError = MissingValueError;

function ValidationError(specName, spec, error){
  this.name = 'ValidationError';
  this.specName = specName;
  this.spec = spec;
  this.error = error;

  this.message = specName + ' is invalid: ' + error.message;
}
ValidationError.prototype = Object.create(DataTypeValidationError.prototype);
ValidationError.prototype.constructor = ValidationError;
exports.ValidationError = ValidationError;

function ValidationErrors(value, specName, spec, errors){
  this.name = 'ValidationErrors';

  this.value = value;
  this.specName = specName;
  this.spec = spec;
  this.errors = errors || [];

  this.message = specName + ' is invalid';

  if(this.errors.length){
    this.message += ':\n\t' + this.errors.map(function(e){ return e.message; }).join('\n\t');
  }
}
ValidationErrors.prototype = Object.create(DataTypeValidationError.prototype);
ValidationErrors.prototype.constructor = ValidationErrors;
exports.ValidationErrors = ValidationErrors;

},{}],14:[function(_dereq_,module,exports){
exports.dataType = _dereq_('./validateDataType');
exports.model = _dereq_('./validateModel');
exports.operation = _dereq_('./validateOperation');
exports.array = _dereq_('./validateArray');
exports.errors = _dereq_('./errorTypes');

var primitives = _dereq_('./validatePrimitiveTypes');
exports.primitive = {
  integer: primitives.validateInteger,
  number: primitives.validateNumber,
  string: primitives.validateString,
  boolean: primitives.validateBoolean,
  void: primitives.validateVoid,
  file: primitives.validateFile
};

},{"./errorTypes":13,"./validateArray":15,"./validateDataType":16,"./validateModel":17,"./validateOperation":18,"./validatePrimitiveTypes":19}],15:[function(_dereq_,module,exports){
'use strict';

var errorTypes = _dereq_('./errorTypes'),
  validate = _dereq_('./index');

function validateArray(candidate, dataType, models){
  if(!Array.isArray(candidate)){
    return new errorTypes.NotAnArrayError(candidate, typeof candidate);
  }

  var items = dataType.items;

  if(dataType.uniqueItems){
    var dupeCheck = [];
    var dupes = candidate.filter(function(value){
      var signature;
      if(items.$ref){
        signature = JSON.stringify(value);
      } else {
        signature = value;
      }
      if(dupeCheck.indexOf(signature) !== -1){
        return true;
      } else {
        dupeCheck.push(signature);
        return false;
      }
    });

    if(dupes.length) {
      return new errorTypes.DuplicateInSetError(candidate, dupes);
    }
  }

  var errors;

  if(items.$ref){
    var model = models[items.$ref];
    errors = candidate.filter(function(value){
      return validate.model(value, model, models);
    });
  } else {
    errors = candidate.filter(function(value){
      return validate.dataType(value, items, models);
    });
  }

  if(errors.length){
    return new errorTypes.ErrorsInArrayElementsError(errors);
  }
}
module.exports = validateArray;
},{"./errorTypes":13,"./index":14}],16:[function(_dereq_,module,exports){
'use strict';

var validate = _dereq_('./index');
  
function validateDataType(candidate, dataType, models){
  models = models || {};
      
  var type = dataType.type || dataType.dataType || dataType.$ref;

  switch(type){
    case 'integer':
      return validate.primitive.integer(candidate, dataType);
    case 'number':
      return validate.primitive.number(candidate, dataType);
    case 'string':
      return validate.primitive.string(candidate, dataType);
    case 'boolean':
      return validate.primitive.boolean(candidate);
    case 'array':
      return validate.array(candidate, dataType, models);
    case 'void':
      return validate.primitive.void(candidate);
    case 'File':
      return validate.primitive.file();
    default:
      // Assumed to be complex model
      var model = models[type];
      return validate.model(candidate, model, models);
  }
}
module.exports = validateDataType;
},{"./index":14}],17:[function(_dereq_,module,exports){
'use strict';

var errorTypes = _dereq_('./errorTypes'),
  ValidationError = errorTypes.ValidationError,
  ValidationErrors = errorTypes.ValidationErrors,
  MissingValueError = errorTypes.MissingValueError,
  validate = _dereq_('./index');

// http://stackoverflow.com/questions/122102/what-is-the-most-efficient-way-to-clone-an-object
function clone(obj){
    if(obj === null || obj === undefined || typeof obj !== 'object') return obj;

    if(Array.isArray(obj)) return obj.slice();

    var temp = {};

    for(var key in obj)
        temp[key] = clone(obj[key]);
    return temp;
}

function addInhertiedProperties(model, modelId, models){
  var parent;

  Object.keys(models).some(function(modelName){
    var potentialParent = models[modelName];
    if (!potentialParent.subTypes) return;

    if(potentialParent.subTypes.indexOf(modelId) !== -1){
      parent = potentialParent;
      return true;
    }
  });

  if(!parent) return;

  for(var propertyName in parent.properties){
    model.properties[propertyName] = parent.properties[propertyName];
  }
  
  if(parent.required) model.required = model.required.concat(parent.required);

  addInhertiedProperties(model, parent.id, models);
}

function validateModel(candidate, model, models){
  if(candidate === null || typeof candidate !== 'object'){
    return new ValidationErrors(candidate, model);
  }

  models = models || {};

  model = clone(model);
  if(!model.required) model.required = [];
  addInhertiedProperties(model, model.id, models);

  var errors = [];

  model.required.forEach(function(propertyName){
    if (candidate[propertyName] !== undefined) return;

    var property = model.properties[propertyName];
    var error = new MissingValueError();
    errors.push(new ValidationError(propertyName, property, error));
  });

  Object.keys(candidate).forEach(function(propertyName){
    var property = model.properties[propertyName];
    
    if(property === undefined) return;

    var error = validate.dataType(candidate[propertyName], property, models);
    if(error){
      errors.push(new ValidationError(propertyName, property, error));
    }
  });
  
  if(errors.length){
    return new ValidationErrors(candidate, model.id, model, errors);
  }
}
module.exports = validateModel;
},{"./errorTypes":13,"./index":14}],18:[function(_dereq_,module,exports){
'use strict';

var errorTypes = _dereq_('./errorTypes'),
  ValidationError = errorTypes.ValidationError,
  ValidationErrors = errorTypes.ValidationErrors,
  MissingValueError = errorTypes.MissingValueError,
  validate = _dereq_('./index');

function validateOperation(candidate, operation, models){
  var errors = [];
  
  var presentParams = operation.parameters.filter(function(param){
    if (candidate[param.name] !== undefined) return true;
    
    if (param.required) {
      var error = new MissingValueError();
      errors.push(new ValidationError(param.name, param, error));
    }

    return false;
  });

  presentParams.forEach(function(param){
    var error = validate.dataType(candidate[param.name], param, models);
    if(error){
      errors.push(new ValidationError(param.name, param, error));
    }
  });
  
  if(errors.length){
    return new ValidationErrors(candidate, operation.nickname, operation, errors);
  }
}
module.exports = validateOperation;
},{"./errorTypes":13,"./index":14}],19:[function(_dereq_,module,exports){
'use strict';

var errorTypes = _dereq_('./errorTypes');

function validateInteger(candidate, dataType){
  var error = validateNumber(candidate, dataType);
  if(error) return error;

  if(candidate % 1){
    return new errorTypes.NotAnIntegerError(candidate);
  }
}
exports.validateInteger = validateInteger;

function validateNumber(candidate, dataType){
  if(!(typeof candidate === 'number' || candidate instanceof Number) || isNaN(candidate)){
    return new errorTypes.NotANumberError(candidate, typeof candidate);
  }
  
  if((dataType.minimum !== undefined) && candidate < parseInt(dataType.minimum, 10)){
    return new errorTypes.NumberTooSmallError(candidate, dataType.minimum);
  }
  
  if((dataType.maximum !== undefined) && candidate > parseInt(dataType.maximum, 10)){
    return new errorTypes.NumberTooLargeError(candidate, dataType.maximum);
  }
}
exports.validateNumber = validateNumber;

function validateBoolean(candidate){
  if(!(typeof candidate === 'boolean' || candidate instanceof Boolean)){
    return new errorTypes.NotABooleanError(candidate, typeof candidate);
  }
}
exports.validateBoolean = validateBoolean;


function validateVoid(candidate){
  if(candidate != null){
    return new errorTypes.NotVoidError(candidate, typeof candidate);
  }
}
exports.validateVoid = validateVoid;

function validateFile(){
  // Not sure how to check this, since anything could qualify as 'File'.
}
exports.validateFile = validateFile;

function validateString(candidate, dataType){
  if(typeof candidate !== 'string' && !(candidate instanceof String)){
    return new errorTypes.NotAStringError(candidate, typeof candidate);
  }

  if('enum' in dataType){
    if(dataType.enum.indexOf(candidate) === -1) {
      return new errorTypes.StringNotInEnumError(candidate, dataType.enum);
    }
  }
}
exports.validateString = validateString;
},{"./errorTypes":13}],20:[function(_dereq_,module,exports){
'use strict';

var MissingAuthorizationError = _dereq_('./errorTypes').MissingAuthorizationError;

module.exports = function applyAuthData(operation, authData, request){
  var authMap = operation.authorizations;
  if(!authMap) authMap = operation.apiObject.apiDeclaration.authorizations;
  if(!authMap) return;

  var authNames = Object.keys(authMap).filter(function(authName){
    // Currently unable to handle oauth2
    return authMap[authName].type !== 'oauth2';
  });

  if(authNames.length === 0) return;

  if(authNames.length === 1){
    var authName = authNames[0];
    var auth = authMap[authName];

    if(!authData) throw new MissingAuthorizationError(authName, auth);

    // Unpack nested authData for single auth ops: { apiKey: '123' } -> '123'
    if(authData[authName]) authData = authData[authName];

    if(auth.type === 'apiKey'){
      applyApiKey(auth, authName, authData, request);
    } else if(auth.type === 'basicAuth') {
      applyBasicAuth(auth, authName, authData.username, authData.password, request);
    }
  } else {
    var hasAuth = authNames.some(function(authName){
      var auth = authMap[authName];
      var data = authData[authName];

      if(!data) return false;

      if(auth.type === 'apiKey'){
        applyApiKey(auth, authName, data, request);
      } else if(auth.type === 'basicAuth'){
        applyBasicAuth(auth, authName, data.username, data.password, request);
      }

      return true;
    });

    if(!hasAuth){
      throw new MissingAuthorizationError(authNames.join(', '), authMap);
    }
  }
};

function applyApiKey(auth, authName, apiKey, request){
  if(!apiKey) throw new MissingAuthorizationError(authName, auth);
  
  if(auth.passAs === 'header'){
    request.headers[auth.keyname] = apiKey;
  } else if(auth.passAs === 'query'){
    var url = request.url;
    var queryParam = auth.keyname + '=' + encodeURIComponent(apiKey);
    if(url.indexOf('?') === -1){
      url += '?' + queryParam;
    } else {
      url = url.replace('?', '?' + queryParam + '&');
    }

    request.url = url;
  }
}

function applyBasicAuth(auth, authName, username, password, request){
  if(!username || !password) throw new MissingAuthorizationError(authName, auth);
  
  var url = request.url;
  
  // Only add basic auth once
  if(url.indexOf('@') === -1){
    url = url.replace('://', '://' + username + ':' + password + '@');
  }

  request.url = url;
}
},{"./errorTypes":23}],21:[function(_dereq_,module,exports){
'use strict';

var createOperationHandler = _dereq_('./createOperationHandler');

function createClient(schema, requestHandler){
  var api = {},
    apiAuthData,
    authMethodName = 'auth';

  schema = processSchema(schema);
  
  // If the 'auth' key is used for any resource or operation, we'll use
  // 'authorization' instead for the auth methods
  var authIsInUse = schema.apis.some(function(resourceObject){
    return resourceObject.apiDeclaration.apis.some(function(apiObject){
      var resourceApiName = getApiName(apiObject.apiDeclaration.resourcePath || apiObject.path);
      if(resourceApiName === 'auth') return true;
      return apiObject.operations.some(function(operation){
        return operation.nickname === 'auth';
      });
    });
  });
  
  if(authIsInUse) authMethodName = 'authorization';

  api[authMethodName] = function(){
    apiAuthData = processApiAuthArgs(arguments);
  };

  schema.apis.forEach(function(resourceObject){
    var resourceName,
      resourceApi,
      resourceAuthData;

    if(resourceObject.apiDeclaration.resourcePath){
      resourceName = getApiName(resourceObject.apiDeclaration.resourcePath);
      resourceApi = api[resourceName] = {};
      resourceApi[authMethodName] = function(){
        resourceAuthData = processApiAuthArgs(arguments);
      };
    }

    resourceObject.apiDeclaration.apis.forEach(function(apiObject){
      var apiObjectName = resourceName,
        apiObjectApi = resourceApi,
        apiObjectAuthData;

      if(!apiObjectName){
        apiObjectName = getApiName(apiObject.path);
        apiObjectApi = api[apiObjectName] = {};
        apiObjectApi[authMethodName] = function(){
          apiObjectAuthData = processApiAuthArgs(arguments);
        };
      }

      apiObject.operations.forEach(function(operation){
        var operationHandlerName = operation.nickname,
          operationAuthData,
          operationHandler; 
        
        function getAuthData(){
          return operationAuthData || apiObjectAuthData || resourceAuthData || apiAuthData;
        }

        operationHandler = createOperationHandler(operation, getAuthData, requestHandler);

        operationHandler[authMethodName] = function(){
          operationAuthData = processApiAuthArgs(arguments);
        };

        apiObjectApi[operationHandlerName] = operationHandler;
      });
    });
  });

  return api;
}
module.exports = createClient;

function processApiAuthArgs(args){
  // for basic auth, allow calls with two args (username, password)
  if(typeof args[0] === 'string' && typeof args[1] === 'string') {
    return {
      username: args[0],
      password: args[1]
    };
  } else {
    return args[0];
  }
}

// Helpper method which assings back pointer to object parents and returns
// the api objects within the given schema.
function processSchema(schema){
  schema.apis.forEach(function(resourceObject){
    resourceObject.resourceListing = schema;

    resourceObject.apiDeclaration.apis.forEach(function(apiObject){
      apiObject.resourceObject = resourceObject;
      apiObject.apiDeclaration = resourceObject.apiDeclaration;

      apiObject.operations.forEach(function(operation){
        operation.apiObject = apiObject;

        operation.parameters.forEach(function(parameter){
          parameter.operation = operation;
        });
      });
    });
  });

  return schema;
}

// Takes a path and returns a JavaScript-friendly variable name
function getApiName(name){
  // String non-word characters
  name = name.replace(/\W/g, '/');

  // Turn paths which look/like/this to lookLikeThis
  name = name.replace(/(\w)\/(\w)/g, function(match, p1, p2){
    return p1 + p2.toUpperCase();
  });

  name = name.replace(/\//g, '');

  return name;
}
},{"./createOperationHandler":22}],22:[function(_dereq_,module,exports){
'use strict';

var getRequestHeaders = _dereq_('./getRequestHeaders'),
  getRequestUrl = _dereq_('./getRequestUrl'),
  getRequestBody = _dereq_('./getRequestBody'),
  applyAuthData = _dereq_('./applyAuthData'),
  errorTypes = _dereq_('./errorTypes'),
  swaggerValidate = _dereq_('swagger-validate');

var allErrorTypes = {};
Object.keys(swaggerValidate.errors).forEach(function(errorName){
  allErrorTypes[errorName] = swaggerValidate.errors[errorName];
});

Object.keys(errorTypes).forEach(function(errorName){
  allErrorTypes[errorName] = errorTypes[errorName];
});

function createOperationHandler(operation, getAuthData, requestHandler){
  function Request(data, options){
    this.method = operation.method;
    this.operation = operation;
    this.errorTypes = allErrorTypes;
    this.data = data;
    this.options = options;
  }

  var operationHandler = function(data, options){
    var error,
      request;
    
    options = options || {};
    
    if(data == null) data = {};

    // if a function is passed in as options, assume it's a callback function
    // for convenience
    if(typeof options === 'function'){
      options.callback = options;
    }

    try{
      data = prune(data);
      data = singleParamConvenienceProcessor(operation, data);
      data = removeUnknownParams(operation, data);

      error = swaggerValidate.operation(data, operation, operation.apiObject.apiDeclaration.models);
      
      request = new Request(data, options);
      
      // If we know there is an error, don't attempt to craft the request params.
      // The request param generators assume valid data to work properly.
      if(!error){
        request.url = getRequestUrl(operation, data);
        request.headers = getRequestHeaders(operation, data, options);
        request.body = getRequestBody(operation, data, request.headers);
        
        applyAuthData(operation, getAuthData(), request);
      }
    } catch(e){
      error = e;
    }
    
    return requestHandler(error, request);
  };

  // Useful for instanceof checks
  operationHandler.Request = Request;
  operationHandler.errorTypes = allErrorTypes;

  // Useful for reflection
  operationHandler.operation = operation;
  
  // Can be used to preemptively validate without action
  operationHandler.validate = function(data){
    return swaggerValidate.operation(data, operation, operation.apiObject.apiDeclaration.models);
  };

  return operationHandler;
}
module.exports = createOperationHandler;

function noop(){}
createOperationHandler.logger = {
  debug: noop,
  info: noop,
  warn: noop,
  error: noop
};

// Stringify and parse the data to clean up undefined, and non-scalar properties
function prune(data){
  return JSON.parse(JSON.stringify(data));
}

// Enables data to be passed directly for single param operations.
function singleParamConvenienceProcessor(operation, data){
  // If there are more than one params, bail
  var requiredParams = operation.parameters.filter(function(param){
    return param.required;
  });

  // If there are more than one required params, or if there is no required param
  // and there are many optional params, bail
  if(requiredParams.length > 1) return data;

  if(requiredParams.length !== 1 && operation.parameters.length !== 1) return data;

  var param = requiredParams[0] || operation.parameters[0];
  
  // If the param is already defined explicitly, bail
  if(typeof data === 'object' &&  data[param.name] !== undefined) return data;

  var models = operation.apiObject.apiDeclaration.models;

  // If the data passed is is not valid for the param data type, bail
  var error;

  try {
    error = swaggerValidate.dataType(data, param, models); 
  } catch(e){
    return data;
  }
  
  // If the data passed is a valid param data type, bail
  if(!error){
    var wrapper = {};
    wrapper[param.name] = data;
    return wrapper;
  } else {
    return data;
  }
}
 

function removeUnknownParams(operation, data){
  if(!data || typeof data !== 'object') return data;

  var paramNames = {};
  operation.parameters.forEach(function(param){
    paramNames[param.name] = true;
  });

  var unknownKeys = Object.keys(data).filter(function(key){
    return !(key in paramNames);
  });

  createOperationHandler.logger.warn('Unknown parameters removed from request:', 
    unknownKeys.join(', '));

  unknownKeys.forEach(function(key){
    delete data[key];
  });

  return data;
}
},{"./applyAuthData":20,"./errorTypes":23,"./getRequestBody":24,"./getRequestHeaders":25,"./getRequestUrl":26,"swagger-validate":14}],23:[function(_dereq_,module,exports){
'use strict';

function InvalidRequestError(message){
  this.name = 'InvalidRequestError';
  this.message = message || 'Invalid request';
}
InvalidRequestError.prototype = Object.create(Error.prototype);
InvalidRequestError.prototype.constructor = InvalidRequestError;

exports.InvalidRequestError = InvalidRequestError;


function MissingAuthorizationError(authName, auth){
  this.name = 'MissingAuthorizationError';
  this.message = 'No data found for authorization: ' + authName;
  this.authorization = auth;
}
MissingAuthorizationError.prototype = Object.create(InvalidRequestError.prototype);
MissingAuthorizationError.prototype.constructor = MissingAuthorizationError;

exports.MissingAuthorizationError = MissingAuthorizationError;


function MissingPathParamsError(pathParams){
  this.name = 'MissingPathParamsError';
  this.message = 'Missing the following required path parameters: ' + pathParams.join('');
}
MissingPathParamsError.prototype = Object.create(InvalidRequestError.prototype);
MissingPathParamsError.prototype.constructor = MissingPathParamsError;

exports.MissingPathParamsError = MissingPathParamsError;


function ContentTypeNotSupportedError(contentType, operation){
  var apiDeclaration = operation.apiObject.apiDeclaration;
  var consumes = operation.consumes || apiDeclaration.consumes || [];

  this.name = 'ContentTypeNotSupportedError';
  this.message = 'Operation [' + operation.nickname + '] does not accept ' + contentType + '. It supports: ' + 
    consumes.join(', ');
}
ContentTypeNotSupportedError.prototype = Object.create(InvalidRequestError.prototype);
ContentTypeNotSupportedError.prototype.constructor = ContentTypeNotSupportedError;

exports.ContentTypeNotSupportedError = ContentTypeNotSupportedError;


function AcceptsNotSupportedError(accepts, operation){
  var apiDeclaration = operation.apiObject.apiDeclaration;
  var produces = operation.produces || apiDeclaration.produces || [];

  this.name = 'AcceptsNotSupportedError';
  this.message = 'Operation [' + operation.nickname + '] does not produce ' + accepts + '. It supports: ' + 
    produces.join(', ');
}
AcceptsNotSupportedError.prototype = Object.create(InvalidRequestError.prototype);
AcceptsNotSupportedError.prototype.constructor = AcceptsNotSupportedError;

exports.AcceptsNotSupportedError = AcceptsNotSupportedError;


function OperationValidationError(operation, errors){
  this.name = 'OperationValidationError';
  this.message = operation.nickname + ' failed validation: \n\t' + errors.join('\n\t');
}
OperationValidationError.prototype = Object.create(InvalidRequestError.prototype);
OperationValidationError.prototype.constructor = OperationValidationError;

exports.OperationValidationError = OperationValidationError;


function ParameterValidationError(parameter, errors){
  this.name = 'ParameterValidationError';
  this.message = parameter.name + ' failed validation: \n\t' + errors.join('\n\t');
}
ParameterValidationError.prototype = Object.create(InvalidRequestError.prototype);
ParameterValidationError.prototype.constructor = ParameterValidationError;

exports.ParameterValidationError = ParameterValidationError;


function DataTypeValidationError(message){
  this.name = 'DataTypeValidationError';
  this.message = message || 'Invalid data type';
}
DataTypeValidationError.prototype = Object.create(Error.prototype);
DataTypeValidationError.prototype.constructor = DataTypeValidationError;

exports.DataTypeValidationError = DataTypeValidationError;
},{}],24:[function(_dereq_,module,exports){
'use strict';

module.exports = function getRequestBody(operation, data, headers){
  var body = operation.parameters.filter(function(param){
    return param.paramType === 'body' && data[param.name] != null;
  }).map(function(param){
    return data[param.name];
  })[0];

  if(!(headers &&  headers['Content-Type'])) return body;

  var contentType = headers['Content-Type'];
  var presentFormParams = operation.parameters.filter(function(param){
    return param.paramType === 'form' && data[param.name] != null;
  });

  if(contentType.indexOf('application/x-www-form-urlencoded') !== -1){
    body = presentFormParams.map(function(param){
      var key = param.name,
        value = data[key];
      return encodeURIComponent(key) + '=' + encodeURIComponent(value);
    }).join('&');
  } else if(contentType.indexOf('multipart/form-data') !== -1){
    var randomness = Math.random().toString(16).substr(2);
    var boundary = 'SwaggerBoundary' + randomness;
    
    body = presentFormParams.map(function(param){
      var key = param.name,
        value = data[key],
        result = '--' + boundary;

      result += '\nContent-Disposition: form-data; name="' + key + '"';
      
      if(value.contentType){
        if(value.name){
          result += '; filename="' + value.name + '"';
        }

        result += '\nContent-Type: ' + value.contentType;
      }

      if(value.contentTransferEncoding){
        result += '\nContent-Transfer-Encoding: ' + value.contentTransferEncoding;
      }

      if(value.body){
        result += '\n\n' + value.body;
      } else {
        result += '\n\n' + value;
      }

      return result;
    }).join('\n');

    body += '\n--' + boundary + '--\n';
    
    headers['Content-Type'] = contentType.replace(
      'multipart/form-data', 
      'multipart/form-data; boundary=' + boundary
    );
  } else if(contentType.indexOf('application/json') !== -1){
    if(typeof body !== 'string'){
      body = JSON.stringify(body);
    }
  }

  return body;
};
},{}],25:[function(_dereq_,module,exports){
'use strict';

var errorTypes = _dereq_('./errorTypes'),
  ContentTypeNotSupportedError = errorTypes.ContentTypeNotSupportedError,
  AcceptsNotSupportedError = errorTypes.AcceptsNotSupportedError;

var DEFAULT_ACCEPT = 'application/json';
module.exports = function getRequestHeaders(operation, data, options){
  data = data || {};
  options = options || {};

  var headers = {};

  operation.parameters.forEach(function(param){
    if(param.paramType === 'header' && data[param.name] != null){
      headers[param.name] = data[param.name];
    }
  });

  // Passed headers
  if(options.headers){
    Object.keys(options.headers).forEach(function(key){
      headers[key] = options.headers[key];
    });
  }

  // Content-Type
  var contentType = options.contentType || getContentType(operation, data, options);
  if(contentType) {
    if(hasAccept(operation, contentType)){
      headers['Content-Type'] = contentType;  
    } else {
      throw new ContentTypeNotSupportedError(contentType, operation);
    }
  }

  // Accept
  var accept = options.accept || DEFAULT_ACCEPT;
  if(accept){
    if(hasContentType(operation, accept)){
      headers.Accept = accept;  
    } else {
      throw new AcceptsNotSupportedError(accept, operation);
    }
  }
  
  return headers;
};

function getContentType(operation, data){
  var hasBody = operation.parameters.some(function(param){
    return param.paramType === 'body' && data[param.name] !== undefined;
  });

  if (hasBody){
    return 'application/json';
  } else {
    var hasFormParams = operation.parameters.some(function(param){
      return param.paramType === 'form' && data[param.name] !== undefined;
    });

    var hasFileParam = hasFormParams && 
      operation.parameters.some(function(param){
        return param.type === 'File' && data[param.name] !== undefined;
      });

    if(hasFileParam) return 'multipart/form-data';
    else if(hasFormParams) return 'application/x-www-form-urlencoded';
  }
}

// Accepts is an optional field in the spec, but must be enforced when present
function hasAccept(operation, contentType){
  var apiDeclaration = operation.apiObject.apiDeclaration;
  var accepts = operation.consumes || apiDeclaration.consumes;

  if(accepts && accepts.length){
    return accepts.indexOf(contentType) !== -1;
  } else {
    return true;
  }
}
exports.hasAccept = hasAccept;

// Content-Type (produces) is an optional field in the spec, but must be enforced when present
function hasContentType(operation, contentType){
  var apiDeclaration = operation.apiObject.apiDeclaration,
    contentTypes = operation.produces || apiDeclaration.produces;

  if(contentTypes && contentTypes.length){
    return contentTypes.indexOf(contentType) !== -1;
  } else {
    return true;
  }
}
exports.hasContentType = hasContentType;
},{"./errorTypes":23}],26:[function(_dereq_,module,exports){
'use strict';

var errorTypes = _dereq_('./errorTypes'),
  MissingPathParamsError = errorTypes.MissingPathParamsError;

module.exports = function getRequestUrl(operation, data){
  var url = getUrlTemplate(operation);

  url = applyPathParams(url, operation, data);

  if(!data) return url;

  var queryParams = operation.parameters.filter(function(param){
    return param.paramType === 'query' && data[param.name] !== undefined;
  }).map(function(param){
    var key = param.name;
    return encodeURIComponent(key) + '=' + encodeURIComponent(data[key]);
  }).join('&');

  if(queryParams) url += '?' + queryParams;

  return url;
};

function applyPathParams(url, operation, data){
  var pathParams = operation.parameters.filter(function(param){
    return param.paramType === 'path';
  });

  var missingParams = pathParams.filter(function(param){
    return data[param.name] === undefined;
  });

  if(missingParams.length){
    throw new MissingPathParamsError(missingParams.map(function(param){
      return param.name;
    }));
  }

  pathParams.forEach(function(param){
    var key = param.name;
    
    var exp = new RegExp('{' + key + '[^}]*}', 'gi');

    var value = data[key].toString();
    delete data[key];
    value = value.split('/').map(encodeURIComponent).join('/');

    url = url.replace(exp, value);
  });

  return url;
}

function getUrlTemplate(operation){
  var apiObject = operation.apiObject; 

  var basePath = apiObject.apiDeclaration.basePath;
  var path = apiObject.path.replace('{format}', 'json');
  
  return basePath + path;
}

},{"./errorTypes":23}],27:[function(_dereq_,module,exports){
'use strict';

// Promise polyfill
var Promise = _dereq_('es6-promise').Promise;
var clientGenerator = _dereq_('swagger-client-generator');

module.exports = function(schema){
  return clientGenerator(schema, requestHandler);
};

// For mocking during unit testing
if(typeof XMLHttpRequest !== 'undefined'){
  module.exports.XMLHttpRequest = window.XMLHttpRequest;
}

function requestHandler(error, request){
  var XMLHttpRequest = module.exports.XMLHttpRequest;
  return new Promise(function(resolve, reject){
    if(error) return reject(error);

    var method = request.method;
    var url = request.url;
    var body = request.body;
    var headers = request.headers;

    var options = request.options;
    var async = ('async' in options)? options.async : true;
    var xhr = new XMLHttpRequest();

    xhr.open(method, url, async);

    if(headers){
      Object.keys(headers).forEach(function(header){
        xhr.setRequestHeader(header, headers[header]);
      });
    }
    
    if(options.withCredentials) xhr.withCredentials = options.withCredentials;
    if(options.timeout) xhr.timeout = options.timeout;
    if(options.onabort) xhr.onabort = options.onabort;
    if(options.onerror) xhr.onerror = options.onerror;
    if(options.onload) xhr.onload = options.onload;
    if(options.ontimeout) xhr.ontimeout = options.ontimeout;
    if(options.onprogress) xhr.onprogress = options.onprogress;

    xhr.onloadend = function(){
      var data = this.response;
      var contentType = this.getResponseHeader('Content-Type');

      if(contentType && contentType.indexOf('application/json') !== -1){
        try {
          data = JSON.parse(data);
        } catch(error){
          reject({ 
            error: error,
            status: this.status,
            data: data
          });
        }
      }

      if(this.status < 200 || this.status >= 300){
        reject({
          error: error,
          status: this.status,
          data: data
        });
      } else {
        resolve(data);
      }
      
      if(options.onloadend) options.onloadend.call(this);
    };

    xhr.send(body);
  });
}

},{"es6-promise":2,"swagger-client-generator":12}]},{},[27])
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/ozan/code/swagger-ajax-client/node_modules/boilerplate-gulp/node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/ozan/code/swagger-ajax-client/node_modules/boilerplate-gulp/node_modules/browserify/node_modules/process/browser.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/main.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/all.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/asap.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/config.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/polyfill.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/promise.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/race.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/reject.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/resolve.js","/Users/ozan/code/swagger-ajax-client/node_modules/es6-promise/dist/commonjs/promise/utils.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/index.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/node_modules/swagger-validate/src/errorTypes.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/node_modules/swagger-validate/src/index.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/node_modules/swagger-validate/src/validateArray.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/node_modules/swagger-validate/src/validateDataType.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/node_modules/swagger-validate/src/validateModel.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/node_modules/swagger-validate/src/validateOperation.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/node_modules/swagger-validate/src/validatePrimitiveTypes.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/src/applyAuthData.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/src/createClient.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/src/createOperationHandler.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/src/errorTypes.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/src/getRequestBody.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/src/getRequestHeaders.js","/Users/ozan/code/swagger-ajax-client/node_modules/swagger-client-generator/src/getRequestUrl.js","/Users/ozan/code/swagger-ajax-client/src/client.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// shim for using process in browser\n\nvar process = module.exports = {};\n\nprocess.nextTick = (function () {\n    var canSetImmediate = typeof window !== 'undefined'\n    && window.setImmediate;\n    var canPost = typeof window !== 'undefined'\n    && window.postMessage && window.addEventListener\n    ;\n\n    if (canSetImmediate) {\n        return function (f) { return window.setImmediate(f) };\n    }\n\n    if (canPost) {\n        var queue = [];\n        window.addEventListener('message', function (ev) {\n            var source = ev.source;\n            if ((source === window || source === null) && ev.data === 'process-tick') {\n                ev.stopPropagation();\n                if (queue.length > 0) {\n                    var fn = queue.shift();\n                    fn();\n                }\n            }\n        }, true);\n\n        return function nextTick(fn) {\n            queue.push(fn);\n            window.postMessage('process-tick', '*');\n        };\n    }\n\n    return function nextTick(fn) {\n        setTimeout(fn, 0);\n    };\n})();\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n}\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\n","\"use strict\";\nvar Promise = require(\"./promise/promise\").Promise;\nvar polyfill = require(\"./promise/polyfill\").polyfill;\nexports.Promise = Promise;\nexports.polyfill = polyfill;","\"use strict\";\n/* global toString */\n\nvar isArray = require(\"./utils\").isArray;\nvar isFunction = require(\"./utils\").isFunction;\n\n/**\n  Returns a promise that is fulfilled when all the given promises have been\n  fulfilled, or rejected if any of them become rejected. The return promise\n  is fulfilled with an array that gives all the values in the order they were\n  passed in the `promises` array argument.\n\n  Example:\n\n  ```javascript\n  var promise1 = RSVP.resolve(1);\n  var promise2 = RSVP.resolve(2);\n  var promise3 = RSVP.resolve(3);\n  var promises = [ promise1, promise2, promise3 ];\n\n  RSVP.all(promises).then(function(array){\n    // The array here would be [ 1, 2, 3 ];\n  });\n  ```\n\n  If any of the `promises` given to `RSVP.all` are rejected, the first promise\n  that is rejected will be given as an argument to the returned promises's\n  rejection handler. For example:\n\n  Example:\n\n  ```javascript\n  var promise1 = RSVP.resolve(1);\n  var promise2 = RSVP.reject(new Error(\"2\"));\n  var promise3 = RSVP.reject(new Error(\"3\"));\n  var promises = [ promise1, promise2, promise3 ];\n\n  RSVP.all(promises).then(function(array){\n    // Code here never runs because there are rejected promises!\n  }, function(error) {\n    // error.message === \"2\"\n  });\n  ```\n\n  @method all\n  @for RSVP\n  @param {Array} promises\n  @param {String} label\n  @return {Promise} promise that is fulfilled when all `promises` have been\n  fulfilled, or rejected if any of them become rejected.\n*/\nfunction all(promises) {\n  /*jshint validthis:true */\n  var Promise = this;\n\n  if (!isArray(promises)) {\n    throw new TypeError('You must pass an array to all.');\n  }\n\n  return new Promise(function(resolve, reject) {\n    var results = [], remaining = promises.length,\n    promise;\n\n    if (remaining === 0) {\n      resolve([]);\n    }\n\n    function resolver(index) {\n      return function(value) {\n        resolveAll(index, value);\n      };\n    }\n\n    function resolveAll(index, value) {\n      results[index] = value;\n      if (--remaining === 0) {\n        resolve(results);\n      }\n    }\n\n    for (var i = 0; i < promises.length; i++) {\n      promise = promises[i];\n\n      if (promise && isFunction(promise.then)) {\n        promise.then(resolver(i), reject);\n      } else {\n        resolveAll(i, promise);\n      }\n    }\n  });\n}\n\nexports.all = all;","(function (process,global){\n\"use strict\";\nvar browserGlobal = (typeof window !== 'undefined') ? window : {};\nvar BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;\nvar local = (typeof global !== 'undefined') ? global : (this === undefined? window:this);\n\n// node\nfunction useNextTick() {\n  return function() {\n    process.nextTick(flush);\n  };\n}\n\nfunction useMutationObserver() {\n  var iterations = 0;\n  var observer = new BrowserMutationObserver(flush);\n  var node = document.createTextNode('');\n  observer.observe(node, { characterData: true });\n\n  return function() {\n    node.data = (iterations = ++iterations % 2);\n  };\n}\n\nfunction useSetTimeout() {\n  return function() {\n    local.setTimeout(flush, 1);\n  };\n}\n\nvar queue = [];\nfunction flush() {\n  for (var i = 0; i < queue.length; i++) {\n    var tuple = queue[i];\n    var callback = tuple[0], arg = tuple[1];\n    callback(arg);\n  }\n  queue = [];\n}\n\nvar scheduleFlush;\n\n// Decide what async method to use to triggering processing of queued callbacks:\nif (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {\n  scheduleFlush = useNextTick();\n} else if (BrowserMutationObserver) {\n  scheduleFlush = useMutationObserver();\n} else {\n  scheduleFlush = useSetTimeout();\n}\n\nfunction asap(callback, arg) {\n  var length = queue.push([callback, arg]);\n  if (length === 1) {\n    // If length is 1, that means that we need to schedule an async flush.\n    // If additional callbacks are queued before the queue is flushed, they\n    // will be processed by this flush that we are scheduling.\n    scheduleFlush();\n  }\n}\n\nexports.asap = asap;\n}).call(this,require(\"0yPD3/\"),typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","\"use strict\";\nvar config = {\n  instrument: false\n};\n\nfunction configure(name, value) {\n  if (arguments.length === 2) {\n    config[name] = value;\n  } else {\n    return config[name];\n  }\n}\n\nexports.config = config;\nexports.configure = configure;","(function (global){\n\"use strict\";\n/*global self*/\nvar RSVPPromise = require(\"./promise\").Promise;\nvar isFunction = require(\"./utils\").isFunction;\n\nfunction polyfill() {\n  var local;\n\n  if (typeof global !== 'undefined') {\n    local = global;\n  } else if (typeof window !== 'undefined' && window.document) {\n    local = window;\n  } else {\n    local = self;\n  }\n\n  var es6PromiseSupport = \n    \"Promise\" in local &&\n    // Some of these methods are missing from\n    // Firefox/Chrome experimental implementations\n    \"resolve\" in local.Promise &&\n    \"reject\" in local.Promise &&\n    \"all\" in local.Promise &&\n    \"race\" in local.Promise &&\n    // Older version of the spec had a resolver object\n    // as the arg rather than a function\n    (function() {\n      var resolve;\n      new local.Promise(function(r) { resolve = r; });\n      return isFunction(resolve);\n    }());\n\n  if (!es6PromiseSupport) {\n    local.Promise = RSVPPromise;\n  }\n}\n\nexports.polyfill = polyfill;\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","\"use strict\";\nvar config = require(\"./config\").config;\nvar configure = require(\"./config\").configure;\nvar objectOrFunction = require(\"./utils\").objectOrFunction;\nvar isFunction = require(\"./utils\").isFunction;\nvar now = require(\"./utils\").now;\nvar all = require(\"./all\").all;\nvar race = require(\"./race\").race;\nvar staticResolve = require(\"./resolve\").resolve;\nvar staticReject = require(\"./reject\").reject;\nvar asap = require(\"./asap\").asap;\n\nvar counter = 0;\n\nconfig.async = asap; // default async is asap;\n\nfunction Promise(resolver) {\n  if (!isFunction(resolver)) {\n    throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');\n  }\n\n  if (!(this instanceof Promise)) {\n    throw new TypeError(\"Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.\");\n  }\n\n  this._subscribers = [];\n\n  invokeResolver(resolver, this);\n}\n\nfunction invokeResolver(resolver, promise) {\n  function resolvePromise(value) {\n    resolve(promise, value);\n  }\n\n  function rejectPromise(reason) {\n    reject(promise, reason);\n  }\n\n  try {\n    resolver(resolvePromise, rejectPromise);\n  } catch(e) {\n    rejectPromise(e);\n  }\n}\n\nfunction invokeCallback(settled, promise, callback, detail) {\n  var hasCallback = isFunction(callback),\n      value, error, succeeded, failed;\n\n  if (hasCallback) {\n    try {\n      value = callback(detail);\n      succeeded = true;\n    } catch(e) {\n      failed = true;\n      error = e;\n    }\n  } else {\n    value = detail;\n    succeeded = true;\n  }\n\n  if (handleThenable(promise, value)) {\n    return;\n  } else if (hasCallback && succeeded) {\n    resolve(promise, value);\n  } else if (failed) {\n    reject(promise, error);\n  } else if (settled === FULFILLED) {\n    resolve(promise, value);\n  } else if (settled === REJECTED) {\n    reject(promise, value);\n  }\n}\n\nvar PENDING   = void 0;\nvar SEALED    = 0;\nvar FULFILLED = 1;\nvar REJECTED  = 2;\n\nfunction subscribe(parent, child, onFulfillment, onRejection) {\n  var subscribers = parent._subscribers;\n  var length = subscribers.length;\n\n  subscribers[length] = child;\n  subscribers[length + FULFILLED] = onFulfillment;\n  subscribers[length + REJECTED]  = onRejection;\n}\n\nfunction publish(promise, settled) {\n  var child, callback, subscribers = promise._subscribers, detail = promise._detail;\n\n  for (var i = 0; i < subscribers.length; i += 3) {\n    child = subscribers[i];\n    callback = subscribers[i + settled];\n\n    invokeCallback(settled, child, callback, detail);\n  }\n\n  promise._subscribers = null;\n}\n\nPromise.prototype = {\n  constructor: Promise,\n\n  _state: undefined,\n  _detail: undefined,\n  _subscribers: undefined,\n\n  then: function(onFulfillment, onRejection) {\n    var promise = this;\n\n    var thenPromise = new this.constructor(function() {});\n\n    if (this._state) {\n      var callbacks = arguments;\n      config.async(function invokePromiseCallback() {\n        invokeCallback(promise._state, thenPromise, callbacks[promise._state - 1], promise._detail);\n      });\n    } else {\n      subscribe(this, thenPromise, onFulfillment, onRejection);\n    }\n\n    return thenPromise;\n  },\n\n  'catch': function(onRejection) {\n    return this.then(null, onRejection);\n  }\n};\n\nPromise.all = all;\nPromise.race = race;\nPromise.resolve = staticResolve;\nPromise.reject = staticReject;\n\nfunction handleThenable(promise, value) {\n  var then = null,\n  resolved;\n\n  try {\n    if (promise === value) {\n      throw new TypeError(\"A promises callback cannot return that same promise.\");\n    }\n\n    if (objectOrFunction(value)) {\n      then = value.then;\n\n      if (isFunction(then)) {\n        then.call(value, function(val) {\n          if (resolved) { return true; }\n          resolved = true;\n\n          if (value !== val) {\n            resolve(promise, val);\n          } else {\n            fulfill(promise, val);\n          }\n        }, function(val) {\n          if (resolved) { return true; }\n          resolved = true;\n\n          reject(promise, val);\n        });\n\n        return true;\n      }\n    }\n  } catch (error) {\n    if (resolved) { return true; }\n    reject(promise, error);\n    return true;\n  }\n\n  return false;\n}\n\nfunction resolve(promise, value) {\n  if (promise === value) {\n    fulfill(promise, value);\n  } else if (!handleThenable(promise, value)) {\n    fulfill(promise, value);\n  }\n}\n\nfunction fulfill(promise, value) {\n  if (promise._state !== PENDING) { return; }\n  promise._state = SEALED;\n  promise._detail = value;\n\n  config.async(publishFulfillment, promise);\n}\n\nfunction reject(promise, reason) {\n  if (promise._state !== PENDING) { return; }\n  promise._state = SEALED;\n  promise._detail = reason;\n\n  config.async(publishRejection, promise);\n}\n\nfunction publishFulfillment(promise) {\n  publish(promise, promise._state = FULFILLED);\n}\n\nfunction publishRejection(promise) {\n  publish(promise, promise._state = REJECTED);\n}\n\nexports.Promise = Promise;","\"use strict\";\n/* global toString */\nvar isArray = require(\"./utils\").isArray;\n\n/**\n  `RSVP.race` allows you to watch a series of promises and act as soon as the\n  first promise given to the `promises` argument fulfills or rejects.\n\n  Example:\n\n  ```javascript\n  var promise1 = new RSVP.Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve(\"promise 1\");\n    }, 200);\n  });\n\n  var promise2 = new RSVP.Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve(\"promise 2\");\n    }, 100);\n  });\n\n  RSVP.race([promise1, promise2]).then(function(result){\n    // result === \"promise 2\" because it was resolved before promise1\n    // was resolved.\n  });\n  ```\n\n  `RSVP.race` is deterministic in that only the state of the first completed\n  promise matters. For example, even if other promises given to the `promises`\n  array argument are resolved, but the first completed promise has become\n  rejected before the other promises became fulfilled, the returned promise\n  will become rejected:\n\n  ```javascript\n  var promise1 = new RSVP.Promise(function(resolve, reject){\n    setTimeout(function(){\n      resolve(\"promise 1\");\n    }, 200);\n  });\n\n  var promise2 = new RSVP.Promise(function(resolve, reject){\n    setTimeout(function(){\n      reject(new Error(\"promise 2\"));\n    }, 100);\n  });\n\n  RSVP.race([promise1, promise2]).then(function(result){\n    // Code here never runs because there are rejected promises!\n  }, function(reason){\n    // reason.message === \"promise2\" because promise 2 became rejected before\n    // promise 1 became fulfilled\n  });\n  ```\n\n  @method race\n  @for RSVP\n  @param {Array} promises array of promises to observe\n  @param {String} label optional string for describing the promise returned.\n  Useful for tooling.\n  @return {Promise} a promise that becomes fulfilled with the value the first\n  completed promises is resolved with if the first completed promise was\n  fulfilled, or rejected with the reason that the first completed promise\n  was rejected with.\n*/\nfunction race(promises) {\n  /*jshint validthis:true */\n  var Promise = this;\n\n  if (!isArray(promises)) {\n    throw new TypeError('You must pass an array to race.');\n  }\n  return new Promise(function(resolve, reject) {\n    var results = [], promise;\n\n    for (var i = 0; i < promises.length; i++) {\n      promise = promises[i];\n\n      if (promise && typeof promise.then === 'function') {\n        promise.then(resolve, reject);\n      } else {\n        resolve(promise);\n      }\n    }\n  });\n}\n\nexports.race = race;","\"use strict\";\n/**\n  `RSVP.reject` returns a promise that will become rejected with the passed\n  `reason`. `RSVP.reject` is essentially shorthand for the following:\n\n  ```javascript\n  var promise = new RSVP.Promise(function(resolve, reject){\n    reject(new Error('WHOOPS'));\n  });\n\n  promise.then(function(value){\n    // Code here doesn't run because the promise is rejected!\n  }, function(reason){\n    // reason.message === 'WHOOPS'\n  });\n  ```\n\n  Instead of writing the above, your code now simply becomes the following:\n\n  ```javascript\n  var promise = RSVP.reject(new Error('WHOOPS'));\n\n  promise.then(function(value){\n    // Code here doesn't run because the promise is rejected!\n  }, function(reason){\n    // reason.message === 'WHOOPS'\n  });\n  ```\n\n  @method reject\n  @for RSVP\n  @param {Any} reason value that the returned promise will be rejected with.\n  @param {String} label optional string for identifying the returned promise.\n  Useful for tooling.\n  @return {Promise} a promise that will become rejected with the given\n  `reason`.\n*/\nfunction reject(reason) {\n  /*jshint validthis:true */\n  var Promise = this;\n\n  return new Promise(function (resolve, reject) {\n    reject(reason);\n  });\n}\n\nexports.reject = reject;","\"use strict\";\nfunction resolve(value) {\n  /*jshint validthis:true */\n  if (value && typeof value === 'object' && value.constructor === this) {\n    return value;\n  }\n\n  var Promise = this;\n\n  return new Promise(function(resolve) {\n    resolve(value);\n  });\n}\n\nexports.resolve = resolve;","\"use strict\";\nfunction objectOrFunction(x) {\n  return isFunction(x) || (typeof x === \"object\" && x !== null);\n}\n\nfunction isFunction(x) {\n  return typeof x === \"function\";\n}\n\nfunction isArray(x) {\n  return Object.prototype.toString.call(x) === \"[object Array]\";\n}\n\n// Date.now is not available in browsers < IE9\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility\nvar now = Date.now || function() { return new Date().getTime(); };\n\n\nexports.objectOrFunction = objectOrFunction;\nexports.isFunction = isFunction;\nexports.isArray = isArray;\nexports.now = now;","module.exports = require('./src/createClient');","'use strict';\n\nfunction DataTypeValidationError(message){\n  this.name = 'DataTypeValidationError';\n  this.message = message || 'Invalid data type';\n}\nDataTypeValidationError.prototype = Object.create(Error.prototype);\nDataTypeValidationError.prototype.constructor = DataTypeValidationError;\nexports.DataTypeValidationError = DataTypeValidationError;\n\nfunction NotAnIntegerError(value){\n  this.name = 'NotAnIntegerError';\n  this.message = '\"' + value + '\" is not an integer';\n  this.value = value;\n}\nNotAnIntegerError.prototype = Object.create(DataTypeValidationError.prototype);\nNotAnIntegerError.prototype.constructor = NotAnIntegerError;\nexports.NotAnIntegerError = NotAnIntegerError;\n\nfunction NotANumberError(value, actualType){\n  this.name = 'NotANumberError';\n  this.message = '\"' + value + '\" is not a number';\n  if(actualType) this.message += ' (got a ' + actualType + ' instead)';\n\n  this.value = value;\n}\nNotANumberError.prototype = Object.create(DataTypeValidationError.prototype);\nNotANumberError.prototype.constructor = NotANumberError;\nexports.NotANumberError = NotANumberError;\n\nfunction NumberTooLargeError(value, max){\n  this.name = 'NumberTooLargeError';\n  this.message = '\"' + value + '\" is above the maximum of ' + max.toString();\n  this.value = value;\n}\nNumberTooLargeError.prototype = Object.create(DataTypeValidationError.prototype);\nNumberTooLargeError.prototype.constructor = NumberTooLargeError;\nexports.NumberTooLargeError = NumberTooLargeError;\n\nfunction NumberTooSmallError(value, max){\n  this.name = 'NumberTooSmallError';\n  this.message = '\"' + value + '\" is above the maximum of ' + max.toString();\n  this.value = value;\n}\nNumberTooSmallError.prototype = Object.create(DataTypeValidationError.prototype);\nNumberTooSmallError.prototype.constructor = NumberTooSmallError;\nexports.NumberTooSmallError = NumberTooSmallError;\n\nfunction NotABooleanError(value, actualType){\n  this.name = 'NotABooleanError';\n  this.message = '\"' + value + '\" is not a boolean';\n  if(actualType) this.message += ' (got a ' + actualType + ' instead)';\n\n  this.value = value;\n}\nNotABooleanError.prototype = Object.create(DataTypeValidationError.prototype);\nNotABooleanError.prototype.constructor = NotABooleanError;\nexports.NotABooleanError = NotABooleanError;\n\nfunction NotAnArrayError(value, actualType){\n  this.name = 'NotAnArrayError';\n  this.message = '\"' + value + '\" is not an array';\n  if(actualType) this.message += ' (got a ' + actualType + ' instead)';\n\n  this.value = value;\n}\nNotAnArrayError.prototype = Object.create(DataTypeValidationError.prototype);\nNotAnArrayError.prototype.constructor = NotAnArrayError;\nexports.NotAnArrayError = NotAnArrayError;\n\nfunction DuplicateInSetError(arr, dupes){\n  this.name = 'DuplicateInSetError';\n  this.message = 'Duplicates (\"' + dupes.join('\", \"') + '\") found in set: [\"' + arr.join('\", \"') + '\"';\n  this.dupes = dupes;\n  this.value = arr;\n}\nDuplicateInSetError.prototype = Object.create(DataTypeValidationError.prototype);\nDuplicateInSetError.prototype.constructor = DuplicateInSetError;\nexports.DuplicateInSetError = DuplicateInSetError;\n\nfunction NotVoidError(value, actualType){\n  this.name = 'NotVoidError';\n  this.message = '\"' + value + '\" is not null or undefined';\n  if(actualType) this.message += ' (got a ' + actualType + ' instead)';\n\n  this.value = value;\n}\nNotVoidError.prototype = Object.create(DataTypeValidationError.prototype);\nNotVoidError.prototype.constructor = NotVoidError;\nexports.NotVoidError = NotVoidError;\n\nfunction NotAStringError(value, actualType){\n  this.name = 'NotAStringError';\n  this.message = '\"' + value + '\" is not a string';\n  if(actualType) this.message += ' (got a ' + actualType + ' instead)';\n\n  this.value = value;\n}\nNotAStringError.prototype = Object.create(DataTypeValidationError.prototype);\nNotAStringError.prototype.constructor = NotAStringError;\nexports.NotAStringError = NotAStringError;\n\nfunction StringNotInEnumError(value, acceptableValues){\n  this.name = 'StringNotInEnumError';\n  this.message = '\"' + value + '\" is not an acceptable value: \"' + acceptableValues.join('\", \"') + '\"';\n \n  this.value = value;\n}\nStringNotInEnumError.prototype = Object.create(DataTypeValidationError.prototype);\nStringNotInEnumError.prototype.constructor = StringNotInEnumError;\nexports.StringNotInEnumError = StringNotInEnumError;\n\n\nfunction ErrorsInArrayElementsError(errors){\n  this.name = 'ErrorsInArrayElementsError';\n  this.message = 'Errors in array elements:\\n\\t' + errors.join(',\\n\\t');\n  this.errors = errors;\n}\nErrorsInArrayElementsError.prototype = Object.create(DataTypeValidationError.prototype);\nErrorsInArrayElementsError.prototype.constructor = ErrorsInArrayElementsError;\nexports.ErrorsInArrayElementsError = ErrorsInArrayElementsError;\n\nfunction MissingValueError(){\n  this.name = 'MissingValueError';\n  \n  this.message = 'This value is required but missing';\n}\nMissingValueError.prototype = Object.create(DataTypeValidationError.prototype);\nMissingValueError.prototype.constructor = MissingValueError;\nexports.MissingValueError = MissingValueError;\n\nfunction ValidationError(specName, spec, error){\n  this.name = 'ValidationError';\n  this.specName = specName;\n  this.spec = spec;\n  this.error = error;\n\n  this.message = specName + ' is invalid: ' + error.message;\n}\nValidationError.prototype = Object.create(DataTypeValidationError.prototype);\nValidationError.prototype.constructor = ValidationError;\nexports.ValidationError = ValidationError;\n\nfunction ValidationErrors(value, specName, spec, errors){\n  this.name = 'ValidationErrors';\n\n  this.value = value;\n  this.specName = specName;\n  this.spec = spec;\n  this.errors = errors || [];\n\n  this.message = specName + ' is invalid';\n\n  if(this.errors.length){\n    this.message += ':\\n\\t' + this.errors.map(function(e){ return e.message; }).join('\\n\\t');\n  }\n}\nValidationErrors.prototype = Object.create(DataTypeValidationError.prototype);\nValidationErrors.prototype.constructor = ValidationErrors;\nexports.ValidationErrors = ValidationErrors;\n","exports.dataType = require('./validateDataType');\nexports.model = require('./validateModel');\nexports.operation = require('./validateOperation');\nexports.array = require('./validateArray');\nexports.errors = require('./errorTypes');\n\nvar primitives = require('./validatePrimitiveTypes');\nexports.primitive = {\n  integer: primitives.validateInteger,\n  number: primitives.validateNumber,\n  string: primitives.validateString,\n  boolean: primitives.validateBoolean,\n  void: primitives.validateVoid,\n  file: primitives.validateFile\n};\n","'use strict';\n\nvar errorTypes = require('./errorTypes'),\n  validate = require('./index');\n\nfunction validateArray(candidate, dataType, models){\n  if(!Array.isArray(candidate)){\n    return new errorTypes.NotAnArrayError(candidate, typeof candidate);\n  }\n\n  var items = dataType.items;\n\n  if(dataType.uniqueItems){\n    var dupeCheck = [];\n    var dupes = candidate.filter(function(value){\n      var signature;\n      if(items.$ref){\n        signature = JSON.stringify(value);\n      } else {\n        signature = value;\n      }\n      if(dupeCheck.indexOf(signature) !== -1){\n        return true;\n      } else {\n        dupeCheck.push(signature);\n        return false;\n      }\n    });\n\n    if(dupes.length) {\n      return new errorTypes.DuplicateInSetError(candidate, dupes);\n    }\n  }\n\n  var errors;\n\n  if(items.$ref){\n    var model = models[items.$ref];\n    errors = candidate.filter(function(value){\n      return validate.model(value, model, models);\n    });\n  } else {\n    errors = candidate.filter(function(value){\n      return validate.dataType(value, items, models);\n    });\n  }\n\n  if(errors.length){\n    return new errorTypes.ErrorsInArrayElementsError(errors);\n  }\n}\nmodule.exports = validateArray;","'use strict';\n\nvar validate = require('./index');\n  \nfunction validateDataType(candidate, dataType, models){\n  models = models || {};\n      \n  var type = dataType.type || dataType.dataType || dataType.$ref;\n\n  switch(type){\n    case 'integer':\n      return validate.primitive.integer(candidate, dataType);\n    case 'number':\n      return validate.primitive.number(candidate, dataType);\n    case 'string':\n      return validate.primitive.string(candidate, dataType);\n    case 'boolean':\n      return validate.primitive.boolean(candidate);\n    case 'array':\n      return validate.array(candidate, dataType, models);\n    case 'void':\n      return validate.primitive.void(candidate);\n    case 'File':\n      return validate.primitive.file();\n    default:\n      // Assumed to be complex model\n      var model = models[type];\n      return validate.model(candidate, model, models);\n  }\n}\nmodule.exports = validateDataType;","'use strict';\n\nvar errorTypes = require('./errorTypes'),\n  ValidationError = errorTypes.ValidationError,\n  ValidationErrors = errorTypes.ValidationErrors,\n  MissingValueError = errorTypes.MissingValueError,\n  validate = require('./index');\n\n// http://stackoverflow.com/questions/122102/what-is-the-most-efficient-way-to-clone-an-object\nfunction clone(obj){\n    if(obj === null || obj === undefined || typeof obj !== 'object') return obj;\n\n    if(Array.isArray(obj)) return obj.slice();\n\n    var temp = {};\n\n    for(var key in obj)\n        temp[key] = clone(obj[key]);\n    return temp;\n}\n\nfunction addInhertiedProperties(model, modelId, models){\n  var parent;\n\n  Object.keys(models).some(function(modelName){\n    var potentialParent = models[modelName];\n    if (!potentialParent.subTypes) return;\n\n    if(potentialParent.subTypes.indexOf(modelId) !== -1){\n      parent = potentialParent;\n      return true;\n    }\n  });\n\n  if(!parent) return;\n\n  for(var propertyName in parent.properties){\n    model.properties[propertyName] = parent.properties[propertyName];\n  }\n  \n  if(parent.required) model.required = model.required.concat(parent.required);\n\n  addInhertiedProperties(model, parent.id, models);\n}\n\nfunction validateModel(candidate, model, models){\n  if(candidate === null || typeof candidate !== 'object'){\n    return new ValidationErrors(candidate, model);\n  }\n\n  models = models || {};\n\n  model = clone(model);\n  if(!model.required) model.required = [];\n  addInhertiedProperties(model, model.id, models);\n\n  var errors = [];\n\n  model.required.forEach(function(propertyName){\n    if (candidate[propertyName] !== undefined) return;\n\n    var property = model.properties[propertyName];\n    var error = new MissingValueError();\n    errors.push(new ValidationError(propertyName, property, error));\n  });\n\n  Object.keys(candidate).forEach(function(propertyName){\n    var property = model.properties[propertyName];\n    \n    if(property === undefined) return;\n\n    var error = validate.dataType(candidate[propertyName], property, models);\n    if(error){\n      errors.push(new ValidationError(propertyName, property, error));\n    }\n  });\n  \n  if(errors.length){\n    return new ValidationErrors(candidate, model.id, model, errors);\n  }\n}\nmodule.exports = validateModel;","'use strict';\n\nvar errorTypes = require('./errorTypes'),\n  ValidationError = errorTypes.ValidationError,\n  ValidationErrors = errorTypes.ValidationErrors,\n  MissingValueError = errorTypes.MissingValueError,\n  validate = require('./index');\n\nfunction validateOperation(candidate, operation, models){\n  var errors = [];\n  \n  var presentParams = operation.parameters.filter(function(param){\n    if (candidate[param.name] !== undefined) return true;\n    \n    if (param.required) {\n      var error = new MissingValueError();\n      errors.push(new ValidationError(param.name, param, error));\n    }\n\n    return false;\n  });\n\n  presentParams.forEach(function(param){\n    var error = validate.dataType(candidate[param.name], param, models);\n    if(error){\n      errors.push(new ValidationError(param.name, param, error));\n    }\n  });\n  \n  if(errors.length){\n    return new ValidationErrors(candidate, operation.nickname, operation, errors);\n  }\n}\nmodule.exports = validateOperation;","'use strict';\n\nvar errorTypes = require('./errorTypes');\n\nfunction validateInteger(candidate, dataType){\n  var error = validateNumber(candidate, dataType);\n  if(error) return error;\n\n  if(candidate % 1){\n    return new errorTypes.NotAnIntegerError(candidate);\n  }\n}\nexports.validateInteger = validateInteger;\n\nfunction validateNumber(candidate, dataType){\n  if(!(typeof candidate === 'number' || candidate instanceof Number) || isNaN(candidate)){\n    return new errorTypes.NotANumberError(candidate, typeof candidate);\n  }\n  \n  if((dataType.minimum !== undefined) && candidate < parseInt(dataType.minimum, 10)){\n    return new errorTypes.NumberTooSmallError(candidate, dataType.minimum);\n  }\n  \n  if((dataType.maximum !== undefined) && candidate > parseInt(dataType.maximum, 10)){\n    return new errorTypes.NumberTooLargeError(candidate, dataType.maximum);\n  }\n}\nexports.validateNumber = validateNumber;\n\nfunction validateBoolean(candidate){\n  if(!(typeof candidate === 'boolean' || candidate instanceof Boolean)){\n    return new errorTypes.NotABooleanError(candidate, typeof candidate);\n  }\n}\nexports.validateBoolean = validateBoolean;\n\n\nfunction validateVoid(candidate){\n  if(candidate != null){\n    return new errorTypes.NotVoidError(candidate, typeof candidate);\n  }\n}\nexports.validateVoid = validateVoid;\n\nfunction validateFile(){\n  // Not sure how to check this, since anything could qualify as 'File'.\n}\nexports.validateFile = validateFile;\n\nfunction validateString(candidate, dataType){\n  if(typeof candidate !== 'string' && !(candidate instanceof String)){\n    return new errorTypes.NotAStringError(candidate, typeof candidate);\n  }\n\n  if('enum' in dataType){\n    if(dataType.enum.indexOf(candidate) === -1) {\n      return new errorTypes.StringNotInEnumError(candidate, dataType.enum);\n    }\n  }\n}\nexports.validateString = validateString;","'use strict';\n\nvar MissingAuthorizationError = require('./errorTypes').MissingAuthorizationError;\n\nmodule.exports = function applyAuthData(operation, authData, request){\n  var authMap = operation.authorizations;\n  if(!authMap) authMap = operation.apiObject.apiDeclaration.authorizations;\n  if(!authMap) return;\n\n  var authNames = Object.keys(authMap).filter(function(authName){\n    // Currently unable to handle oauth2\n    return authMap[authName].type !== 'oauth2';\n  });\n\n  if(authNames.length === 0) return;\n\n  if(authNames.length === 1){\n    var authName = authNames[0];\n    var auth = authMap[authName];\n\n    if(!authData) throw new MissingAuthorizationError(authName, auth);\n\n    // Unpack nested authData for single auth ops: { apiKey: '123' } -> '123'\n    if(authData[authName]) authData = authData[authName];\n\n    if(auth.type === 'apiKey'){\n      applyApiKey(auth, authName, authData, request);\n    } else if(auth.type === 'basicAuth') {\n      applyBasicAuth(auth, authName, authData.username, authData.password, request);\n    }\n  } else {\n    var hasAuth = authNames.some(function(authName){\n      var auth = authMap[authName];\n      var data = authData[authName];\n\n      if(!data) return false;\n\n      if(auth.type === 'apiKey'){\n        applyApiKey(auth, authName, data, request);\n      } else if(auth.type === 'basicAuth'){\n        applyBasicAuth(auth, authName, data.username, data.password, request);\n      }\n\n      return true;\n    });\n\n    if(!hasAuth){\n      throw new MissingAuthorizationError(authNames.join(', '), authMap);\n    }\n  }\n};\n\nfunction applyApiKey(auth, authName, apiKey, request){\n  if(!apiKey) throw new MissingAuthorizationError(authName, auth);\n  \n  if(auth.passAs === 'header'){\n    request.headers[auth.keyname] = apiKey;\n  } else if(auth.passAs === 'query'){\n    var url = request.url;\n    var queryParam = auth.keyname + '=' + encodeURIComponent(apiKey);\n    if(url.indexOf('?') === -1){\n      url += '?' + queryParam;\n    } else {\n      url = url.replace('?', '?' + queryParam + '&');\n    }\n\n    request.url = url;\n  }\n}\n\nfunction applyBasicAuth(auth, authName, username, password, request){\n  if(!username || !password) throw new MissingAuthorizationError(authName, auth);\n  \n  var url = request.url;\n  \n  // Only add basic auth once\n  if(url.indexOf('@') === -1){\n    url = url.replace('://', '://' + username + ':' + password + '@');\n  }\n\n  request.url = url;\n}","'use strict';\n\nvar createOperationHandler = require('./createOperationHandler');\n\nfunction createClient(schema, requestHandler){\n  var api = {},\n    apiAuthData,\n    authMethodName = 'auth';\n\n  schema = processSchema(schema);\n  \n  // If the 'auth' key is used for any resource or operation, we'll use\n  // 'authorization' instead for the auth methods\n  var authIsInUse = schema.apis.some(function(resourceObject){\n    return resourceObject.apiDeclaration.apis.some(function(apiObject){\n      var resourceApiName = getApiName(apiObject.apiDeclaration.resourcePath || apiObject.path);\n      if(resourceApiName === 'auth') return true;\n      return apiObject.operations.some(function(operation){\n        return operation.nickname === 'auth';\n      });\n    });\n  });\n  \n  if(authIsInUse) authMethodName = 'authorization';\n\n  api[authMethodName] = function(){\n    apiAuthData = processApiAuthArgs(arguments);\n  };\n\n  schema.apis.forEach(function(resourceObject){\n    var resourceName,\n      resourceApi,\n      resourceAuthData;\n\n    if(resourceObject.apiDeclaration.resourcePath){\n      resourceName = getApiName(resourceObject.apiDeclaration.resourcePath);\n      resourceApi = api[resourceName] = {};\n      resourceApi[authMethodName] = function(){\n        resourceAuthData = processApiAuthArgs(arguments);\n      };\n    }\n\n    resourceObject.apiDeclaration.apis.forEach(function(apiObject){\n      var apiObjectName = resourceName,\n        apiObjectApi = resourceApi,\n        apiObjectAuthData;\n\n      if(!apiObjectName){\n        apiObjectName = getApiName(apiObject.path);\n        apiObjectApi = api[apiObjectName] = {};\n        apiObjectApi[authMethodName] = function(){\n          apiObjectAuthData = processApiAuthArgs(arguments);\n        };\n      }\n\n      apiObject.operations.forEach(function(operation){\n        var operationHandlerName = operation.nickname,\n          operationAuthData,\n          operationHandler; \n        \n        function getAuthData(){\n          return operationAuthData || apiObjectAuthData || resourceAuthData || apiAuthData;\n        }\n\n        operationHandler = createOperationHandler(operation, getAuthData, requestHandler);\n\n        operationHandler[authMethodName] = function(){\n          operationAuthData = processApiAuthArgs(arguments);\n        };\n\n        apiObjectApi[operationHandlerName] = operationHandler;\n      });\n    });\n  });\n\n  return api;\n}\nmodule.exports = createClient;\n\nfunction processApiAuthArgs(args){\n  // for basic auth, allow calls with two args (username, password)\n  if(typeof args[0] === 'string' && typeof args[1] === 'string') {\n    return {\n      username: args[0],\n      password: args[1]\n    };\n  } else {\n    return args[0];\n  }\n}\n\n// Helpper method which assings back pointer to object parents and returns\n// the api objects within the given schema.\nfunction processSchema(schema){\n  schema.apis.forEach(function(resourceObject){\n    resourceObject.resourceListing = schema;\n\n    resourceObject.apiDeclaration.apis.forEach(function(apiObject){\n      apiObject.resourceObject = resourceObject;\n      apiObject.apiDeclaration = resourceObject.apiDeclaration;\n\n      apiObject.operations.forEach(function(operation){\n        operation.apiObject = apiObject;\n\n        operation.parameters.forEach(function(parameter){\n          parameter.operation = operation;\n        });\n      });\n    });\n  });\n\n  return schema;\n}\n\n// Takes a path and returns a JavaScript-friendly variable name\nfunction getApiName(name){\n  // String non-word characters\n  name = name.replace(/\\W/g, '/');\n\n  // Turn paths which look/like/this to lookLikeThis\n  name = name.replace(/(\\w)\\/(\\w)/g, function(match, p1, p2){\n    return p1 + p2.toUpperCase();\n  });\n\n  name = name.replace(/\\//g, '');\n\n  return name;\n}","'use strict';\n\nvar getRequestHeaders = require('./getRequestHeaders'),\n  getRequestUrl = require('./getRequestUrl'),\n  getRequestBody = require('./getRequestBody'),\n  applyAuthData = require('./applyAuthData'),\n  errorTypes = require('./errorTypes'),\n  swaggerValidate = require('swagger-validate');\n\nvar allErrorTypes = {};\nObject.keys(swaggerValidate.errors).forEach(function(errorName){\n  allErrorTypes[errorName] = swaggerValidate.errors[errorName];\n});\n\nObject.keys(errorTypes).forEach(function(errorName){\n  allErrorTypes[errorName] = errorTypes[errorName];\n});\n\nfunction createOperationHandler(operation, getAuthData, requestHandler){\n  function Request(data, options){\n    this.method = operation.method;\n    this.operation = operation;\n    this.errorTypes = allErrorTypes;\n    this.data = data;\n    this.options = options;\n  }\n\n  var operationHandler = function(data, options){\n    var error,\n      request;\n    \n    options = options || {};\n    \n    if(data == null) data = {};\n\n    // if a function is passed in as options, assume it's a callback function\n    // for convenience\n    if(typeof options === 'function'){\n      options.callback = options;\n    }\n\n    try{\n      data = prune(data);\n      data = singleParamConvenienceProcessor(operation, data);\n      data = removeUnknownParams(operation, data);\n\n      error = swaggerValidate.operation(data, operation, operation.apiObject.apiDeclaration.models);\n      \n      request = new Request(data, options);\n      \n      // If we know there is an error, don't attempt to craft the request params.\n      // The request param generators assume valid data to work properly.\n      if(!error){\n        request.url = getRequestUrl(operation, data);\n        request.headers = getRequestHeaders(operation, data, options);\n        request.body = getRequestBody(operation, data, request.headers);\n        \n        applyAuthData(operation, getAuthData(), request);\n      }\n    } catch(e){\n      error = e;\n    }\n    \n    return requestHandler(error, request);\n  };\n\n  // Useful for instanceof checks\n  operationHandler.Request = Request;\n  operationHandler.errorTypes = allErrorTypes;\n\n  // Useful for reflection\n  operationHandler.operation = operation;\n  \n  // Can be used to preemptively validate without action\n  operationHandler.validate = function(data){\n    return swaggerValidate.operation(data, operation, operation.apiObject.apiDeclaration.models);\n  };\n\n  return operationHandler;\n}\nmodule.exports = createOperationHandler;\n\nfunction noop(){}\ncreateOperationHandler.logger = {\n  debug: noop,\n  info: noop,\n  warn: noop,\n  error: noop\n};\n\n// Stringify and parse the data to clean up undefined, and non-scalar properties\nfunction prune(data){\n  return JSON.parse(JSON.stringify(data));\n}\n\n// Enables data to be passed directly for single param operations.\nfunction singleParamConvenienceProcessor(operation, data){\n  // If there are more than one params, bail\n  var requiredParams = operation.parameters.filter(function(param){\n    return param.required;\n  });\n\n  // If there are more than one required params, or if there is no required param\n  // and there are many optional params, bail\n  if(requiredParams.length > 1) return data;\n\n  if(requiredParams.length !== 1 && operation.parameters.length !== 1) return data;\n\n  var param = requiredParams[0] || operation.parameters[0];\n  \n  // If the param is already defined explicitly, bail\n  if(typeof data === 'object' &&  data[param.name] !== undefined) return data;\n\n  var models = operation.apiObject.apiDeclaration.models;\n\n  // If the data passed is is not valid for the param data type, bail\n  var error;\n\n  try {\n    error = swaggerValidate.dataType(data, param, models); \n  } catch(e){\n    return data;\n  }\n  \n  // If the data passed is a valid param data type, bail\n  if(!error){\n    var wrapper = {};\n    wrapper[param.name] = data;\n    return wrapper;\n  } else {\n    return data;\n  }\n}\n \n\nfunction removeUnknownParams(operation, data){\n  if(!data || typeof data !== 'object') return data;\n\n  var paramNames = {};\n  operation.parameters.forEach(function(param){\n    paramNames[param.name] = true;\n  });\n\n  var unknownKeys = Object.keys(data).filter(function(key){\n    return !(key in paramNames);\n  });\n\n  createOperationHandler.logger.warn('Unknown parameters removed from request:', \n    unknownKeys.join(', '));\n\n  unknownKeys.forEach(function(key){\n    delete data[key];\n  });\n\n  return data;\n}","'use strict';\n\nfunction InvalidRequestError(message){\n  this.name = 'InvalidRequestError';\n  this.message = message || 'Invalid request';\n}\nInvalidRequestError.prototype = Object.create(Error.prototype);\nInvalidRequestError.prototype.constructor = InvalidRequestError;\n\nexports.InvalidRequestError = InvalidRequestError;\n\n\nfunction MissingAuthorizationError(authName, auth){\n  this.name = 'MissingAuthorizationError';\n  this.message = 'No data found for authorization: ' + authName;\n  this.authorization = auth;\n}\nMissingAuthorizationError.prototype = Object.create(InvalidRequestError.prototype);\nMissingAuthorizationError.prototype.constructor = MissingAuthorizationError;\n\nexports.MissingAuthorizationError = MissingAuthorizationError;\n\n\nfunction MissingPathParamsError(pathParams){\n  this.name = 'MissingPathParamsError';\n  this.message = 'Missing the following required path parameters: ' + pathParams.join('');\n}\nMissingPathParamsError.prototype = Object.create(InvalidRequestError.prototype);\nMissingPathParamsError.prototype.constructor = MissingPathParamsError;\n\nexports.MissingPathParamsError = MissingPathParamsError;\n\n\nfunction ContentTypeNotSupportedError(contentType, operation){\n  var apiDeclaration = operation.apiObject.apiDeclaration;\n  var consumes = operation.consumes || apiDeclaration.consumes || [];\n\n  this.name = 'ContentTypeNotSupportedError';\n  this.message = 'Operation [' + operation.nickname + '] does not accept ' + contentType + '. It supports: ' + \n    consumes.join(', ');\n}\nContentTypeNotSupportedError.prototype = Object.create(InvalidRequestError.prototype);\nContentTypeNotSupportedError.prototype.constructor = ContentTypeNotSupportedError;\n\nexports.ContentTypeNotSupportedError = ContentTypeNotSupportedError;\n\n\nfunction AcceptsNotSupportedError(accepts, operation){\n  var apiDeclaration = operation.apiObject.apiDeclaration;\n  var produces = operation.produces || apiDeclaration.produces || [];\n\n  this.name = 'AcceptsNotSupportedError';\n  this.message = 'Operation [' + operation.nickname + '] does not produce ' + accepts + '. It supports: ' + \n    produces.join(', ');\n}\nAcceptsNotSupportedError.prototype = Object.create(InvalidRequestError.prototype);\nAcceptsNotSupportedError.prototype.constructor = AcceptsNotSupportedError;\n\nexports.AcceptsNotSupportedError = AcceptsNotSupportedError;\n\n\nfunction OperationValidationError(operation, errors){\n  this.name = 'OperationValidationError';\n  this.message = operation.nickname + ' failed validation: \\n\\t' + errors.join('\\n\\t');\n}\nOperationValidationError.prototype = Object.create(InvalidRequestError.prototype);\nOperationValidationError.prototype.constructor = OperationValidationError;\n\nexports.OperationValidationError = OperationValidationError;\n\n\nfunction ParameterValidationError(parameter, errors){\n  this.name = 'ParameterValidationError';\n  this.message = parameter.name + ' failed validation: \\n\\t' + errors.join('\\n\\t');\n}\nParameterValidationError.prototype = Object.create(InvalidRequestError.prototype);\nParameterValidationError.prototype.constructor = ParameterValidationError;\n\nexports.ParameterValidationError = ParameterValidationError;\n\n\nfunction DataTypeValidationError(message){\n  this.name = 'DataTypeValidationError';\n  this.message = message || 'Invalid data type';\n}\nDataTypeValidationError.prototype = Object.create(Error.prototype);\nDataTypeValidationError.prototype.constructor = DataTypeValidationError;\n\nexports.DataTypeValidationError = DataTypeValidationError;","'use strict';\n\nmodule.exports = function getRequestBody(operation, data, headers){\n  var body = operation.parameters.filter(function(param){\n    return param.paramType === 'body' && data[param.name] != null;\n  }).map(function(param){\n    return data[param.name];\n  })[0];\n\n  if(!(headers &&  headers['Content-Type'])) return body;\n\n  var contentType = headers['Content-Type'];\n  var presentFormParams = operation.parameters.filter(function(param){\n    return param.paramType === 'form' && data[param.name] != null;\n  });\n\n  if(contentType.indexOf('application/x-www-form-urlencoded') !== -1){\n    body = presentFormParams.map(function(param){\n      var key = param.name,\n        value = data[key];\n      return encodeURIComponent(key) + '=' + encodeURIComponent(value);\n    }).join('&');\n  } else if(contentType.indexOf('multipart/form-data') !== -1){\n    var randomness = Math.random().toString(16).substr(2);\n    var boundary = 'SwaggerBoundary' + randomness;\n    \n    body = presentFormParams.map(function(param){\n      var key = param.name,\n        value = data[key],\n        result = '--' + boundary;\n\n      result += '\\nContent-Disposition: form-data; name=\"' + key + '\"';\n      \n      if(value.contentType){\n        if(value.name){\n          result += '; filename=\"' + value.name + '\"';\n        }\n\n        result += '\\nContent-Type: ' + value.contentType;\n      }\n\n      if(value.contentTransferEncoding){\n        result += '\\nContent-Transfer-Encoding: ' + value.contentTransferEncoding;\n      }\n\n      if(value.body){\n        result += '\\n\\n' + value.body;\n      } else {\n        result += '\\n\\n' + value;\n      }\n\n      return result;\n    }).join('\\n');\n\n    body += '\\n--' + boundary + '--\\n';\n    \n    headers['Content-Type'] = contentType.replace(\n      'multipart/form-data', \n      'multipart/form-data; boundary=' + boundary\n    );\n  } else if(contentType.indexOf('application/json') !== -1){\n    if(typeof body !== 'string'){\n      body = JSON.stringify(body);\n    }\n  }\n\n  return body;\n};","'use strict';\n\nvar errorTypes = require('./errorTypes'),\n  ContentTypeNotSupportedError = errorTypes.ContentTypeNotSupportedError,\n  AcceptsNotSupportedError = errorTypes.AcceptsNotSupportedError;\n\nvar DEFAULT_ACCEPT = 'application/json';\nmodule.exports = function getRequestHeaders(operation, data, options){\n  data = data || {};\n  options = options || {};\n\n  var headers = {};\n\n  operation.parameters.forEach(function(param){\n    if(param.paramType === 'header' && data[param.name] != null){\n      headers[param.name] = data[param.name];\n    }\n  });\n\n  // Passed headers\n  if(options.headers){\n    Object.keys(options.headers).forEach(function(key){\n      headers[key] = options.headers[key];\n    });\n  }\n\n  // Content-Type\n  var contentType = options.contentType || getContentType(operation, data, options);\n  if(contentType) {\n    if(hasAccept(operation, contentType)){\n      headers['Content-Type'] = contentType;  \n    } else {\n      throw new ContentTypeNotSupportedError(contentType, operation);\n    }\n  }\n\n  // Accept\n  var accept = options.accept || DEFAULT_ACCEPT;\n  if(accept){\n    if(hasContentType(operation, accept)){\n      headers.Accept = accept;  \n    } else {\n      throw new AcceptsNotSupportedError(accept, operation);\n    }\n  }\n  \n  return headers;\n};\n\nfunction getContentType(operation, data){\n  var hasBody = operation.parameters.some(function(param){\n    return param.paramType === 'body' && data[param.name] !== undefined;\n  });\n\n  if (hasBody){\n    return 'application/json';\n  } else {\n    var hasFormParams = operation.parameters.some(function(param){\n      return param.paramType === 'form' && data[param.name] !== undefined;\n    });\n\n    var hasFileParam = hasFormParams && \n      operation.parameters.some(function(param){\n        return param.type === 'File' && data[param.name] !== undefined;\n      });\n\n    if(hasFileParam) return 'multipart/form-data';\n    else if(hasFormParams) return 'application/x-www-form-urlencoded';\n  }\n}\n\n// Accepts is an optional field in the spec, but must be enforced when present\nfunction hasAccept(operation, contentType){\n  var apiDeclaration = operation.apiObject.apiDeclaration;\n  var accepts = operation.consumes || apiDeclaration.consumes;\n\n  if(accepts && accepts.length){\n    return accepts.indexOf(contentType) !== -1;\n  } else {\n    return true;\n  }\n}\nexports.hasAccept = hasAccept;\n\n// Content-Type (produces) is an optional field in the spec, but must be enforced when present\nfunction hasContentType(operation, contentType){\n  var apiDeclaration = operation.apiObject.apiDeclaration,\n    contentTypes = operation.produces || apiDeclaration.produces;\n\n  if(contentTypes && contentTypes.length){\n    return contentTypes.indexOf(contentType) !== -1;\n  } else {\n    return true;\n  }\n}\nexports.hasContentType = hasContentType;","'use strict';\n\nvar errorTypes = require('./errorTypes'),\n  MissingPathParamsError = errorTypes.MissingPathParamsError;\n\nmodule.exports = function getRequestUrl(operation, data){\n  var url = getUrlTemplate(operation);\n\n  url = applyPathParams(url, operation, data);\n\n  if(!data) return url;\n\n  var queryParams = operation.parameters.filter(function(param){\n    return param.paramType === 'query' && data[param.name] !== undefined;\n  }).map(function(param){\n    var key = param.name;\n    return encodeURIComponent(key) + '=' + encodeURIComponent(data[key]);\n  }).join('&');\n\n  if(queryParams) url += '?' + queryParams;\n\n  return url;\n};\n\nfunction applyPathParams(url, operation, data){\n  var pathParams = operation.parameters.filter(function(param){\n    return param.paramType === 'path';\n  });\n\n  var missingParams = pathParams.filter(function(param){\n    return data[param.name] === undefined;\n  });\n\n  if(missingParams.length){\n    throw new MissingPathParamsError(missingParams.map(function(param){\n      return param.name;\n    }));\n  }\n\n  pathParams.forEach(function(param){\n    var key = param.name;\n    \n    var exp = new RegExp('{' + key + '[^}]*}', 'gi');\n\n    var value = data[key].toString();\n    delete data[key];\n    value = value.split('/').map(encodeURIComponent).join('/');\n\n    url = url.replace(exp, value);\n  });\n\n  return url;\n}\n\nfunction getUrlTemplate(operation){\n  var apiObject = operation.apiObject; \n\n  var basePath = apiObject.apiDeclaration.basePath;\n  var path = apiObject.path.replace('{format}', 'json');\n  \n  return basePath + path;\n}\n","'use strict';\n\n// Promise polyfill\nvar Promise = require('es6-promise').Promise;\nvar clientGenerator = require('swagger-client-generator');\n\nmodule.exports = function(schema){\n  return clientGenerator(schema, requestHandler);\n};\n\n// For mocking during unit testing\nif(typeof XMLHttpRequest !== 'undefined'){\n  module.exports.XMLHttpRequest = window.XMLHttpRequest;\n}\n\nfunction requestHandler(error, request){\n  var XMLHttpRequest = module.exports.XMLHttpRequest;\n  return new Promise(function(resolve, reject){\n    if(error) return reject(error);\n\n    var method = request.method;\n    var url = request.url;\n    var body = request.body;\n    var headers = request.headers;\n\n    var options = request.options;\n    var async = ('async' in options)? options.async : true;\n    var xhr = new XMLHttpRequest();\n\n    xhr.open(method, url, async);\n\n    if(headers){\n      Object.keys(headers).forEach(function(header){\n        xhr.setRequestHeader(header, headers[header]);\n      });\n    }\n    \n    if(options.withCredentials) xhr.withCredentials = options.withCredentials;\n    if(options.timeout) xhr.timeout = options.timeout;\n    if(options.onabort) xhr.onabort = options.onabort;\n    if(options.onerror) xhr.onerror = options.onerror;\n    if(options.onload) xhr.onload = options.onload;\n    if(options.ontimeout) xhr.ontimeout = options.ontimeout;\n    if(options.onprogress) xhr.onprogress = options.onprogress;\n\n    xhr.onloadend = function(){\n      var data = this.response;\n      var contentType = this.getResponseHeader('Content-Type');\n\n      if(contentType && contentType.indexOf('application/json') !== -1){\n        try {\n          data = JSON.parse(data);\n        } catch(error){\n          reject({ \n            error: error,\n            status: this.status,\n            data: data\n          });\n        }\n      }\n\n      if(this.status < 200 || this.status >= 300){\n        reject({\n          error: error,\n          status: this.status,\n          data: data\n        });\n      } else {\n        resolve(data);\n      }\n      \n      if(options.onloadend) options.onloadend.call(this);\n    };\n\n    xhr.send(body);\n  });\n}\n"]}
(27)
});