text: // swagger-client.js
  // version 2.1.0-alpha.3
  /**
   * Array Model
   **/
  var ArrayModel = function(definition) {
      this.name = "name";
      this.definition = definition || {};
      this.properties = [];
      this.type;
      this.ref;
  
      var requiredFields = definition.enum || [];
      var items = definition.items;
      if(items) {
          var type = items.type;
          if(items.type) {
              this.type = typeFromJsonSchema(type.type, type.format);
          }
          else {
              this.ref = items['$ref'];
          }
      }
  }
  
  ArrayModel.prototype.createJSONSample = function(modelsToIgnore) {
      var result;
      modelsToIgnore = (modelsToIgnore||{})
      if(this.type) {
          result = type;
      }
      else if (this.ref) {
          var name = simpleRef(this.ref);
          result = models[name].createJSONSample();
      }
      return [ result ];
  };
  
  ArrayModel.prototype.getSampleValue = function(modelsToIgnore) {
      var result;
      modelsToIgnore = (modelsToIgnore || {})
      if(this.type) {
          result = type;
      }
      else if (this.ref) {
          var name = simpleRef(this.ref);
          result = models[name].getSampleValue(modelsToIgnore);
      }
      return [ result ];
  }
  
  ArrayModel.prototype.getMockSignature = function(modelsToIgnore) {
      var propertiesStr = [];
  
      if(this.ref) {
          return models[simpleRef(this.ref)].getMockSignature();
      }
  };
  
  /**
   * SwaggerAuthorizations applys the correct authorization to an operation being executed
   */
  var SwaggerAuthorizations = function() {
      this.authz = {};
  };
  
  SwaggerAuthorizations.prototype.add = function(name, auth) {
      this.authz[name] = auth;
      return auth;
  };
  
  SwaggerAuthorizations.prototype.remove = function(name) {
      return delete this.authz[name];
  };
  
  SwaggerAuthorizations.prototype.apply = function(obj, authorizations) {
      var status = null;
      var key;
  
      // if the "authorizations" key is undefined, or has an empty array, add all keys
      if(typeof authorizations === 'undefined' || Object.keys(authorizations).length == 0) {
          for (key in this.authz) {
              value = this.authz[key];
              result = value.apply(obj, authorizations);
              if (result === true)
                  status = true;
          }
      }
      else {
          if(Array.isArray(authorizations)) {
              var i;
              for(i = 0; i < authorizations.length; i++) {
                  var auth = authorizations[i];
                  log(auth);
                  for (key in this.authz) {
                      var value = this.authz[key];
                      if(typeof value !== 'undefined') {
                          result = value.apply(obj, authorizations);
                          if (result === true)
                              status = true;
                      }
                  }
              }
          }
      }
  
      return status;
  };
  
  /**
   * ApiKeyAuthorization allows a query param or header to be injected
   */
  var ApiKeyAuthorization = function(name, value, type) {
      this.name = name;
      this.value = value;
      this.type = type;
  };
  
  ApiKeyAuthorization.prototype.apply = function(obj, authorizations) {
      if (this.type === "query") {
          if (obj.url.indexOf('?') > 0)
              obj.url = obj.url + "&" + this.name + "=" + this.value;
          else
              obj.url = obj.url + "?" + this.name + "=" + this.value;
          return true;
      } else if (this.type === "header") {
          obj.headers[this.name] = this.value;
          return true;
      }
  };
  
  var CookieAuthorization = function(cookie) {
      this.cookie = cookie;
  }
  
  CookieAuthorization.prototype.apply = function(obj, authorizations) {
      obj.cookieJar = obj.cookieJar || CookieJar();
      obj.cookieJar.setCookie(this.cookie);
      return true;
  }
  
  /**
   * Password Authorization is a basic auth implementation
   */
  var PasswordAuthorization = function(name, username, password) {
      this.name = name;
      this.username = username;
      this.password = password;
      this._btoa = null;
      if (typeof window !== 'undefined')
          this._btoa = btoa;
      else
          this._btoa = require("btoa");
  };
  
  PasswordAuthorization.prototype.apply = function(obj, authorizations) {
      var base64encoder = this._btoa;
      obj.headers["Authorization"] = "Basic " + base64encoder(this.username + ":" + this.password);
      return true;
  };var __bind = function(fn, me){
      return function(){
          return fn.apply(me, arguments);
      };
  };
  
  fail = function(message) {
      log(message);
  }
  
  log = function(){
      log.history = log.history || [];
      log.history.push(arguments);
      if(this.console){
          console.log( Array.prototype.slice.call(arguments)[0] );
      }
  };
  
  if (!Array.prototype.indexOf) {
      Array.prototype.indexOf = function(obj, start) {
          for (var i = (start || 0), j = this.length; i < j; i++) {
              if (this[i] === obj) { return i; }
          }
          return -1;
      }
  }
  
  if (!('filter' in Array.prototype)) {
      Array.prototype.filter= function(filter, that /*opt*/) {
          var other= [], v;
          for (var i=0, n= this.length; i<n; i++)
              if (i in this && filter.call(that, v= this[i], i, this))
                  other.push(v);
          return other;
      };
  }
  
  if (!('map' in Array.prototype)) {
      Array.prototype.map= function(mapper, that /*opt*/) {
          var other= new Array(this.length);
          for (var i= 0, n= this.length; i<n; i++)
              if (i in this)
                  other[i]= mapper.call(that, this[i], i, this);
          return other;
      };
  }
  
  Object.keys = Object.keys || (function () {
      var hasOwnProperty = Object.prototype.hasOwnProperty,
          hasDontEnumBug = !{toString:null}.propertyIsEnumerable("toString"),
          DontEnums = [
              'toString',
              'toLocaleString',
              'valueOf',
              'hasOwnProperty',
              'isPrototypeOf',
              'propertyIsEnumerable',
              'constructor'
          ],
          DontEnumsLength = DontEnums.length;
  
      return function (o) {
          if (typeof o != "object" && typeof o != "function" || o === null)
              throw new TypeError("Object.keys called on a non-object");
  
          var result = [];
          for (var name in o) {
              if (hasOwnProperty.call(o, name))
                  result.push(name);
          }
  
          if (hasDontEnumBug) {
              for (var i = 0; i < DontEnumsLength; i++) {
                  if (hasOwnProperty.call(o, DontEnums[i]))
                      result.push(DontEnums[i]);
              }
          }
  
          return result;
      };
  })();
  /**
   * PrimitiveModel
   **/
  var PrimitiveModel = function(definition) {
      this.name = "name";
      this.definition = definition || {};
      this.properties = [];
      this.type;
  
      var requiredFields = definition.enum || [];
      this.type = typeFromJsonSchema(definition.type, definition.format);
  }
  
  PrimitiveModel.prototype.createJSONSample = function(modelsToIgnore) {
      var result = this.type;
      return result;
  };
  
  PrimitiveModel.prototype.getSampleValue = function() {
      var result = this.type;
      return null;
  }
  
  PrimitiveModel.prototype.getMockSignature = function(modelsToIgnore) {
      var propertiesStr = [];
      var i;
      for (i = 0; i < this.properties.length; i++) {
          var prop = this.properties[i];
          propertiesStr.push(prop.toString());
      }
  
      var strong = '<span class="strong">';
      var stronger = '<span class="stronger">';
      var strongClose = '</span>';
      var classOpen = strong + this.name + ' {' + strongClose;
      var classClose = strong + '}' + strongClose;
      var returnVal = classOpen + '<div>' + propertiesStr.join(',</div><div>') + '</div>' + classClose;
  
      if (!modelsToIgnore)
          modelsToIgnore = {};
      modelsToIgnore[this.name] = this;
      var i;
      for (i = 0; i < this.properties.length; i++) {
          var prop = this.properties[i];
          var ref = prop['$ref'];
          var model = models[ref];
          if (model && typeof modelsToIgnore[ref] === 'undefined') {
              returnVal = returnVal + ('<br>' + model.getMockSignature(modelsToIgnore));
          }
      }
      return returnVal;
  };var SwaggerClient = function(url, options) {
      this.isBuilt = false;
      this.url = null;
      this.debug = false;
      this.basePath = null;
      this.authorizations = null;
      this.authorizationScheme = null;
      this.isValid = false;
      this.info = null;
      this.useJQuery = false;
      this.models = models;
  
      options = (options||{});
      if (url)
          if (url.url) options = url;
          else this.url = url;
      else options = url;
  
      if (options.url != null)
          this.url = options.url;
  
      if (options.success != null)
          this.success = options.success;
  
      if (typeof options.useJQuery === 'boolean')
          this.useJQuery = options.useJQuery;
  
      this.failure = options.failure != null ? options.failure : function() {};
      this.progress = options.progress != null ? options.progress : function() {};
      this.spec = options.spec;
  
      if (options.success != null)
          this.build();
  }
  
  SwaggerClient.prototype.build = function() {
      var self = this;
      this.progress('fetching resource list: ' + this.url);
      var obj = {
          useJQuery: this.useJQuery,
          url: this.url,
          method: "get",
          headers: {
              accept: "application/json, */*"
          },
          on: {
              error: function(response) {
                  if (self.url.substring(0, 4) !== 'http')
                      return self.fail('Please specify the protocol for ' + self.url);
                  else if (response.status === 0)
                      return self.fail('Can\'t read from server.  It may not have the appropriate access-control-origin settings.');
                  else if (response.status === 404)
                      return self.fail('Can\'t read swagger JSON from ' + self.url);
                  else
                      return self.fail(response.status + ' : ' + response.statusText + ' ' + self.url);
              },
              response: function(resp) {
                  var responseObj = resp.obj || JSON.parse(resp.data);
                  self.swaggerVersion = responseObj.swaggerVersion;
  
                  if(responseObj.swagger && parseInt(responseObj.swagger) === 2) {
                      self.swaggerVersion = responseObj.swagger;
                      self.buildFromSpec(responseObj);
                      self.isValid = true;
                  }
                  else {
                      self.isValid = false;
                      self.failure();
                  }
              }
          }
      };
      if(this.spec) {
          var self = this;
          setTimeout(function() { self.buildFromSpec(self.spec); }, 10);
      }
      else {
          var e = (typeof window !== 'undefined' ? window : exports);
          var status = e.authorizations.apply(obj);
          new SwaggerHttp().execute(obj);
      }
  
      return this;
  };
  
  SwaggerClient.prototype.buildFromSpec = function(response) {
      if(this.isBuilt) return this;
  
      this.info = response.info || {};
      this.title = response.title || '';
      this.host = response.host || '';
      this.schemes = response.schemes || [];
      this.scheme;
      this.basePath = response.basePath || '';
      this.apis = {};
      this.apisArray = [];
      this.consumes = response.consumes;
      this.produces = response.produces;
      this.securityDefinitions = response.securityDefinitions;
  
      // legacy support
      this.authSchemes = response.securityDefinitions;
  
      var location = this.parseUri(this.url);
      if(typeof this.schemes === 'undefined' || this.schemes.length === 0) {
          this.scheme = location.scheme;
      }
      else {
          this.scheme = this.schemes[0];
      }
  
      if(typeof this.host === 'undefined' || this.host === '') {
          this.host = location.host;
          if (location.port) {
              this.host = this.host + ':' + location.port;
          }
      }
  
      this.definitions = response.definitions;
      var key;
      for(key in this.definitions) {
          var model = new Model(key, this.definitions[key]);
          if(model) {
              models[key] = model;
          }
      }
  
      // get paths, create functions for each operationId
      var path;
      var operations = [];
      for(path in response.paths) {
          if(typeof response.paths[path] === 'object') {
              var httpMethod;
              for(httpMethod in response.paths[path]) {
                  if(['delete', 'get', 'head', 'options', 'patch', 'post', 'put'].indexOf(httpMethod) === -1) {
                      continue;
                  }
                  var operation = response.paths[path][httpMethod];
                  var tags = operation.tags;
                  if(typeof tags === 'undefined') {
                      operation.tags = [ 'default' ];
                      tags = operation.tags;
                  }
                  var operationId = this.idFromOp(path, httpMethod, operation);
                  var operationObject = new Operation (
                      this,
                      operationId,
                      httpMethod,
                      path,
                      operation,
                      this.definitions
                  );
                  // bind this operation's execute command to the api
                  if(tags.length > 0) {
                      var i;
                      for(i = 0; i < tags.length; i++) {
                          var tag = this.tagFromLabel(tags[i]);
                          var operationGroup = this[tag];
                          if(typeof operationGroup === 'undefined') {
                              this[tag] = [];
                              operationGroup = this[tag];
                              operationGroup.label = tag;
                              operationGroup.apis = [];
                              this[tag].help = this.help.bind(operationGroup);
                              this.apisArray.push(new OperationGroup(tag, operationObject));
                          }
                          operationGroup[operationId] = operationObject.execute.bind(operationObject);
                          operationGroup[operationId].help = operationObject.help.bind(operationObject);
                          operationGroup.apis.push(operationObject);
  
                          // legacy UI feature
                          var j;
                          var api;
                          for(j = 0; j < this.apisArray.length; j++) {
                              if(this.apisArray[j].tag === tag) {
                                  api = this.apisArray[j];
                              }
                          }
                          if(api) {
                              api.operationsArray.push(operationObject);
                          }
                      }
                  }
                  else {
                      log('no group to bind to');
                  }
              }
          }
      }
      this.isBuilt = true;
      if (this.success)
          this.success();
      return this;
  }
  
  SwaggerClient.prototype.parseUri = function(uri) {
      var urlParseRE = /^(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/;
      var parts = urlParseRE.exec(uri);
      return {
          scheme: parts[4].replace(':',''),
          host: parts[11],
          port: parts[12],
          path: parts[15]
      };
  }
  
  SwaggerClient.prototype.help = function() {
      var i;
      log('operations for the "' + this.label + '" tag');
      for(i = 0; i < this.apis.length; i++) {
          var api = this.apis[i];
          log('  * ' + api.nickname + ': ' + api.operation.summary);
      }
  }
  
  SwaggerClient.prototype.tagFromLabel = function(label) {
      return label;
  }
  
  SwaggerClient.prototype.idFromOp = function(path, httpMethod, op) {
      if(typeof op.operationId !== 'undefined') {
          return (op.operationId);
      }
      else {
          return path.substring(1).replace(/\//g, "_").replace(/\{/g, "").replace(/\}/g, "") + "_" + httpMethod;
      }
  }
  
  SwaggerClient.prototype.fail = function(message) {
      this.failure(message);
      throw message;
  };
  
  var OperationGroup = function(tag, operation) {
      this.tag = tag;
      this.path = tag;
      this.name = tag;
      this.operation = operation;
      this.operationsArray = [];
  
      this.description = operation.description || "";
  }
  
  var Operation = function(parent, operationId, httpMethod, path, args, definitions) {
      var errors = [];
      this.operation = args;
      this.deprecated = args.deprecated;
      this.consumes = args.consumes;
      this.produces = args.produces;
      this.parent = parent;
      this.host = parent.host;
      this.schemes = parent.schemes;
      this.scheme = parent.scheme || 'http';
      this.basePath = parent.basePath;
      this.nickname = (operationId||errors.push('Operations must have a nickname.'));
      this.method = (httpMethod||errors.push('Operation ' + operationId + ' is missing method.'));
      this.path = (path||errors.push('Operation ' + nickname + ' is missing path.'));
      this.parameters = args != null ? (args.parameters||[]) : {};
      this.summary = args.summary || '';
      this.responses = (args.responses||{});
      this.type = null;
      this.security = args.security;
      this.authorizations = args.security;
      this.description = args.description;
  
      var i;
      for(i = 0; i < this.parameters.length; i++) {
          var param = this.parameters[i];
          if(param.type === 'array') {
              param.isList = true;
              param.allowMultiple = true;
          }
          var innerType = this.getType(param);
          if(innerType && innerType.toString().toLowerCase() === 'boolean') {
              param.allowableValues = {};
              param.isList = true;
              param.enum = ["true", "false"];
          }
          if(typeof param.enum !== 'undefined') {
              var id;
              param.allowableValues = {};
              param.allowableValues.values = [];
              param.allowableValues.descriptiveValues = [];
              for(id = 0; id < param.enum.length; id++) {
                  var value = param.enum[id];
                  var isDefault = (value === param.default) ? true : false;
                  param.allowableValues.values.push(value);
                  param.allowableValues.descriptiveValues.push({value : value, isDefault: isDefault});
              }
          }
          if(param.type === 'array' && typeof param.allowableValues === 'undefined') {
              // can't show as a list if no values to select from
              delete param.isList;
              delete param.allowMultiple;
          }
          param.signature = this.getSignature(innerType, models);
          param.sampleJSON = this.getSampleJSON(innerType, models);
          param.responseClassSignature = param.signature;
      }
  
      var response;
      var model;
      var responses = this.responses;
  
      if(responses['200']) {
          response = responses['200'];
          defaultResponseCode = '200';
      }
      else if(responses['201']) {
          response = responses['201'];
          defaultResponseCode = '201';
      }
      else if(responses['202']) {
          response = responses['202'];
          defaultResponseCode = '202';
      }
      else if(responses['203']) {
          response = responses['203'];
          defaultResponseCode = '203';
      }
      else if(responses['204']) {
          response = responses['204'];
          defaultResponseCode = '204';
      }
      else if(responses['205']) {
          response = responses['205'];
          defaultResponseCode = '205';
      }
      else if(responses['206']) {
          response = responses['206'];
          defaultResponseCode = '206';
      }
      else if(responses['default']) {
          response = responses['default'];
          defaultResponseCode = 'default';
      }
  
      if(response && response.schema) {
          var resolvedModel = this.resolveModel(response.schema, definitions);
          if(resolvedModel) {
              this.type = resolvedModel.name;
              this.responseSampleJSON = JSON.stringify(resolvedModel.getSampleValue(), null, 2);
              this.responseClassSignature = resolvedModel.getMockSignature();
              delete responses[defaultResponseCode];
          }
          else {
              this.type = response.schema.type;
          }
      }
  
      if (errors.length > 0)
          this.resource.api.fail(errors);
  
      return this;
  }
  
  OperationGroup.prototype.sort = function(sorter) {
  
  }
  
  Operation.prototype.getType = function (param) {
      var type = param.type;
      var format = param.format;
      var isArray = false;
      var str;
      if(type === 'integer' && format === 'int32')
          str = 'integer';
      else if(type === 'integer' && format === 'int64')
          str = 'long';
      else if(type === 'integer' && typeof format === 'undefined')
          str = 'long';
      else if(type === 'string' && format === 'date-time')
          str = 'date-time';
      else if(type === 'string' && format === 'date')
          str = 'date';
      else if(type === 'number' && format === 'float')
          str = 'float';
      else if(type === 'number' && format === 'double')
          str = 'double';
      else if(type === 'number' && typeof format === 'undefined')
          str = 'double';
      else if(type === 'boolean')
          str = 'boolean';
      else if(type === 'string')
          str = 'string';
      else if(type === 'array') {
          isArray = true;
          if(param.items)
              str = this.getType(param.items);
      }
      if(param['$ref'])
          str = param['$ref'];
  
      var schema = param.schema;
      if(schema) {
          var ref = schema['$ref'];
          if(ref) {
              ref = simpleRef(ref);
              if(isArray)
                  return [ ref ];
              else
                  return ref;
          }
          else
              return this.getType(schema);
      }
      if(isArray)
          return [ str ];
      else
          return str;
  }
  
  Operation.prototype.resolveModel = function (schema, definitions) {
      if(typeof schema['$ref'] !== 'undefined') {
          var ref = schema['$ref'];
          if(ref.indexOf('#/definitions/') == 0)
              ref = ref.substring('#/definitions/'.length);
          if(definitions[ref])
              return new Model(ref, definitions[ref]);
      }
      if(schema.type === 'array')
          return new ArrayModel(schema);
      else
          return null;
  }
  
  Operation.prototype.help = function() {
      log(this.nickname + ': ' + this.operation.summary);
      for(var i = 0; i < this.parameters.length; i++) {
          var param = this.parameters[i];
          log('  * ' + param.name + ': ' + param.description);
      }
  }
  
  Operation.prototype.getSignature = function(type, models) {
      var isPrimitive, listType;
  
      if(type instanceof Array) {
          listType = true;
          type = type[0];
      }
  
      if(type === 'string')
          isPrimitive = true
      else
          isPrimitive = ((listType != null) && models[listType]) || (models[type] != null) ? false : true;
      if (isPrimitive) {
          return type;
      } else {
          if (listType != null)
              return models[type].getMockSignature();
          else
              return models[type].getMockSignature();
      }
  };
  
  /**
   * gets sample response for a single operation
   **/
  Operation.prototype.getSampleJSON = function(type, models) {
      var isPrimitive, listType, sampleJson;
  
      listType = (type instanceof Array);
      isPrimitive = (models[type] != null) ? false : true;
      sampleJson = isPrimitive ? void 0 : models[type].createJSONSample();
  
      if (sampleJson) {
          sampleJson = listType ? [sampleJson] : sampleJson;
          if(typeof sampleJson == 'string')
              return sampleJson;
          else if(typeof sampleJson === 'object') {
              var t = sampleJson;
              if(sampleJson instanceof Array && sampleJson.length > 0) {
                  t = sampleJson[0];
              }
              if(t.nodeName) {
                  var xmlString = new XMLSerializer().serializeToString(t);
                  return this.formatXml(xmlString);
              }
              else
                  return JSON.stringify(sampleJson, null, 2);
          }
          else
              return sampleJson;
      }
  };
  
  /**
   * legacy binding
   **/
  Operation.prototype["do"] = function(args, opts, callback, error, parent) {
      return this.execute(args, opts, callback, error, parent);
  }
  
  /**
   * executes an operation
   **/
  Operation.prototype.execute = function(arg1, arg2, arg3, arg4, parent) {
      var args = (arg1||{});
      var opts = {}, success, error;
      if(typeof arg2 === 'object') {
          opts = arg2;
          success = arg3;
          error = arg4;
      }
      if(typeof arg2 === 'function') {
          success = arg2;
          error = arg3;
      }
  
      var formParams = {};
      var headers = {};
      var requestUrl = this.path;
  
      success = (success||log)
      error = (error||log)
  
      var requiredParams = [];
      var missingParams = [];
      // check required params, track the ones that are missing
      var i;
      for(i = 0; i < this.parameters.length; i++) {
          var param = this.parameters[i];
          if(param.required === true) {
              requiredParams.push(param.name);
              if(typeof args[param.name] === 'undefined')
                  missingParams = param.name;
          }
      }
  
      if(missingParams.length > 0) {
          var message = 'missing required params: ' + missingParams;
          fail(message);
          return;
      }
  
      // set content type negotiation
      var consumes = this.consumes || this.parent.consumes || [ 'application/json' ];
      var produces = this.produces || this.parent.produces || [ 'application/json' ];
  
      headers = this.setContentTypes(args, opts);
  
      // grab params from the args, build the querystring along the way
      var querystring = "";
      for(var i = 0; i < this.parameters.length; i++) {
          var param = this.parameters[i];
          if(typeof args[param.name] !== 'undefined') {
              if(param.in === 'path') {
                  var reg = new RegExp('\{' + param.name + '[^\}]*\}', 'gi');
                  requestUrl = requestUrl.replace(reg, this.encodePathParam(args[param.name]));
              }
              else if (param.in === 'query' && typeof args[param.name] !== 'undefined') {
                  if(querystring === '')
                      querystring += '?';
                  else
                      querystring += '&';
                  if(typeof param.collectionFormat !== 'undefined') {
                      var qp = args[param.name];
                      if(Array.isArray(qp))
                          querystring += this.encodeCollection(param.collectionFormat, param.name, qp);
                      else
                          querystring += this.encodeQueryParam(param.name) + '=' + this.encodeQueryParam(args[param.name]);
                  }
                  else
                      querystring += this.encodeQueryParam(param.name) + '=' + this.encodeQueryParam(args[param.name]);
              }
              else if (param.in === 'header')
                  headers[param.name] = args[param.name];
              else if (param.in === 'formData')
                  formParams[param.name] = args[param.name];
              else if (param.in === 'body')
                  args.body = args[param.name];
          }
      }
      // handle form params
      if(headers['Content-Type'] === 'application/x-www-form-urlencoded') {
          var encoded = "";
          var key;
          for(key in formParams) {
              value = formParams[key];
              if(typeof value !== 'undefined'){
                  if(encoded !== "")
                      encoded += "&";
                  encoded += encodeURIComponent(key) + '=' + encodeURIComponent(value);
              }
          }
          // todo append?
          args.body = encoded;
      }
      var url = this.scheme + '://' + this.host + this.basePath + requestUrl + querystring;
  
      var obj = {
          url: url,
          method: this.method,
          body: args.body,
          useJQuery: this.useJQuery,
          headers: headers,
          on: {
              response: function(response) {
                  return success(response, parent);
              },
              error: function(response) {
                  return error(response, parent);
              }
          }
      };
      var status = e.authorizations.apply(obj, this.operation.security);
      new SwaggerHttp().execute(obj);
  }
  
  Operation.prototype.setContentTypes = function(args, opts) {
      // default type
      var accepts = 'application/json';
      var consumes = 'application/json';
  
      var allDefinedParams = this.parameters;
      var definedFormParams = [];
      var definedFileParams = [];
      var body = args.body;
      var headers = {};
  
      // get params from the operation and set them in definedFileParams, definedFormParams, headers
      var i;
      for(i = 0; i < allDefinedParams.length; i++) {
          var param = allDefinedParams[i];
          if(param.in === 'formData')
              definedFormParams.push(param);
          else if(param.in === 'file')
              definedFileParams.push(param);
          else if(param.in === 'header' && this.headers) {
              var key = param.name;
              var headerValue = this.headers[param.name];
              if(typeof this.headers[param.name] !== 'undefined')
                  headers[key] = headerValue;
          }
      }
  
      // if there's a body, need to set the accepts header via requestContentType
      if (body && (this.type === 'post' || this.type === 'put' || this.type === 'patch' || this.type === 'delete')) {
          if (opts.requestContentType)
              consumes = opts.requestContentType;
      } else {
          // if any form params, content type must be set
          if(definedFormParams.length > 0) {
              if(definedFileParams.length > 0)
                  consumes = 'multipart/form-data';
              else
                  consumes = 'application/x-www-form-urlencoded';
          }
          else if (this.type == 'DELETE')
              body = '{}';
          else if (this.type != 'DELETE')
              accepts = null;
      }
  
      if (consumes && this.consumes) {
          if (this.consumes.indexOf(consumes) === -1) {
              log('server doesn\'t consume ' + consumes + ', try ' + JSON.stringify(this.consumes));
              consumes = this.operation.consumes[0];
          }
      }
  
      if (opts.responseContentType) {
          accepts = opts.responseContentType;
      } else {
          accepts = 'application/json';
      }
      if (accepts && this.produces) {
          if (this.produces.indexOf(accepts) === -1) {
              log('server can\'t produce ' + accepts);
              accepts = this.produces[0];
          }
      }
  
      if ((consumes && body !== '') || (consumes === 'application/x-www-form-urlencoded'))
          headers['Content-Type'] = consumes;
      if (accepts)
          headers['Accept'] = accepts;
      return headers;
  }
  
  Operation.prototype.encodeCollection = function(type, name, value) {
      var encoded = '';
      var i;
      if(type === 'default' || type === 'multi') {
          for(i = 0; i < value.length; i++) {
              if(i > 0) encoded += '&'
              encoded += this.encodeQueryParam(name) + '=' + this.encodeQueryParam(value[i]);
          }
      }
      else {
          var separator = '';
          if(type === 'csv')
              separator = ',';
          else if(type === 'ssv')
              separator = '%20';
          else if(type === 'tsv')
              separator = '\\t';
          else if(type === 'pipes')
              separator = '|';
          if(separator !== '') {
              for(i = 0; i < value.length; i++) {
                  if(i == 0)
                      encoded = this.encodeQueryParam(name) + '=' + this.encodeQueryParam(value[i]);
                  else
                      encoded += separator + this.encodeQueryParam(value[i]);
              }
          }
      }
      // TODO: support the different encoding schemes here
      return encoded;
  }
  
  /**
   * TODO this encoding needs to be changed
   **/
  Operation.prototype.encodeQueryParam = function(arg) {
      return escape(arg);
  }
  
  /**
   * TODO revisit, might not want to leave '/'
   **/
  Operation.prototype.encodePathParam = function(pathParam) {
      var encParts, part, parts, _i, _len;
      pathParam = pathParam.toString();
      if (pathParam.indexOf('/') === -1) {
          return encodeURIComponent(pathParam);
      } else {
          parts = pathParam.split('/');
          encParts = [];
          for (_i = 0, _len = parts.length; _i < _len; _i++) {
              part = parts[_i];
              encParts.push(encodeURIComponent(part));
          }
          return encParts.join('/');
      }
  };
  
  var Model = function(name, definition) {
      this.name = name;
      this.definition = definition || {};
      this.properties = [];
      var requiredFields = definition.required || [];
  
      var key;
      var props = definition.properties;
      if(props) {
          for(key in props) {
              var required = false;
              var property = props[key];
              if(requiredFields.indexOf(key) >= 0)
                  required = true;
              this.properties.push(new Property(key, property, required));
          }
      }
  }
  
  Model.prototype.createJSONSample = function(modelsToIgnore) {
      var result = {};
      modelsToIgnore = (modelsToIgnore||{})
      modelsToIgnore[this.name] = this;
      var i;
      for (i = 0; i < this.properties.length; i++) {
          prop = this.properties[i];
          result[prop.name] = prop.getSampleValue(modelsToIgnore);
      }
      delete modelsToIgnore[this.name];
      return result;
  };
  
  Model.prototype.getSampleValue = function(modelsToIgnore) {
      var i;
      var obj = {};
      for(i = 0; i < this.properties.length; i++ ) {
          var property = this.properties[i];
          obj[property.name] = property.sampleValue(false, modelsToIgnore);
      }
      return obj;
  }
  
  Model.prototype.getMockSignature = function(modelsToIgnore) {
      var propertiesStr = [];
      var i;
      for (i = 0; i < this.properties.length; i++) {
          var prop = this.properties[i];
          propertiesStr.push(prop.toString());
      }
  
      var strong = '<span class="strong">';
      var stronger = '<span class="stronger">';
      var strongClose = '</span>';
      var classOpen = strong + this.name + ' {' + strongClose;
      var classClose = strong + '}' + strongClose;
      var returnVal = classOpen + '<div>' + propertiesStr.join(',</div><div>') + '</div>' + classClose;
      if (!modelsToIgnore)
          modelsToIgnore = {};
  
      modelsToIgnore[this.name] = this;
      var i;
      for (i = 0; i < this.properties.length; i++) {
          var prop = this.properties[i];
          var ref = prop['$ref'];
          var model = models[ref];
          if (model && typeof modelsToIgnore[model.name] === 'undefined') {
              returnVal = returnVal + ('<br>' + model.getMockSignature(modelsToIgnore));
          }
      }
      return returnVal;
  };
  
  var Property = function(name, obj, required) {
      this.schema = obj;
      this.required = required;
      if(obj['$ref'])
          this['$ref'] = simpleRef(obj['$ref']);
      else if (obj.type === 'array') {
          if(obj.items['$ref'])
              this['$ref'] = simpleRef(obj.items['$ref']);
          else
              obj = obj.items;
      }
      this.name = name;
      this.description = obj.description;
      this.obj = obj;
      this.optional = true;
      this.default = obj.default || null;
      this.example = obj.example || null;
  }
  
  Property.prototype.getSampleValue = function (modelsToIgnore) {
      return this.sampleValue(false, modelsToIgnore);
  }
  
  Property.prototype.isArray = function () {
      var schema = this.schema;
      if(schema.type === 'array')
          return true;
      else
          return false;
  }
  
  Property.prototype.sampleValue = function(isArray, ignoredModels) {
      isArray = (isArray || this.isArray());
      ignoredModels = (ignoredModels || {});
      var type = getStringSignature(this.obj);
      var output;
  
      if(this['$ref']) {
          var refModelName = simpleRef(this['$ref']);
          var refModel = models[refModelName];
          if(refModel && typeof ignoredModels[type] === 'undefined') {
              ignoredModels[type] = this;
              output = refModel.getSampleValue(ignoredModels);
          }
          else
              type = refModel;
      }
      else if(this.example)
          output = this.example;
      else if(this.default)
          output = this.default;
      else if(type === 'date-time')
          output = new Date().toISOString();
      else if(type === 'string')
          output = 'string';
      else if(type === 'integer')
          output = 0;
      else if(type === 'long')
          output = 0;
      else if(type === 'float')
          output = 0.0;
      else if(type === 'double')
          output = 0.0;
      else if(type === 'boolean')
          output = true;
      else
          output = {};
      ignoredModels[type] = output;
      if(isArray)
          return [output];
      else
          return output;
  }
  
  getStringSignature = function(obj) {
      var str = '';
      if(obj.type === 'array') {
          obj = (obj.items || obj['$ref'] || {});
          str += 'Array[';
      }
      if(obj.type === 'integer' && obj.format === 'int32')
          str += 'integer';
      else if(obj.type === 'integer' && obj.format === 'int64')
          str += 'long';
      else if(obj.type === 'integer' && typeof obj.format === 'undefined')
          str += 'long';
      else if(obj.type === 'string' && obj.format === 'date-time')
          str += 'date-time';
      else if(obj.type === 'string' && obj.format === 'date')
          str += 'date';
      else if(obj.type === 'number' && obj.format === 'float')
          str += 'float';
      else if(obj.type === 'number' && obj.format === 'double')
          str += 'double';
      else if(obj.type === 'number' && typeof obj.format === 'undefined')
          str += 'double';
      else if(obj.type === 'boolean')
          str += 'boolean';
      else if(obj['$ref'])
          str += simpleRef(obj['$ref']);
      else
          str += obj.type;
      if(obj.type === 'array')
          str += ']';
      return str;
  }
  
  simpleRef = function(name) {
      if(typeof name === 'undefined')
          return null;
      if(name.indexOf("#/definitions/") === 0)
          return name.substring('#/definitions/'.length)
      else
          return name;
  }
  
  Property.prototype.toString = function() {
      var str = getStringSignature(this.obj);
      if(str !== '') {
          str = '<span class="propName ' + this.required + '">' + this.name + '</span> (<span class="propType">' + str + '</span>';
          if(!this.required)
              str += ', <span class="propOptKey">optional</span>';
          str += ')';
      }
      else
          str = this.name + ' (' + JSON.stringify(this.obj) + ')';
  
      if(typeof this.description !== 'undefined')
          str += ': ' + this.description;
      return str;
  }
  
  typeFromJsonSchema = function(type, format) {
      var str;
      if(type === 'integer' && format === 'int32')
          str = 'integer';
      else if(type === 'integer' && format === 'int64')
          str = 'long';
      else if(type === 'integer' && typeof format === 'undefined')
          str = 'long';
      else if(type === 'string' && format === 'date-time')
          str = 'date-time';
      else if(type === 'string' && format === 'date')
          str = 'date';
      else if(type === 'number' && format === 'float')
          str = 'float';
      else if(type === 'number' && format === 'double')
          str = 'double';
      else if(type === 'number' && typeof format === 'undefined')
          str = 'double';
      else if(type === 'boolean')
          str = 'boolean';
      else if(type === 'string')
          str = 'string';
  
      return str;
  }
  
  var e = (typeof window !== 'undefined' ? window : exports);
  
  var sampleModels = {};
  var cookies = {};
  var models = {};
  
  e.authorizations = new SwaggerAuthorizations();
  e.ApiKeyAuthorization = ApiKeyAuthorization;
  e.PasswordAuthorization = PasswordAuthorization;
  e.CookieAuthorization = CookieAuthorization;
  e.SwaggerClient = SwaggerClient;
  
  /**
   * SwaggerHttp is a wrapper for executing requests
   */
  var SwaggerHttp = function() {};
  
  SwaggerHttp.prototype.execute = function(obj) {
      if(obj && (typeof obj.useJQuery === 'boolean'))
          this.useJQuery = obj.useJQuery;
      else
          this.useJQuery = this.isIE8();
  
      if(this.useJQuery)
          return new JQueryHttpClient().execute(obj);
      else
          return new ShredHttpClient().execute(obj);
  }
  
  SwaggerHttp.prototype.isIE8 = function() {
      var detectedIE = false;
      if (typeof navigator !== 'undefined' && navigator.userAgent) {
          nav = navigator.userAgent.toLowerCase();
          if (nav.indexOf('msie') !== -1) {
              var version = parseInt(nav.split('msie')[1]);
              if (version <= 8) {
                  detectedIE = true;
              }
          }
      }
      return detectedIE;
  };
  
  /*
   * JQueryHttpClient lets a browser take advantage of JQuery's cross-browser magic.
   * NOTE: when jQuery is available it will export both '$' and 'jQuery' to the global space.
   *       Since we are using closures here we need to alias it for internal use.
   */
  var JQueryHttpClient = function(options) {
      "use strict";
      if(!jQuery){
          var jQuery = window.jQuery;
      }
  }
  
  JQueryHttpClient.prototype.execute = function(obj) {
      var cb = obj.on;
      var request = obj;
  
      obj.type = obj.method;
      obj.cache = false;
  
      obj.beforeSend = function(xhr) {
          var key, results;
          if (obj.headers) {
              results = [];
              var key;
              for (key in obj.headers) {
                  if (key.toLowerCase() === "content-type") {
                      results.push(obj.contentType = obj.headers[key]);
                  } else if (key.toLowerCase() === "accept") {
                      results.push(obj.accepts = obj.headers[key]);
                  } else {
                      results.push(xhr.setRequestHeader(key, obj.headers[key]));
                  }
              }
              return results;
          }
      };
  
      obj.data = obj.body;
      obj.complete = function(response, textStatus, opts) {
          var headers = {},
              headerArray = response.getAllResponseHeaders().split("\n");
  
          for(var i = 0; i < headerArray.length; i++) {
              var toSplit = headerArray[i].trim();
              if(toSplit.length === 0)
                  continue;
              var separator = toSplit.indexOf(":");
              if(separator === -1) {
                  // Name but no value in the header
                  headers[toSplit] = null;
                  continue;
              }
              var name = toSplit.substring(0, separator).trim(),
                  value = toSplit.substring(separator + 1).trim();
              headers[name] = value;
          }
  
          var out = {
              url: request.url,
              method: request.method,
              status: response.status,
              data: response.responseText,
              headers: headers
          };
  
          var contentType = (headers["content-type"]||headers["Content-Type"]||null)
  
          if(contentType != null) {
              if(contentType.indexOf("application/json") == 0 || contentType.indexOf("+json") > 0) {
                  if(response.responseText && response.responseText !== "")
                      out.obj = JSON.parse(response.responseText);
                  else
                      out.obj = {}
              }
          }
  
          if(response.status >= 200 && response.status < 300)
              cb.response(out);
          else if(response.status === 0 || (response.status >= 400 && response.status < 599))
              cb.error(out);
          else
              return cb.response(out);
      };
  
      jQuery.support.cors = true;
      return jQuery.ajax(obj);
  }
  
  /*
   * ShredHttpClient is a light-weight, node or browser HTTP client
   */
  var ShredHttpClient = function(options) {
      this.options = (options||{});
      this.isInitialized = false;
  
      var identity, toString;
  
      if (typeof window !== 'undefined') {
          this.Shred = require("./shred");
          this.content = require("./shred/content");
      }
      else
          this.Shred = require("shred");
      this.shred = new this.Shred(options);
  }
  
  ShredHttpClient.prototype.initShred = function () {
      this.isInitialized = true;
      this.registerProcessors(this.shred);
  }
  
  ShredHttpClient.prototype.registerProcessors = function(shred) {
      var identity = function(x) {
          return x;
      };
      var toString = function(x) {
          return x.toString();
      };
  
      if (typeof window !== 'undefined') {
          this.content.registerProcessor(["application/json; charset=utf-8", "application/json", "json"], {
              parser: identity,
              stringify: toString
          });
      } else {
          this.Shred.registerProcessor(["application/json; charset=utf-8", "application/json", "json"], {
              parser: identity,
              stringify: toString
          });
      }
  }
  
  ShredHttpClient.prototype.execute = function(obj) {
      if(!this.isInitialized)
          this.initShred();
  
      var cb = obj.on, res;
  
      var transform = function(response) {
          var out = {
              headers: response._headers,
              url: response.request.url,
              method: response.request.method,
              status: response.status,
              data: response.content.data
          };
  
          var contentType = (response._headers["content-type"]||response._headers["Content-Type"]||null)
  
          if(contentType != null) {
              if(contentType.indexOf("application/json") == 0 || contentType.indexOf("+json") > 0) {
                  if(response.content.data && response.content.data !== "")
                      try{
                          out.obj = JSON.parse(response.content.data);
                      }
                      catch (e) {
                          // unable to parse
                      }
                  else
                      out.obj = {}
              }
          }
          return out;
      };
  
      res = {
          error: function(response) {
              if (obj)
                  return cb.error(transform(response));
          },
          redirect: function(response) {
              if (obj)
                  return cb.redirect(transform(response));
          },
          307: function(response) {
              if (obj)
                  return cb.redirect(transform(response));
          },
          response: function(response) {
              if (obj)
                  return cb.response(transform(response));
          }
      };
      if (obj) {
          obj.on = res;
      }
      return this.shred.request(obj);
  };