new swagger and url logic

code/moya-web/WebContent/swagger/css/screen.css

@@ -743,17 +743,20 @@
   display: inline-block;
   display: inline-block;
   font-size: 0.9em;
   font-size: 0.9em;
 }
 }
-.swagger-section .swagger-ui-wrap ul#resources li.resource ul.endpoints li.endpoint ul.operations li.operation div.content div.sandbox_header img {
-  display: block;
-  clear: none;
-  float: right;
-}
 .swagger-section .swagger-ui-wrap ul#resources li.resource ul.endpoints li.endpoint ul.operations li.operation div.content div.sandbox_header input.submit {
 .swagger-section .swagger-ui-wrap ul#resources li.resource ul.endpoints li.endpoint ul.operations li.operation div.content div.sandbox_header input.submit {
   display: block;
   display: block;
   clear: none;
   clear: none;
   float: left;
   float: left;
   padding: 6px 8px;
   padding: 6px 8px;
 }
 }
+.swagger-section .swagger-ui-wrap ul#resources li.resource ul.endpoints li.endpoint ul.operations li.operation div.content div.sandbox_header span.response_throbber {
+  background-image: url('../images/throbber.gif');
+  width: 128px;
+  height: 16px;
+  display: block;
+  clear: none;
+  float: right;
+}
 .swagger-section .swagger-ui-wrap ul#resources li.resource ul.endpoints li.endpoint ul.operations li.operation div.content form input[type='text'].error {
 .swagger-section .swagger-ui-wrap ul#resources li.resource ul.endpoints li.endpoint ul.operations li.operation div.content form input[type='text'].error {
   outline: 2px solid black;
   outline: 2px solid black;
   outline-color: #cc0000;
   outline-color: #cc0000;

code/moya-web/WebContent/swagger/index.html

@@ -16,49 +16,65 @@
   <script src='lib/underscore-min.js' type='text/javascript'></script>
   <script src='lib/underscore-min.js' type='text/javascript'></script>
   <script src='lib/backbone-min.js' type='text/javascript'></script>
   <script src='lib/backbone-min.js' type='text/javascript'></script>
   <script src='lib/swagger.js' type='text/javascript'></script>
   <script src='lib/swagger.js' type='text/javascript'></script>
+  <script src='lib/swagger-client.js' type='text/javascript'></script>
   <script src='swagger-ui.js' type='text/javascript'></script>
   <script src='swagger-ui.js' type='text/javascript'></script>
   <script src='lib/highlight.7.3.pack.js' type='text/javascript'></script>
   <script src='lib/highlight.7.3.pack.js' type='text/javascript'></script>
 
 
   <!-- enabling this will enable oauth2 implicit scope support -->
   <!-- enabling this will enable oauth2 implicit scope support -->
   <script src='lib/swagger-oauth.js' type='text/javascript'></script>
   <script src='lib/swagger-oauth.js' type='text/javascript'></script>
-
   <script type="text/javascript">
   <script type="text/javascript">
     $(function () {
     $(function () {
+      var url = window.location.protocol + '//' + window.location.host + '/MoyaWeb/rest/api-docs';
+      if (!url || url.length < 1) {
+        url = "http://localhost:8080/MoyaWeb/rest/api-docs";
+      }
       window.swaggerUi = new SwaggerUi({
       window.swaggerUi = new SwaggerUi({
-      url: "http://localhost:8080/MoyaWeb/rest/api-docs",
-      dom_id: "swagger-ui-container",
-      supportedSubmitMethods: ['get', 'post', 'put', 'delete'],
-      onComplete: function(swaggerApi, swaggerUi){
-        log("Loaded SwaggerUI");
-
-        if(typeof initOAuth == "function") {
-          /*
-          initOAuth({
-            clientId: "your-client-id",
-            realm: "your-realms",
-            appName: "your-app-name"
+        url: url,
+        dom_id: "swagger-ui-container",
+        supportedSubmitMethods: ['get', 'post', 'put', 'delete'],
+        onComplete: function(swaggerApi, swaggerUi){
+          log("Loaded SwaggerUI");
+          if(typeof initOAuth == "function") {
+            /*
+            initOAuth({
+              clientId: "your-client-id",
+              realm: "your-realms",
+              appName: "your-app-name"
+            });
+            */
+          }
+          $('pre code').each(function(i, e) {
+            hljs.highlightBlock(e)
           });
           });
-          */
-        }
-        $('pre code').each(function(i, e) {
-          hljs.highlightBlock(e)
-        });
-      },
-      onFailure: function(data) {
-        log("Unable to Load SwaggerUI");
-      },
-      docExpansion: "none"
-    });
+        },
+        onFailure: function(data) {
+          log("Unable to Load SwaggerUI");
+        },
+        docExpansion: "none",
+        sorter : "alpha"
+      });
 
 
-    $('#input_apiKey').change(function() {
-      var key = $('#input_apiKey')[0].value;
-      log("key: " + key);
-      if(key && key.trim() != "") {
-        log("added key " + key);
-        window.authorizations.add("key", new ApiKeyAuthorization("api_key", key, "query"));
+      function addApiKeyAuthorization() {
+        var key = $('#input_apiKey')[0].value;
+        log("key: " + key);
+        if(key && key.trim() != "") {
+            log("added key " + key);
+            window.authorizations.add("api_key", new ApiKeyAuthorization("api_key", key, "query"));
+        }
       }
       }
-    })
-    window.swaggerUi.load();
+
+      $('#input_apiKey').change(function() {
+        addApiKeyAuthorization();
+      });
+
+      // if you have an apiKey you would like to pre-populate on the page for demonstration purposes...
+      /*
+        var apiKey = "myApiKeyXXXX123456789";
+        $('#input_apiKey').val(apiKey);
+        addApiKeyAuthorization();
+      */
+
+      window.swaggerUi.load();
   });
   });
   </script>
   </script>
 </head>
 </head>
@@ -66,14 +82,8 @@
 <body class="swagger-section">
 <body class="swagger-section">
 <div id='header'>
 <div id='header'>
   <div class="swagger-ui-wrap">
   <div class="swagger-ui-wrap">
-    <a id="logo" href="http://swagger.wordnik.com">swagger</a>
+    <a id="logo" href="http://swagger.io">swagger</a>
     <form id='api_selector'>
     <form id='api_selector'>
-      <div class='input icon-btn'>
-        <img id="show-pet-store-icon" src="images/pet_store_api.png" title="Show Swagger Petstore Example Apis">
-      </div>
-      <div class='input icon-btn'>
-        <img id="show-wordnik-dev-icon" src="images/wordnik_api.png" title="Show Wordnik Developer Apis">
-      </div>
       <div class='input'><input placeholder="http://example.com/api" id="input_baseUrl" name="baseUrl" type="text"/></div>
       <div class='input'><input placeholder="http://example.com/api" id="input_baseUrl" name="baseUrl" type="text"/></div>
       <div class='input'><input placeholder="api_key" id="input_apiKey" name="apiKey" type="text"/></div>
       <div class='input'><input placeholder="api_key" id="input_apiKey" name="apiKey" type="text"/></div>
       <div class='input'><a id="explore" href="#">Explore</a></div>
       <div class='input'><a id="explore" href="#">Explore</a></div>

code/moya-web/WebContent/swagger/lib/shred.bundle.js

@@ -2131,10 +2131,10 @@ require.define("/shred/mixins/headers.js", function (require, module, exports, _
 // to `Content-Type`.
 // to `Content-Type`.
 
 
 var corsetCase = function(string) {
 var corsetCase = function(string) {
-  return string.toLowerCase()
+  return string;//.toLowerCase()
       //.replace("_","-")
       //.replace("_","-")
-      .replace(/(^|-)(\w)/g, 
-          function(s) { return s.toUpperCase(); });
+      // .replace(/(^|-)(\w)/g, 
+          // function(s) { return s.toUpperCase(); });
 };
 };
 
 
 // We suspect that `initializeHeaders` was once more complicated ...
 // We suspect that `initializeHeaders` was once more complicated ...

code/moya-web/WebContent/swagger/lib/swagger-client.js

+// swagger-client.js
+// version 2.1.0-alpha.5
+/**
+ * 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, "")
+      .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 = [];
+  parent = parent||{};
+  args = args||{};
+
+  this.operation = args;
+  this.deprecated = args.deprecated;
+  this.consumes = args.consumes;
+  this.produces = args.produces;
+  this.parent = parent;
+  this.host = parent.host || 'localhost';
+  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 ' + this.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) {
+    if(this.resource && this.resource.api && this.resource.api.fail)
+      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')
+    str = 'integer'
+  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')
+    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(dontPrint) {
+  var out = this.nickname + ': ' + this.summary + '\n';
+  for(var i = 0; i < this.parameters.length; i++) {
+    var param = this.parameters[i];
+    var typeInfo = typeFromJsonSchema(param.type, param.format);
+    out += '\n  * ' + param.name + ' (' + typeInfo + '): ' + param.description;
+  }
+  if(typeof dontPrint === 'undefined')
+    log(out);
+  return out;
+}
+
+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();
+  }
+};
+
+Operation.prototype.supportHeaderParams = function () {
+  return true;
+};
+
+Operation.prototype.supportedSubmitMethods = function () {
+  return this.resource.api.supportedSubmitMethods;
+};
+
+Operation.prototype.getHeaderParams = function (args) {
+  var headers = this.setContentTypes(args, {});
+  for(var i = 0; i < this.parameters.length; i++) {
+    var param = this.parameters[i];
+    if(typeof args[param.name] !== 'undefined') {
+      if (param.in === 'header') {
+        var value = args[param.name];
+        if(Array.isArray(value))
+          value = this.encodePathCollection(param.collectionFormat, param.name, value);
+        else
+          value = this.encodePathParam(value);
+        headers[param.name] = value;
+      }
+    }
+  }
+  return headers;
+}
+
+Operation.prototype.urlify = function (args) {
+  var formParams = {};
+  var requestUrl = this.path;
+
+  // 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');
+        var value = args[param.name];
+        if(Array.isArray(value))
+          value = this.encodePathCollection(param.collectionFormat, param.name, value);
+        else
+          value = this.encodePathParam(value);
+        requestUrl = requestUrl.replace(reg, value);
+      }
+      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.encodeQueryCollection(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 === 'formData')
+        formParams[param.name] = args[param.name];
+    }
+  }
+  var url = this.scheme + '://' + this.host;
+
+  if(this.basePath !== '/')
+    url += this.basePath;
+
+  return url + requestUrl + querystring;
+}
+
+Operation.prototype.getMissingParams = function(args) {
+  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) {
+      if(typeof args[param.name] === 'undefined')
+        missingParams = param.name;
+    }
+  }
+  return missingParams;
+}
+
+Operation.prototype.getBody = function(headers, args) {
+  var formParams = {};
+  var body;
+
+  for(var i = 0; i < this.parameters.length; i++) {
+    var param = this.parameters[i];
+    if(typeof args[param.name] !== 'undefined') {
+      if (param.in === 'body')
+        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);
+      }
+    }
+    body = encoded;
+  }
+
+  return body;
+}
+
+/**
+ * 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;
+  }
+
+  success = (success||log)
+  error = (error||log)
+
+  var missingParams = this.getMissingParams(args);
+  if(missingParams.length > 0) {
+    var message = 'missing required params: ' + missingParams;
+    fail(message);
+    return;
+  }
+
+  var headers = this.getHeaderParams(args);
+  var body = this.getBody(headers, args);
+  var url = this.urlify(args)
+
+  var obj = {
+    url: url,
+    method: this.method,
+    body: 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 = args.parameterContentType || 'application/json';
+
+  var allDefinedParams = this.parameters;
+  var definedFormParams = [];
+  var definedFileParams = [];
+  var 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') {
+      if(param.type === 'file')
+        definedFileParams.push(param);
+      else
+        definedFormParams.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;
+    }
+    else if(param.in === 'body' && typeof args[param.name] !== 'undefined') {
+      body = args[param.name];
+    }
+  }
+
+  // if there's a body, need to set the consumes header via requestContentType
+  if (body && (this.method === 'post' || this.method === 'put' || this.method === 'patch' || this.method === 'delete')) {
+    if (opts.requestContentType)
+      consumes = opts.requestContentType;
+  } else {
+    // if any form params, content type must be set
+    if(definedFormParams.length > 0) {
+      if(opts.requestContentType)           // override if set
+        consumes = opts.requestContentType;
+      else if(definedFileParams.length > 0) // if a file, must be multipart/form-data
+        consumes = 'multipart/form-data';
+      else                                  // default to x-www-from-urlencoded
+        consumes = 'application/x-www-form-urlencoded';
+    }
+    else if (this.type == 'DELETE')
+      body = '{}';
+    else if (this.type != 'DELETE')
+      consumes = 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.asCurl = function (args) {
+  var results = [];
+  var headers = this.getHeaderParams(args);
+  if (headers) {
+    var key;
+    for (key in headers)
+      results.push("--header \"" + key + ": " + headers[key] + "\"");
+  }
+  return "curl " + (results.join(" ")) + " " + this.urlify(args);
+}
+
+Operation.prototype.encodePathCollection = function(type, name, value) {
+  var encoded = '';
+  var i;
+  var separator = '';
+  if(type === 'ssv')
+    separator = '%20';
+  else if(type === 'tsv')
+    separator = '\\t';
+  else if(type === 'pipes')
+    separator = '|';
+  else
+    separator = ',';
+
+  for(i = 0; i < value.length; i++) {
+    if(i == 0)
+      encoded = this.encodeQueryParam(value[i]);
+    else
+      encoded += separator + this.encodeQueryParam(value[i]);
+  }
+  return encoded;
+}
+
+Operation.prototype.encodeQueryCollection = 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 = '|';
+    else if(type === 'brackets') {
+      for(i = 0; i < value.length; i++) {
+        if(i !== 0)
+          encoded += '&';
+        encoded += this.encodeQueryParam(name) + '[]=' + this.encodeQueryParam(value[i]);
+      }
+    }
+    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]);
+      }
+    }
+  }
+  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++) {
+      encParts.push(encodeURIComponent(parts[i]));
+    }
+    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;
+e.Operation = Operation;
+/**
+ * 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 !== "") {
+          try {
+            out.obj = JSON.parse(response.content.data);
+          }
+          catch (ex) {
+            // do not set out.obj
+            log ("unable to parse JSON content");
+          }
+        }
+        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);
+};
\ No newline at end of file

code/moya-web/WebContent/swagger/lib/swagger-oauth.js

@@ -7,10 +7,29 @@ var realm;
 function handleLogin() {
 function handleLogin() {
   var scopes = [];
   var scopes = [];
 
 
-  if(window.swaggerUi.api.authSchemes 
-    && window.swaggerUi.api.authSchemes.oauth2
-    && window.swaggerUi.api.authSchemes.oauth2.scopes) {
-    scopes = window.swaggerUi.api.authSchemes.oauth2.scopes;
+  var auths = window.swaggerUi.api.authSchemes || window.swaggerUi.api.securityDefinitions;
+  if(auths) {
+    var key;
+    var defs = auths;
+    for(key in defs) {
+      var auth = defs[key];
+      if(auth.type === 'oauth2' && auth.scopes) {
+        var scope;
+        if(Array.isArray(auth.scopes)) {
+          // 1.2 support
+          var i;
+          for(i = 0; i < auth.scopes.length; i++) {
+            scopes.push(auth.scopes[i]);
+          }
+        }
+        else {
+          // 2.0 support
+          for(scope in auth.scopes) {
+            scopes.push({scope: scope, description: auth.scopes[scope]});
+          }
+        }
+      }
+    }
   }
   }
 
 
   if(window.swaggerUi.api
   if(window.swaggerUi.api
@@ -18,102 +37,103 @@ function handleLogin() {
     appName = window.swaggerUi.api.info.title;
     appName = window.swaggerUi.api.info.title;
   }
   }
 
 
-  if(popupDialog.length > 0)
-    popupDialog = popupDialog.last();
-  else {
-    popupDialog = $(
-      [
-        '<div class="api-popup-dialog">',
-        '<div class="api-popup-title">Select OAuth2.0 Scopes</div>',
-        '<div class="api-popup-content">',
-          '<p>Scopes are used to grant an application different levels of access to data on behalf of the end user. Each API may declare one or more scopes.',
-            '<a href="#">Learn how to use</a>',
-          '</p>',
-          '<p><strong>' + appName + '</strong> API requires the following scopes. Select which ones you want to grant to Swagger UI.</p>',
-          '<ul class="api-popup-scopes">',
-          '</ul>',
-          '<p class="error-msg"></p>',
-          '<div class="api-popup-actions"><button class="api-popup-authbtn api-button green" type="button">Authorize</button><button class="api-popup-cancel api-button gray" type="button">Cancel</button></div>',
-        '</div>',
-        '</div>'].join(''));
-    $(document.body).append(popupDialog);
-
-    popup = popupDialog.find('ul.api-popup-scopes').empty();
-    for (i = 0; i < scopes.length; i ++) {
-      scope = scopes[i];
-      str = '<li><input type="checkbox" id="scope_' + i + '" scope="' + scope.scope + '"/>' + '<label for="scope_' + i + '">' + scope.scope;
-      if (scope.description) {
-        str += '<br/><span class="api-scope-desc">' + scope.description + '</span>';
-      }
-      str += '</label></li>';
-      popup.append(str);
+  popupDialog = $(
+    [
+      '<div class="api-popup-dialog">',
+      '<div class="api-popup-title">Select OAuth2.0 Scopes</div>',
+      '<div class="api-popup-content">',
+        '<p>Scopes are used to grant an application different levels of access to data on behalf of the end user. Each API may declare one or more scopes.',
+          '<a href="#">Learn how to use</a>',
+        '</p>',
+        '<p><strong>' + appName + '</strong> API requires the following scopes. Select which ones you want to grant to Swagger UI.</p>',
+        '<ul class="api-popup-scopes">',
+        '</ul>',
+        '<p class="error-msg"></p>',
+        '<div class="api-popup-actions"><button class="api-popup-authbtn api-button green" type="button">Authorize</button><button class="api-popup-cancel api-button gray" type="button">Cancel</button></div>',
+      '</div>',
+      '</div>'].join(''));
+  $(document.body).append(popupDialog);
+
+  popup = popupDialog.find('ul.api-popup-scopes').empty();
+  for (i = 0; i < scopes.length; i ++) {
+    scope = scopes[i];
+    str = '<li><input type="checkbox" id="scope_' + i + '" scope="' + scope.scope + '"/>' + '<label for="scope_' + i + '">' + scope.scope;
+    if (scope.description) {
+      str += '<br/><span class="api-scope-desc">' + scope.description + '</span>';
     }
     }
-  
-
-    var $win = $(window),
-      dw = $win.width(),
-      dh = $win.height(),
-      st = $win.scrollTop(),
-      dlgWd = popupDialog.outerWidth(),
-      dlgHt = popupDialog.outerHeight(),
-      top = (dh -dlgHt)/2 + st,
-      left = (dw - dlgWd)/2;
-
-    popupDialog.css({
-      top: (top < 0? 0 : top) + 'px',
-      left: (left < 0? 0 : left) + 'px'
-    });
-
-    popupDialog.find('button.api-popup-cancel').click(function() {
-      popupMask.hide();
-      popupDialog.hide();
-    });
-    popupDialog.find('button.api-popup-authbtn').click(function() {
-      popupMask.hide();
-      popupDialog.hide();
-
-      var authSchemes = window.swaggerUi.api.authSchemes;
-      var location = window.location;
-      var locationUrl = location.protocol + '//' + location.host + location.pathname;
-      var redirectUrl = locationUrl.replace("index.html","").concat("/o2c.html").replace("//o2c.html","/o2c.html");
-      var url = null;
-
-      var p = window.swaggerUi.api.authSchemes;
-      for (var key in p) {
-        if (p.hasOwnProperty(key)) {
-          var o = p[key].grantTypes;
+    str += '</label></li>';
+    popup.append(str);
+  }
+
+  var $win = $(window),
+    dw = $win.width(),
+    dh = $win.height(),
+    st = $win.scrollTop(),
+    dlgWd = popupDialog.outerWidth(),
+    dlgHt = popupDialog.outerHeight(),
+    top = (dh -dlgHt)/2 + st,
+    left = (dw - dlgWd)/2;
+
+  popupDialog.css({
+    top: (top < 0? 0 : top) + 'px',
+    left: (left < 0? 0 : left) + 'px'
+  });
+
+  popupDialog.find('button.api-popup-cancel').click(function() {
+    popupMask.hide();
+    popupDialog.hide();
+    popupDialog.empty();
+    popupDialog = [];
+  });
+
+  popupDialog.find('button.api-popup-authbtn').click(function() {
+    popupMask.hide();
+    popupDialog.hide();
+
+    var authSchemes = window.swaggerUi.api.authSchemes;
+    var host = window.location;
+    var pathname = location.pathname.substring(0, location.pathname.lastIndexOf("/"));
+    var redirectUrl = host.protocol + '//' + host.host + pathname + '/o2c.html';
+    var url = null;
+
+    for (var key in authSchemes) {
+      if (authSchemes.hasOwnProperty(key)) {
+        if(authSchemes[key].type === 'oauth2' && authSchemes[key].flow === 'implicit') {
+          var dets = authSchemes[key];
+          url = dets.authorizationUrl + '?response_type=token';
+          window.swaggerUi.tokenName = dets.tokenUrl || 'access_token';          
+        }
+        else if(authSchemes[key].grantTypes) {
+          // 1.2 support
+          var o = authSchemes[key].grantTypes;
           for(var t in o) {
           for(var t in o) {
             if(o.hasOwnProperty(t) && t === 'implicit') {
             if(o.hasOwnProperty(t) && t === 'implicit') {
               var dets = o[t];
               var dets = o[t];
-              url = dets.loginEndpoint.url + "?response_type=token";
+              var ep = dets.loginEndpoint.url;
+              url = dets.loginEndpoint.url + '?response_type=token';
               window.swaggerUi.tokenName = dets.tokenName;
               window.swaggerUi.tokenName = dets.tokenName;
             }
             }
           }
           }
         }
         }
       }
       }
-      var scopes = [];
-      var scopeForUrl='';
-      var o = $('.api-popup-scopes').find('input:checked');
-
-      for(var k =0; k < o.length; k++) {
-        scopes.push($(o[k]).attr("scope"));
-        if(k > 0){
-      	  scopeForUrl+=' ';
-        }
-        scopeForUrl+=$(o[k]).attr("scope");
-      }
+    }
+    var scopes = []
+    var o = $('.api-popup-scopes').find('input:checked');
 
 
-      window.enabledScopes=scopes;
-    
+    for(k =0; k < o.length; k++) {
+      scopes.push($(o[k]).attr('scope'));
+    }
 
 
-      url += '&redirect_uri=' + encodeURIComponent(redirectUrl);
-      url += '&realm=' + encodeURIComponent(realm);
-      url += '&client_id=' + encodeURIComponent(clientId);
-      url += '&scope=' + encodeURIComponent(scopeForUrl);
+    window.enabledScopes=scopes;
+
+    url += '&redirect_uri=' + encodeURIComponent(redirectUrl);
+    url += '&realm=' + encodeURIComponent(realm);
+    url += '&client_id=' + encodeURIComponent(clientId);
+    url += '&scope=' + encodeURIComponent(scopes);
+
+    window.open(url);
+  });
 
 
-      window.open(url);
-    });
-  }
   popupMask.show();
   popupMask.show();
   popupDialog.show();
   popupDialog.show();
   return;
   return;
@@ -137,14 +157,14 @@ function initOAuth(opts) {
   var o = (opts||{});
   var o = (opts||{});
   var errors = [];
   var errors = [];
 
 
-  appName = (o.appName||errors.push("missing appName"));
+  appName = (o.appName||errors.push('missing appName'));
   popupMask = (o.popupMask||$('#api-common-mask'));
   popupMask = (o.popupMask||$('#api-common-mask'));
   popupDialog = (o.popupDialog||$('.api-popup-dialog'));
   popupDialog = (o.popupDialog||$('.api-popup-dialog'));
-  clientId = (o.clientId||errors.push("missing client id"));
-  realm = (o.realm||errors.push("missing realm"));
+  clientId = (o.clientId||errors.push('missing client id'));
+  realm = (o.realm||errors.push('missing realm'));
 
 
   if(errors.length > 0){
   if(errors.length > 0){
-    log("auth unable initialize oauth: " + errors);
+    log('auth unable initialize oauth: ' + errors);
     return;
     return;
   }
   }
 
 
@@ -210,8 +230,7 @@ function onOAuthComplete(token) {
             }
             }
           }
           }
         });
         });
-
-        window.authorizations.add("key", new ApiKeyAuthorization("Authorization", "Bearer " + b, "header"));
+        window.authorizations.add('oauth2', new ApiKeyAuthorization('Authorization', 'Bearer ' + b, 'header'));
       }
       }
     }
     }
   }
   }

code/moya-web/WebContent/swagger/swagger-ui.js

 // swagger-ui.js
 // swagger-ui.js
+// version 2.1.0-alpha.7
 $(function() {
 $(function() {
 
 
 	// Helper function for vertically aligning DOM elements
 	// Helper function for vertically aligning DOM elements
@@ -67,7 +68,7 @@ log = function(){
   log.history = log.history || [];
   log.history = log.history || [];
   log.history.push(arguments);
   log.history.push(arguments);
   if(this.console){
   if(this.console){
-    console.log( Array.prototype.slice.call(arguments) );
+    console.log( Array.prototype.slice.call(arguments)[0] );
   }
   }
 };
 };
 
 
@@ -92,7 +93,6 @@ var Docs = {
 		switch (fragments.length) {
 		switch (fragments.length) {
 			case 1:
 			case 1:
 				// Expand all operations for the resource and scroll to it
 				// Expand all operations for the resource and scroll to it
-				log('shebang resource:' + fragments[0]);
 				var dom_id = 'resource_' + fragments[0];
 				var dom_id = 'resource_' + fragments[0];
 
 
 				Docs.expandEndpointListForResource(fragments[0]);
 				Docs.expandEndpointListForResource(fragments[0]);
@@ -100,7 +100,6 @@ var Docs = {
 				break;
 				break;
 			case 2:
 			case 2:
 				// Refer to the endpoint DOM element, e.g. #words_get_search
 				// Refer to the endpoint DOM element, e.g. #words_get_search
-				log('shebang endpoint: ' + fragments.join('_'));
 
 
         // Expand Resource
         // Expand Resource
         Docs.expandEndpointListForResource(fragments[0]);
         Docs.expandEndpointListForResource(fragments[0]);
@@ -110,8 +109,6 @@ var Docs = {
 				var li_dom_id = fragments.join('_');
 				var li_dom_id = fragments.join('_');
 				var li_content_dom_id = li_dom_id + "_content";
 				var li_content_dom_id = li_dom_id + "_content";
 
 
-        log("li_dom_id " + li_dom_id);
-        log("li_content_dom_id " + li_content_dom_id);
 
 
 				Docs.expandOperation($('#'+li_content_dom_id));
 				Docs.expandOperation($('#'+li_content_dom_id));
 				$('#'+li_dom_id).slideto({highlight: false});
 				$('#'+li_dom_id).slideto({highlight: false});
@@ -188,6 +185,35 @@ var Docs = {
 	}
 	}
 };(function() {
 };(function() {
   var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
   var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
+templates['apikey_button_view'] = template(function (Handlebars,depth0,helpers,partials,data) {
+  this.compilerInfo = [4,'>= 1.0.0'];
+helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
+  var buffer = "", stack1, functionType="function", escapeExpression=this.escapeExpression;
+
+
+  buffer += "<div class='auth_button' id='apikey_button'><img class='auth_icon' alt='apply api key' src='images/apikey.jpeg'></div>\n<div class='auth_container' id='apikey_container'>\n  <div class='key_input_container'>\n    <div class='auth_label'>";
+  if (stack1 = helpers.keyName) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.keyName; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  buffer += escapeExpression(stack1)
+    + "</div>\n    <input placeholder=\"api_key\" class=\"auth_input\" id=\"input_apiKey_entry\" name=\"apiKey\" type=\"text\"/>\n    <div class='auth_submit'><a class='auth_submit_button' id=\"apply_api_key\" href=\"#\">apply</a></div>\n  </div>\n</div>\n\n";
+  return buffer;
+  });
+})();
+
+(function() {
+  var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
+templates['basic_auth_button_view'] = template(function (Handlebars,depth0,helpers,partials,data) {
+  this.compilerInfo = [4,'>= 1.0.0'];
+helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
+  
+
+
+  return "<div class='auth_button' id='basic_auth_button'><img class='auth_icon' src='images/password.jpeg'></div>\n<div class='auth_container' id='basic_auth_container'>\n  <div class='key_input_container'>\n    <div class=\"auth_label\">Username</div>\n    <input placeholder=\"username\" class=\"auth_input\" id=\"input_username\" name=\"username\" type=\"text\"/>\n    <div class=\"auth_label\">Password</div>\n    <input placeholder=\"password\" class=\"auth_input\" id=\"input_password\" name=\"password\" type=\"password\"/>\n    <div class='auth_submit'><a class='auth_submit_button' id=\"apply_basic_auth\" href=\"#\">apply</a></div>\n  </div>\n</div>\n\n";
+  });
+})();
+
+(function() {
+  var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
 templates['content_type'] = template(function (Handlebars,depth0,helpers,partials,data) {
 templates['content_type'] = template(function (Handlebars,depth0,helpers,partials,data) {
   this.compilerInfo = [4,'>= 1.0.0'];
   this.compilerInfo = [4,'>= 1.0.0'];
 helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
 helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
@@ -234,23 +260,23 @@ function program4(depth0,data) {
 templates['main'] = template(function (Handlebars,depth0,helpers,partials,data) {
 templates['main'] = template(function (Handlebars,depth0,helpers,partials,data) {
   this.compilerInfo = [4,'>= 1.0.0'];
   this.compilerInfo = [4,'>= 1.0.0'];
 helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
 helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
-  var buffer = "", stack1, functionType="function", escapeExpression=this.escapeExpression, self=this;
+  var buffer = "", stack1, stack2, functionType="function", escapeExpression=this.escapeExpression, self=this;
 
 
 function program1(depth0,data) {
 function program1(depth0,data) {
   
   
   var buffer = "", stack1, stack2;
   var buffer = "", stack1, stack2;
-  buffer += "\n    <div class=\"info_title\">"
+  buffer += "\n  <div class=\"info_title\">"
     + escapeExpression(((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.title)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
     + escapeExpression(((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.title)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
-    + "</div>\n    <div class=\"info_description\">";
+    + "</div>\n  <div class=\"info_description\">";
   stack2 = ((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.description)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1);
   stack2 = ((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.description)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1);
   if(stack2 || stack2 === 0) { buffer += stack2; }
   if(stack2 || stack2 === 0) { buffer += stack2; }
-  buffer += "</div>\n    ";
+  buffer += "</div>\n  ";
   stack2 = helpers['if'].call(depth0, ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.termsOfServiceUrl), {hash:{},inverse:self.noop,fn:self.program(2, program2, data),data:data});
   stack2 = helpers['if'].call(depth0, ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.termsOfServiceUrl), {hash:{},inverse:self.noop,fn:self.program(2, program2, data),data:data});
   if(stack2 || stack2 === 0) { buffer += stack2; }
   if(stack2 || stack2 === 0) { buffer += stack2; }
-  buffer += "\n    ";
+  buffer += "\n  ";
   stack2 = helpers['if'].call(depth0, ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.contact), {hash:{},inverse:self.noop,fn:self.program(4, program4, data),data:data});
   stack2 = helpers['if'].call(depth0, ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.contact), {hash:{},inverse:self.noop,fn:self.program(4, program4, data),data:data});
   if(stack2 || stack2 === 0) { buffer += stack2; }
   if(stack2 || stack2 === 0) { buffer += stack2; }
-  buffer += "\n    ";
+  buffer += "\n  ";
   stack2 = helpers['if'].call(depth0, ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.license), {hash:{},inverse:self.noop,fn:self.program(6, program6, data),data:data});
   stack2 = helpers['if'].call(depth0, ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.license), {hash:{},inverse:self.noop,fn:self.program(6, program6, data),data:data});
   if(stack2 || stack2 === 0) { buffer += stack2; }
   if(stack2 || stack2 === 0) { buffer += stack2; }
   buffer += "\n  ";
   buffer += "\n  ";
@@ -269,7 +295,7 @@ function program4(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "<div class='info_contact'><a href=\"mailto:"
   buffer += "<div class='info_contact'><a href=\"mailto:"
-    + escapeExpression(((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.contact)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
+    + escapeExpression(((stack1 = ((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.contact)),stack1 == null || stack1 === false ? stack1 : stack1.name)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
     + "\">Contact the developer</a></div>";
     + "\">Contact the developer</a></div>";
   return buffer;
   return buffer;
   }
   }
@@ -278,9 +304,9 @@ function program6(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "<div class='info_license'><a href='"
   buffer += "<div class='info_license'><a href='"
-    + escapeExpression(((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.licenseUrl)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
+    + escapeExpression(((stack1 = ((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.license)),stack1 == null || stack1 === false ? stack1 : stack1.url)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
     + "'>"
     + "'>"
-    + escapeExpression(((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.license)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
+    + escapeExpression(((stack1 = ((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.license)),stack1 == null || stack1 === false ? stack1 : stack1.name)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
     + "</a></div>";
     + "</a></div>";
   return buffer;
   return buffer;
   }
   }
@@ -288,25 +314,49 @@ function program6(depth0,data) {
 function program8(depth0,data) {
 function program8(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
-  buffer += "\n        , <span style=\"font-variant: small-caps\">api version</span>: ";
-  if (stack1 = helpers.apiVersion) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.apiVersion; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  buffer += "\n    , <span style=\"font-variant: small-caps\">api version</span>: "
+    + escapeExpression(((stack1 = ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.version)),typeof stack1 === functionType ? stack1.apply(depth0) : stack1))
+    + "\n    ";
+  return buffer;
+  }
+
+function program10(depth0,data) {
+  
+  var buffer = "", stack1;
+  buffer += "\n    <span style=\"float:right\"><a href=\"";
+  if (stack1 = helpers.validatorUrl) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.validatorUrl; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "\n        ";
+    + "/debug?url=";
+  if (stack1 = helpers.url) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.url; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  buffer += escapeExpression(stack1)
+    + "\"><img id=\"validator\" src=\"";
+  if (stack1 = helpers.validatorUrl) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.validatorUrl; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  buffer += escapeExpression(stack1)
+    + "?url=";
+  if (stack1 = helpers.url) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.url; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  buffer += escapeExpression(stack1)
+    + "\"></a>\n    </span>\n    ";
   return buffer;
   return buffer;
   }
   }
 
 
   buffer += "<div class='info' id='api_info'>\n  ";
   buffer += "<div class='info' id='api_info'>\n  ";
   stack1 = helpers['if'].call(depth0, depth0.info, {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data});
   stack1 = helpers['if'].call(depth0, depth0.info, {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
-  buffer += "\n</div>\n<div class='container' id='resources_container'>\n    <ul id='resources'>\n    </ul>\n\n    <div class=\"footer\">\n        <br>\n        <br>\n        <h4 style=\"color: #999\">[ <span style=\"font-variant: small-caps\">base url</span>: ";
+  buffer += "\n</div>\n<div class='container' id='resources_container'>\n  <ul id='resources'></ul>\n\n  <div class=\"footer\">\n    <br>\n    <br>\n    <h4 style=\"color: #999\">[ <span style=\"font-variant: small-caps\">base url</span>: ";
   if (stack1 = helpers.basePath) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.basePath) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.basePath; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.basePath; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "\n        ";
-  stack1 = helpers['if'].call(depth0, depth0.apiVersion, {hash:{},inverse:self.noop,fn:self.program(8, program8, data),data:data});
-  if(stack1 || stack1 === 0) { buffer += stack1; }
-  buffer += "]</h4>\n    </div>\n</div>\n";
+    + "\n    ";
+  stack2 = helpers['if'].call(depth0, ((stack1 = depth0.info),stack1 == null || stack1 === false ? stack1 : stack1.version), {hash:{},inverse:self.noop,fn:self.program(8, program8, data),data:data});
+  if(stack2 || stack2 === 0) { buffer += stack2; }
+  buffer += "]\n    ";
+  stack2 = helpers['if'].call(depth0, depth0.validatorUrl, {hash:{},inverse:self.noop,fn:self.program(10, program10, data),data:data});
+  if(stack2 || stack2 === 0) { buffer += stack2; }
+  buffer += "\n    </h4>\n    </div>\n</div>\n";
   return buffer;
   return buffer;
   });
   });
 })();
 })();
@@ -320,31 +370,43 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
 
 
 function program1(depth0,data) {
 function program1(depth0,data) {
   
   
+  
+  return "deprecated";
+  }
+
+function program3(depth0,data) {
+  
+  
+  return "\n            <h4>Warning: Deprecated</h4>\n        ";
+  }
+
+function program5(depth0,data) {
+  
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n        <h4>Implementation Notes</h4>\n        <p>";
   buffer += "\n        <h4>Implementation Notes</h4>\n        <p>";
-  if (stack1 = helpers.notes) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.notes; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers.description) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.description; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "</p>\n        ";
   buffer += "</p>\n        ";
   return buffer;
   return buffer;
   }
   }
 
 
-function program3(depth0,data) {
+function program7(depth0,data) {
   
   
   
   
   return "\n        <div class=\"auth\">\n        <span class=\"api-ic ic-error\"></span>";
   return "\n        <div class=\"auth\">\n        <span class=\"api-ic ic-error\"></span>";
   }
   }
 
 
-function program5(depth0,data) {
+function program9(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n          <div id=\"api_information_panel\" style=\"top: 526px; left: 776px; display: none;\">\n          ";
   buffer += "\n          <div id=\"api_information_panel\" style=\"top: 526px; left: 776px; display: none;\">\n          ";
-  stack1 = helpers.each.call(depth0, depth0, {hash:{},inverse:self.noop,fn:self.program(6, program6, data),data:data});
+  stack1 = helpers.each.call(depth0, depth0, {hash:{},inverse:self.noop,fn:self.program(10, program10, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n          </div>\n        ";
   buffer += "\n          </div>\n        ";
   return buffer;
   return buffer;
   }
   }
-function program6(depth0,data) {
+function program10(depth0,data) {
   
   
   var buffer = "", stack1, stack2;
   var buffer = "", stack1, stack2;
   buffer += "\n            <div title='";
   buffer += "\n            <div title='";
@@ -356,46 +418,46 @@ function program6(depth0,data) {
   return buffer;
   return buffer;
   }
   }
 
 
-function program8(depth0,data) {
+function program12(depth0,data) {
   
   
   
   
   return "</div>";
   return "</div>";
   }
   }
 
 
-function program10(depth0,data) {
+function program14(depth0,data) {
   
   
   
   
   return "\n        <div class='access'>\n          <span class=\"api-ic ic-off\" title=\"click to authenticate\"></span>\n        </div>\n        ";
   return "\n        <div class='access'>\n          <span class=\"api-ic ic-off\" title=\"click to authenticate\"></span>\n        </div>\n        ";
   }
   }
 
 
-function program12(depth0,data) {
+function program16(depth0,data) {
   
   
   
   
   return "\n          <h4>Response Class</h4>\n          <p><span class=\"model-signature\" /></p>\n          <br/>\n          <div class=\"response-content-type\" />\n        ";
   return "\n          <h4>Response Class</h4>\n          <p><span class=\"model-signature\" /></p>\n          <br/>\n          <div class=\"response-content-type\" />\n        ";
   }
   }
 
 
-function program14(depth0,data) {
+function program18(depth0,data) {
   
   
   
   
   return "\n          <h4>Parameters</h4>\n          <table class='fullwidth'>\n          <thead>\n            <tr>\n            <th style=\"width: 100px; max-width: 100px\">Parameter</th>\n            <th style=\"width: 310px; max-width: 310px\">Value</th>\n            <th style=\"width: 200px; max-width: 200px\">Description</th>\n            <th style=\"width: 100px; max-width: 100px\">Parameter Type</th>\n            <th style=\"width: 220px; max-width: 230px\">Data Type</th>\n            </tr>\n          </thead>\n          <tbody class=\"operation-params\">\n\n          </tbody>\n          </table>\n          ";
   return "\n          <h4>Parameters</h4>\n          <table class='fullwidth'>\n          <thead>\n            <tr>\n            <th style=\"width: 100px; max-width: 100px\">Parameter</th>\n            <th style=\"width: 310px; max-width: 310px\">Value</th>\n            <th style=\"width: 200px; max-width: 200px\">Description</th>\n            <th style=\"width: 100px; max-width: 100px\">Parameter Type</th>\n            <th style=\"width: 220px; max-width: 230px\">Data Type</th>\n            </tr>\n          </thead>\n          <tbody class=\"operation-params\">\n\n          </tbody>\n          </table>\n          ";
   }
   }
 
 
-function program16(depth0,data) {
+function program20(depth0,data) {
   
   
   
   
   return "\n          <div style='margin:0;padding:0;display:inline'></div>\n          <h4>Response Messages</h4>\n          <table class='fullwidth'>\n            <thead>\n            <tr>\n              <th>HTTP Status Code</th>\n              <th>Reason</th>\n              <th>Response Model</th>\n            </tr>\n            </thead>\n            <tbody class=\"operation-status\">\n            \n            </tbody>\n          </table>\n          ";
   return "\n          <div style='margin:0;padding:0;display:inline'></div>\n          <h4>Response Messages</h4>\n          <table class='fullwidth'>\n            <thead>\n            <tr>\n              <th>HTTP Status Code</th>\n              <th>Reason</th>\n              <th>Response Model</th>\n            </tr>\n            </thead>\n            <tbody class=\"operation-status\">\n            \n            </tbody>\n          </table>\n          ";
   }
   }
 
 
-function program18(depth0,data) {
+function program22(depth0,data) {
   
   
   
   
   return "\n          ";
   return "\n          ";
   }
   }
 
 
-function program20(depth0,data) {
+function program24(depth0,data) {
   
   
   
   
-  return "\n          <div class='sandbox_header'>\n            <input class='submit' name='commit' type='button' value='Try it out!' />\n            <a href='#' class='response_hider' style='display:none'>Hide Response</a>\n            <img alt='Throbber' class='response_throbber' src='images/throbber.gif' style='display:none' />\n          </div>\n          ";
+  return "\n          <div class='sandbox_header'>\n            <input class='submit' name='commit' type='button' value='Try it out!' />\n            <a href='#' class='response_hider' style='display:none'>Hide Response</a>\n            <span class='response_throbber' style='display:none'></span>\n          </div>\n          ";
   }
   }
 
 
   buffer += "\n  <ul class='operations' >\n    <li class='";
   buffer += "\n  <ul class='operations' >\n    <li class='";
@@ -430,7 +492,10 @@ function program20(depth0,data) {
   if (stack1 = helpers.nickname) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.nickname) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.nickname; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.nickname; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "' class=\"toggleOperation\">";
+    + "' class=\"toggleOperation ";
+  stack1 = helpers['if'].call(depth0, depth0.deprecated, {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data});
+  if(stack1 || stack1 === 0) { buffer += stack1; }
+  buffer += "\">";
   if (stack1 = helpers.path) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.path) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.path; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.path; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
@@ -455,40 +520,43 @@ function program20(depth0,data) {
   else { stack1 = depth0.nickname; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.nickname; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "_content' style='display:none'>\n        ";
     + "_content' style='display:none'>\n        ";
-  stack1 = helpers['if'].call(depth0, depth0.notes, {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0.deprecated, {hash:{},inverse:self.noop,fn:self.program(3, program3, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n        ";
   buffer += "\n        ";
-  options = {hash:{},inverse:self.noop,fn:self.program(3, program3, data),data:data};
+  stack1 = helpers['if'].call(depth0, depth0.description, {hash:{},inverse:self.noop,fn:self.program(5, program5, data),data:data});
+  if(stack1 || stack1 === 0) { buffer += stack1; }
+  buffer += "\n        ";
+  options = {hash:{},inverse:self.noop,fn:self.program(7, program7, data),data:data};
   if (stack1 = helpers.oauth) { stack1 = stack1.call(depth0, options); }
   if (stack1 = helpers.oauth) { stack1 = stack1.call(depth0, options); }
   else { stack1 = depth0.oauth; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.oauth; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   if (!helpers.oauth) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
   if (!helpers.oauth) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n        ";
   buffer += "\n        ";
-  stack1 = helpers.each.call(depth0, depth0.oauth, {hash:{},inverse:self.noop,fn:self.program(5, program5, data),data:data});
+  stack1 = helpers.each.call(depth0, depth0.oauth, {hash:{},inverse:self.noop,fn:self.program(9, program9, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n        ";
   buffer += "\n        ";
-  options = {hash:{},inverse:self.noop,fn:self.program(8, program8, data),data:data};
+  options = {hash:{},inverse:self.noop,fn:self.program(12, program12, data),data:data};
   if (stack1 = helpers.oauth) { stack1 = stack1.call(depth0, options); }
   if (stack1 = helpers.oauth) { stack1 = stack1.call(depth0, options); }
   else { stack1 = depth0.oauth; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.oauth; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   if (!helpers.oauth) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
   if (!helpers.oauth) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n        ";
   buffer += "\n        ";
-  options = {hash:{},inverse:self.noop,fn:self.program(10, program10, data),data:data};
+  options = {hash:{},inverse:self.noop,fn:self.program(14, program14, data),data:data};
   if (stack1 = helpers.oauth) { stack1 = stack1.call(depth0, options); }
   if (stack1 = helpers.oauth) { stack1 = stack1.call(depth0, options); }
   else { stack1 = depth0.oauth; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.oauth; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   if (!helpers.oauth) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
   if (!helpers.oauth) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n        ";
   buffer += "\n        ";
-  stack1 = helpers['if'].call(depth0, depth0.type, {hash:{},inverse:self.noop,fn:self.program(12, program12, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0.type, {hash:{},inverse:self.noop,fn:self.program(16, program16, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n        <form accept-charset='UTF-8' class='sandbox'>\n          <div style='margin:0;padding:0;display:inline'></div>\n          ";
   buffer += "\n        <form accept-charset='UTF-8' class='sandbox'>\n          <div style='margin:0;padding:0;display:inline'></div>\n          ";
-  stack1 = helpers['if'].call(depth0, depth0.parameters, {hash:{},inverse:self.noop,fn:self.program(14, program14, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0.parameters, {hash:{},inverse:self.noop,fn:self.program(18, program18, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n          ";
   buffer += "\n          ";
-  stack1 = helpers['if'].call(depth0, depth0.responseMessages, {hash:{},inverse:self.noop,fn:self.program(16, program16, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0.responseMessages, {hash:{},inverse:self.noop,fn:self.program(20, program20, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n          ";
   buffer += "\n          ";
-  stack1 = helpers['if'].call(depth0, depth0.isReadOnly, {hash:{},inverse:self.program(20, program20, data),fn:self.program(18, program18, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0.isReadOnly, {hash:{},inverse:self.program(24, program24, data),fn:self.program(22, program22, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n        </form>\n        <div class='response' style='display:none'>\n          <h4>Request URL</h4>\n          <div class='block request_url'></div>\n          <h4>Response Body</h4>\n          <div class='block response_body'></div>\n          <h4>Response Code</h4>\n          <div class='block response_code'></div>\n          <h4>Response Headers</h4>\n          <div class='block response_headers'></div>\n        </div>\n      </div>\n    </li>\n  </ul>\n";
   buffer += "\n        </form>\n        <div class='response' style='display:none'>\n          <h4>Request URL</h4>\n          <div class='block request_url'></div>\n          <h4>Response Body</h4>\n          <div class='block response_body'></div>\n          <h4>Response Code</h4>\n          <div class='block response_code'></div>\n          <h4>Response Headers</h4>\n          <div class='block response_headers'></div>\n        </div>\n      </div>\n    </li>\n  </ul>\n";
   return buffer;
   return buffer;
@@ -526,7 +594,7 @@ function program4(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n			";
   buffer += "\n			";
-  stack1 = helpers['if'].call(depth0, depth0.defaultValue, {hash:{},inverse:self.program(7, program7, data),fn:self.program(5, program5, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0['default'], {hash:{},inverse:self.program(7, program7, data),fn:self.program(5, program5, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n		";
   buffer += "\n		";
   return buffer;
   return buffer;
@@ -539,8 +607,8 @@ function program5(depth0,data) {
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "'>";
     + "'>";
-  if (stack1 = helpers.defaultValue) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.defaultValue; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers['default']) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0['default']; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "</textarea>\n			";
     + "</textarea>\n			";
   return buffer;
   return buffer;
@@ -561,7 +629,7 @@ function program9(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n		";
   buffer += "\n		";
-  stack1 = helpers['if'].call(depth0, depth0.defaultValue, {hash:{},inverse:self.program(12, program12, data),fn:self.program(10, program10, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0.isFile, {hash:{},inverse:self.program(10, program10, data),fn:self.program(2, program2, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n	";
   buffer += "\n	";
   return buffer;
   return buffer;
@@ -569,26 +637,35 @@ function program9(depth0,data) {
 function program10(depth0,data) {
 function program10(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
-  buffer += "\n			<input class='parameter' minlength='0' name='";
+  buffer += "\n			";
+  stack1 = helpers['if'].call(depth0, depth0['default'], {hash:{},inverse:self.program(13, program13, data),fn:self.program(11, program11, data),data:data});
+  if(stack1 || stack1 === 0) { buffer += stack1; }
+  buffer += "\n		";
+  return buffer;
+  }
+function program11(depth0,data) {
+  
+  var buffer = "", stack1;
+  buffer += "\n				<input class='parameter' minlength='0' name='";
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "' placeholder='' type='text' value='";
     + "' placeholder='' type='text' value='";
-  if (stack1 = helpers.defaultValue) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.defaultValue; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers['default']) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0['default']; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "'/>\n		";
+    + "'/>\n			";
   return buffer;
   return buffer;
   }
   }
 
 
-function program12(depth0,data) {
+function program13(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
-  buffer += "\n			<input class='parameter' minlength='0' name='";
+  buffer += "\n				<input class='parameter' minlength='0' name='";
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "' placeholder='' type='text' value=''/>\n		";
+    + "' placeholder='' type='text' value=''/>\n			";
   return buffer;
   return buffer;
   }
   }
 
 
@@ -635,7 +712,7 @@ function program5(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n      ";
   buffer += "\n      ";
-  stack1 = helpers['if'].call(depth0, depth0.defaultValue, {hash:{},inverse:self.program(8, program8, data),fn:self.program(6, program6, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0['default'], {hash:{},inverse:self.program(8, program8, data),fn:self.program(6, program6, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n    ";
   buffer += "\n    ";
   return buffer;
   return buffer;
@@ -753,8 +830,8 @@ function program1(depth0,data) {
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "'>";
     + "'>";
-  if (stack1 = helpers.defaultValue) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.defaultValue; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers['default']) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0['default']; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "</textarea>\n    ";
     + "</textarea>\n    ";
   return buffer;
   return buffer;
@@ -764,7 +841,7 @@ function program3(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n        ";
   buffer += "\n        ";
-  stack1 = helpers['if'].call(depth0, depth0.defaultValue, {hash:{},inverse:self.program(6, program6, data),fn:self.program(4, program4, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0['default'], {hash:{},inverse:self.program(6, program6, data),fn:self.program(4, program4, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n    ";
   buffer += "\n    ";
   return buffer;
   return buffer;
@@ -773,8 +850,8 @@ function program4(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n            ";
   buffer += "\n            ";
-  if (stack1 = helpers.defaultValue) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.defaultValue; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers['default']) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0['default']; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "\n        ";
     + "\n        ";
   return buffer;
   return buffer;
@@ -821,8 +898,8 @@ function program1(depth0,data) {
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "'>";
     + "'>";
-  if (stack1 = helpers.defaultValue) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.defaultValue; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers['default']) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0['default']; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "</textarea>\n    ";
     + "</textarea>\n    ";
   return buffer;
   return buffer;
@@ -832,7 +909,7 @@ function program3(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n        ";
   buffer += "\n        ";
-  stack1 = helpers['if'].call(depth0, depth0.defaultValue, {hash:{},inverse:self.program(6, program6, data),fn:self.program(4, program4, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0['default'], {hash:{},inverse:self.program(6, program6, data),fn:self.program(4, program4, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n    ";
   buffer += "\n    ";
   return buffer;
   return buffer;
@@ -841,8 +918,8 @@ function program4(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n            ";
   buffer += "\n            ";
-  if (stack1 = helpers.defaultValue) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.defaultValue; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers['default']) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0['default']; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "\n        ";
     + "\n        ";
   return buffer;
   return buffer;
@@ -905,7 +982,7 @@ function program4(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n			";
   buffer += "\n			";
-  stack1 = helpers['if'].call(depth0, depth0.defaultValue, {hash:{},inverse:self.program(7, program7, data),fn:self.program(5, program5, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0['default'], {hash:{},inverse:self.program(7, program7, data),fn:self.program(5, program5, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n		";
   buffer += "\n		";
   return buffer;
   return buffer;
@@ -913,13 +990,13 @@ function program4(depth0,data) {
 function program5(depth0,data) {
 function program5(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
-  buffer += "\n				<textarea class='body-textarea' placeholder='(required)' name='";
+  buffer += "\n				<textarea class='body-textarea required' placeholder='(required)' name='";
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "'>";
     + "'>";
-  if (stack1 = helpers.defaultValue) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.defaultValue; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers['default']) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0['default']; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "</textarea>\n			";
     + "</textarea>\n			";
   return buffer;
   return buffer;
@@ -928,7 +1005,7 @@ function program5(depth0,data) {
 function program7(depth0,data) {
 function program7(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
-  buffer += "\n				<textarea class='body-textarea' placeholder='(required)' name='";
+  buffer += "\n				<textarea class='body-textarea required' placeholder='(required)' name='";
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
@@ -960,7 +1037,7 @@ function program12(depth0,data) {
   
   
   var buffer = "", stack1;
   var buffer = "", stack1;
   buffer += "\n			";
   buffer += "\n			";
-  stack1 = helpers['if'].call(depth0, depth0.defaultValue, {hash:{},inverse:self.program(15, program15, data),fn:self.program(13, program13, data),data:data});
+  stack1 = helpers['if'].call(depth0, depth0['default'], {hash:{},inverse:self.program(15, program15, data),fn:self.program(13, program13, data),data:data});
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n		";
   buffer += "\n		";
   return buffer;
   return buffer;
@@ -973,8 +1050,8 @@ function program13(depth0,data) {
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "' placeholder='(required)' type='text' value='";
     + "' placeholder='(required)' type='text' value='";
-  if (stack1 = helpers.defaultValue) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.defaultValue; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers['default']) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0['default']; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "'/>\n			";
     + "'/>\n			";
   return buffer;
   return buffer;
@@ -1067,26 +1144,37 @@ function program1(depth0,data) {
   return " : ";
   return " : ";
   }
   }
 
 
+function program3(depth0,data) {
+  
+  var buffer = "", stack1;
+  buffer += "<li>\n      <a href='";
+  if (stack1 = helpers.url) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.url; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  buffer += escapeExpression(stack1)
+    + "'>Raw</a>\n    </li>";
+  return buffer;
+  }
+
   buffer += "<div class='heading'>\n  <h2>\n    <a href='#!/";
   buffer += "<div class='heading'>\n  <h2>\n    <a href='#!/";
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "' onclick=\"Docs.toggleEndpointListForResource('";
+    + "' class=\"toggleEndpointList\" data-id=\"";
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "');\">";
+    + "\">";
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.name) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
     + "</a> ";
     + "</a> ";
   options = {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data};
   options = {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data};
-  if (stack1 = helpers.description) { stack1 = stack1.call(depth0, options); }
-  else { stack1 = depth0.description; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
-  if (!helpers.description) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
+  if (stack1 = helpers.summary) { stack1 = stack1.call(depth0, options); }
+  else { stack1 = depth0.summary; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (!helpers.summary) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
-  if (stack1 = helpers.description) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
-  else { stack1 = depth0.description; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
+  if (stack1 = helpers.summary) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+  else { stack1 = depth0.summary; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   buffer += "\n  </h2>\n  <ul class='options'>\n    <li>\n      <a href='#!/";
   buffer += "\n  </h2>\n  <ul class='options'>\n    <li>\n      <a href='#!/";
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
@@ -1096,23 +1184,25 @@ function program1(depth0,data) {
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "'\n         onclick=\"Docs.toggleEndpointListForResource('";
+    + "' class=\"toggleEndpointList\" data-id=\"";
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "');\">Show/Hide</a>\n    </li>\n    <li>\n      <a href='#' onclick=\"Docs.collapseOperationsForResource('";
+    + "\">Show/Hide</a>\n    </li>\n    <li>\n      <a href='#' class=\"collapseResource\" data-id=\"";
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "'); return false;\">\n        List Operations\n      </a>\n    </li>\n    <li>\n      <a href='#' onclick=\"Docs.expandOperationsForResource('";
+    + "\">\n        List Operations\n      </a>\n    </li>\n    <li>\n      <a href='#' class=\"expandResource\" data-id=\"";
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "'); return false;\">\n        Expand Operations\n      </a>\n    </li>\n    <li>\n      <a href='";
-  if (stack1 = helpers.url) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
+    + "\">\n        Expand Operations\n      </a>\n    </li>\n    ";
+  options = {hash:{},inverse:self.noop,fn:self.program(3, program3, data),data:data};
+  if (stack1 = helpers.url) { stack1 = stack1.call(depth0, options); }
   else { stack1 = depth0.url; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.url; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
-  buffer += escapeExpression(stack1)
-    + "'>Raw</a>\n    </li>\n  </ul>\n</div>\n<ul class='endpoints' id='";
+  if (!helpers.url) { stack1 = blockHelperMissing.call(depth0, stack1, options); }
+  if(stack1 || stack1 === 0) { buffer += stack1; }
+  buffer += "\n  </ul>\n</div>\n<ul class='endpoints' id='";
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.id) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
@@ -1172,15 +1262,15 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
   var buffer = "", stack1, functionType="function", escapeExpression=this.escapeExpression;
   var buffer = "", stack1, functionType="function", escapeExpression=this.escapeExpression;
 
 
 
 
-  buffer += "<div>\n<ul class=\"signature-nav\">\n    <li><a class=\"description-link\" href=\"#\">Model</a></li>\n    <li><a class=\"snippet-link\" href=\"#\">Model Schema</a></li>\n</ul>\n<div>\n\n<div class=\"signature-container\">\n    <div class=\"description\">\n        ";
+  buffer += "<div>\n<ul class=\"signature-nav\">\n  <li><a class=\"description-link\" href=\"#\">Model</a></li>\n  <li><a class=\"snippet-link\" href=\"#\">Model Schema</a></li>\n</ul>\n<div>\n\n<div class=\"signature-container\">\n  <div class=\"description\">\n    ";
   if (stack1 = helpers.signature) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.signature) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.signature; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.signature; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
   if(stack1 || stack1 === 0) { buffer += stack1; }
-  buffer += "\n    </div>\n\n    <div class=\"snippet\">\n        <pre><code>";
+  buffer += "\n  </div>\n\n  <div class=\"snippet\">\n    <pre><code>";
   if (stack1 = helpers.sampleJSON) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   if (stack1 = helpers.sampleJSON) { stack1 = stack1.call(depth0, {hash:{},data:data}); }
   else { stack1 = depth0.sampleJSON; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   else { stack1 = depth0.sampleJSON; stack1 = typeof stack1 === functionType ? stack1.apply(depth0) : stack1; }
   buffer += escapeExpression(stack1)
   buffer += escapeExpression(stack1)
-    + "</code></pre>\n        <small class=\"notice\"></small>\n    </div>\n</div>\n\n";
+    + "</code></pre>\n    <small class=\"notice\"></small>\n  </div>\n</div>\n\n";
   return buffer;
   return buffer;
   });
   });
 })();
 })();
@@ -1210,7 +1300,7 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
 
 
 // Generated by CoffeeScript 1.6.3
 // Generated by CoffeeScript 1.6.3
 (function() {
 (function() {
-  var ContentTypeView, HeaderView, MainView, OperationView, ParameterContentTypeView, ParameterView, ResourceView, ResponseContentTypeView, SignatureView, StatusCodeView, SwaggerUi, _ref, _ref1, _ref10, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9,
+  var ApiKeyButton, BasicAuthButton, ContentTypeView, HeaderView, MainView, OperationView, ParameterContentTypeView, ParameterView, ResourceView, ResponseContentTypeView, SignatureView, StatusCodeView, SwaggerUi, _ref, _ref1, _ref10, _ref11, _ref12, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9,
     __hasProp = {}.hasOwnProperty,
     __hasProp = {}.hasOwnProperty,
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 
 
@@ -1252,7 +1342,13 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
         return _this.showMessage(d);
         return _this.showMessage(d);
       };
       };
       this.options.failure = function(d) {
       this.options.failure = function(d) {
-        return _this.onLoadFailure(d);
+        if (_this.api && _this.api.isValid === false) {
+          log("not a valid 2.0 spec, loading legacy client");
+          _this.api = new SwaggerApi(_this.options);
+          return _this.api.build();
+        } else {
+          return _this.onLoadFailure(d);
+        }
       };
       };
       this.headerView = new HeaderView({
       this.headerView = new HeaderView({
         el: $('#header')
         el: $('#header')
@@ -1262,6 +1358,14 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       });
       });
     };
     };
 
 
+    SwaggerUi.prototype.setOption = function(option, value) {
+      return this.options[option] = value;
+    };
+
+    SwaggerUi.prototype.getOption = function(option) {
+      return this.options[option];
+    };
+
     SwaggerUi.prototype.updateSwaggerUi = function(data) {
     SwaggerUi.prototype.updateSwaggerUi = function(data) {
       this.options.url = data.url;
       this.options.url = data.url;
       return this.load();
       return this.load();
@@ -1278,9 +1382,20 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       }
       }
       this.options.url = url;
       this.options.url = url;
       this.headerView.update(url);
       this.headerView.update(url);
-      this.api = new SwaggerApi(this.options);
-      this.api.build();
-      return this.api;
+      this.api = new SwaggerClient(this.options);
+      return this.api.build();
+    };
+
+    SwaggerUi.prototype.collapseAll = function() {
+      return Docs.collapseEndpointListForResource('');
+    };
+
+    SwaggerUi.prototype.listAll = function() {
+      return Docs.collapseOperationsForResource('');
+    };
+
+    SwaggerUi.prototype.expandAll = function() {
+      return Docs.expandOperationsForResource('');
     };
     };
 
 
     SwaggerUi.prototype.render = function() {
     SwaggerUi.prototype.render = function() {
@@ -1288,15 +1403,16 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       this.showMessage('Finished Loading Resource Information. Rendering Swagger UI...');
       this.showMessage('Finished Loading Resource Information. Rendering Swagger UI...');
       this.mainView = new MainView({
       this.mainView = new MainView({
         model: this.api,
         model: this.api,
-        el: $('#' + this.dom_id)
+        el: $('#' + this.dom_id),
+        swaggerOptions: this.options
       }).render();
       }).render();
       this.showMessage();
       this.showMessage();
       switch (this.options.docExpansion) {
       switch (this.options.docExpansion) {
         case "full":
         case "full":
-          Docs.expandOperationsForResource('');
+          this.expandAll();
           break;
           break;
         case "list":
         case "list":
-          Docs.collapseOperationsForResource('');
+          this.listAll();
       }
       }
       if (this.options.onComplete) {
       if (this.options.onComplete) {
         this.options.onComplete(this.api, this);
         this.options.onComplete(this.api, this);
@@ -1421,6 +1537,8 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
   })(Backbone.View);
   })(Backbone.View);
 
 
   MainView = (function(_super) {
   MainView = (function(_super) {
+    var sorters;
+
     __extends(MainView, _super);
     __extends(MainView, _super);
 
 
     function MainView() {
     function MainView() {
@@ -1428,10 +1546,74 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       return _ref2;
       return _ref2;
     }
     }
 
 
-    MainView.prototype.initialize = function() {};
+    sorters = {
+      'alpha': function(a, b) {
+        return a.path.localeCompare(b.path);
+      },
+      'method': function(a, b) {
+        return a.method.localeCompare(b.method);
+      }
+    };
+
+    MainView.prototype.initialize = function(opts) {
+      var auth, key, name, url, value, _ref3;
+      if (opts == null) {
+        opts = {};
+      }
+      this.model.auths = [];
+      _ref3 = this.model.securityDefinitions;
+      for (key in _ref3) {
+        value = _ref3[key];
+        auth = {
+          name: key,
+          type: value.type,
+          value: value
+        };
+        this.model.auths.push(auth);
+      }
+      if (this.model.info && this.model.info.license && typeof this.model.info.license === 'string') {
+        name = this.model.info.license;
+        url = this.model.info.licenseUrl;
+        this.model.info.license = {};
+        this.model.info.license.name = name;
+        this.model.info.license.url = url;
+      }
+      if (!this.model.info) {
+        this.model.info = {};
+      }
+      if (!this.model.info.version) {
+        this.model.info.version = this.model.apiVersion;
+      }
+      if (this.model.swaggerVersion === "2.0") {
+        if ("validatorUrl" in opts.swaggerOptions) {
+          return this.model.validatorUrl = opts.swaggerOptions.validatorUrl;
+        } else if (this.model.url.indexOf("localhost") > 0) {
+          return this.model.validatorUrl = null;
+        } else {
+          return this.model.validatorUrl = "http://online.swagger.io/validator";
+        }
+      }
+    };
 
 
     MainView.prototype.render = function() {
     MainView.prototype.render = function() {
-      var counter, id, resource, resources, _i, _len, _ref3;
+      var auth, button, counter, id, name, resource, resources, _i, _len, _ref3;
+      if (this.model.securityDefinitions) {
+        for (name in this.model.securityDefinitions) {
+          auth = this.model.securityDefinitions[name];
+          if (auth.type === "apiKey" && $("#apikey_button").length === 0) {
+            button = new ApiKeyButton({
+              model: auth
+            }).render().el;
+            $('.auth_main_container').append(button);
+          }
+          if (auth.type === "basicAuth" && $("#basic_auth_button").length === 0) {
+            button = new BasicAuthButton({
+              model: auth
+            }).render().el;
+            $('.auth_main_container').append(button);
+          }
+        }
+      }
       $(this.el).html(Handlebars.templates.main(this.model));
       $(this.el).html(Handlebars.templates.main(this.model));
       resources = {};
       resources = {};
       counter = 0;
       counter = 0;
@@ -1445,18 +1627,21 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
         }
         }
         resource.id = id;
         resource.id = id;
         resources[id] = resource;
         resources[id] = resource;
-        this.addResource(resource);
+        this.addResource(resource, this.model.auths);
       }
       }
       return this;
       return this;
     };
     };
 
 
-    MainView.prototype.addResource = function(resource) {
+    MainView.prototype.addResource = function(resource, auths) {
       var resourceView;
       var resourceView;
+      resource.id = resource.id.replace(/\s/g, '_');
       resourceView = new ResourceView({
       resourceView = new ResourceView({
         model: resource,
         model: resource,
         tagName: 'li',
         tagName: 'li',
         id: 'resource_' + resource.id,
         id: 'resource_' + resource.id,
-        className: 'resource'
+        className: 'resource',
+        auths: auths,
+        swaggerOptions: this.options.swaggerOptions
       });
       });
       return $('#resources').append(resourceView.render().el);
       return $('#resources').append(resourceView.render().el);
     };
     };
@@ -1477,12 +1662,23 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       return _ref3;
       return _ref3;
     }
     }
 
 
-    ResourceView.prototype.initialize = function() {};
+    ResourceView.prototype.initialize = function(opts) {
+      if (opts == null) {
+        opts = {};
+      }
+      this.auths = opts.auths;
+      if ("" === this.model.description) {
+        return this.model.description = null;
+      }
+    };
 
 
     ResourceView.prototype.render = function() {
     ResourceView.prototype.render = function() {
       var counter, id, methods, operation, _i, _len, _ref4;
       var counter, id, methods, operation, _i, _len, _ref4;
       $(this.el).html(Handlebars.templates.resource(this.model));
       $(this.el).html(Handlebars.templates.resource(this.model));
       methods = {};
       methods = {};
+      if (this.model.description) {
+        this.model.summary = this.model.description;
+      }
       _ref4 = this.model.operationsArray;
       _ref4 = this.model.operationsArray;
       for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
       for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
         operation = _ref4[_i];
         operation = _ref4[_i];
@@ -1497,6 +1693,9 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
         operation.parentId = this.model.id;
         operation.parentId = this.model.id;
         this.addOperation(operation);
         this.addOperation(operation);
       }
       }
+      $('.toggleEndpointList', this.el).click(this.callDocs.bind(this, 'toggleEndpointListForResource'));
+      $('.collapseResource', this.el).click(this.callDocs.bind(this, 'collapseOperationsForResource'));
+      $('.expandResource', this.el).click(this.callDocs.bind(this, 'expandOperationsForResource'));
       return this;
       return this;
     };
     };
 
 
@@ -1506,12 +1705,19 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       operationView = new OperationView({
       operationView = new OperationView({
         model: operation,
         model: operation,
         tagName: 'li',
         tagName: 'li',
-        className: 'endpoint'
+        className: 'endpoint',
+        swaggerOptions: this.options.swaggerOptions,
+        auths: this.auths
       });
       });
       $('.endpoints', $(this.el)).append(operationView.render().el);
       $('.endpoints', $(this.el)).append(operationView.render().el);
       return this.number++;
       return this.number++;
     };
     };
 
 
+    ResourceView.prototype.callDocs = function(fnName, e) {
+      e.preventDefault();
+      return Docs[fnName](e.currentTarget.getAttribute('data-id'));
+    };
+
     return ResourceView;
     return ResourceView;
 
 
   })(Backbone.View);
   })(Backbone.View);
@@ -1535,13 +1741,19 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       'mouseout .api-ic': 'mouseExit'
       'mouseout .api-ic': 'mouseExit'
     };
     };
 
 
-    OperationView.prototype.initialize = function() {};
+    OperationView.prototype.initialize = function(opts) {
+      if (opts == null) {
+        opts = {};
+      }
+      this.auths = opts.auths;
+      return this;
+    };
 
 
     OperationView.prototype.mouseEnter = function(e) {
     OperationView.prototype.mouseEnter = function(e) {
       var elem, hgh, pos, scMaxX, scMaxY, scX, scY, wd, x, y;
       var elem, hgh, pos, scMaxX, scMaxY, scX, scY, wd, x, y;
       elem = $(e.currentTarget.parentNode).find('#api_information_panel');
       elem = $(e.currentTarget.parentNode).find('#api_information_panel');
-      x = event.pageX;
-      y = event.pageY;
+      x = e.pageX;
+      y = e.pageY;
       scX = $(window).scrollLeft();
       scX = $(window).scrollLeft();
       scY = $(window).scrollTop();
       scY = $(window).scrollTop();
       scMaxX = scX + $(window).width();
       scMaxX = scX + $(window).width();
@@ -1572,30 +1784,83 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
     };
     };
 
 
     OperationView.prototype.render = function() {
     OperationView.prototype.render = function() {
-      var contentTypeModel, isMethodSubmissionSupported, k, o, param, responseContentTypeView, responseSignatureView, signatureModel, statusCode, type, v, _i, _j, _k, _l, _len, _len1, _len2, _len3, _ref5, _ref6, _ref7, _ref8;
+      var a, auth, auths, code, contentTypeModel, isMethodSubmissionSupported, k, key, o, param, ref, responseContentTypeView, responseSignatureView, schema, schemaObj, signatureModel, statusCode, type, v, value, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _m, _ref10, _ref11, _ref5, _ref6, _ref7, _ref8, _ref9;
       isMethodSubmissionSupported = true;
       isMethodSubmissionSupported = true;
       if (!isMethodSubmissionSupported) {
       if (!isMethodSubmissionSupported) {
         this.model.isReadOnly = true;
         this.model.isReadOnly = true;
       }
       }
+      this.model.description = this.model.description || this.model.notes;
+      if (this.model.description) {
+        this.model.description = this.model.description.replace(/(?:\r\n|\r|\n)/g, '<br />');
+      }
       this.model.oauth = null;
       this.model.oauth = null;
       if (this.model.authorizations) {
       if (this.model.authorizations) {
-        _ref5 = this.model.authorizations;
-        for (k in _ref5) {
-          v = _ref5[k];
-          if (k === "oauth2") {
-            if (this.model.oauth === null) {
-              this.model.oauth = {};
+        if (Array.isArray(this.model.authorizations)) {
+          _ref5 = this.model.authorizations;
+          for (_i = 0, _len = _ref5.length; _i < _len; _i++) {
+            auths = _ref5[_i];
+            for (key in auths) {
+              auth = auths[key];
+              for (a in this.auths) {
+                auth = this.auths[a];
+                if (auth.type === 'oauth2') {
+                  this.model.oauth = {};
+                  this.model.oauth.scopes = [];
+                  _ref6 = auth.value.scopes;
+                  for (k in _ref6) {
+                    v = _ref6[k];
+                    o = {
+                      scope: k,
+                      description: v
+                    };
+                    this.model.oauth.scopes.push(o);
+                  }
+                }
+              }
             }
             }
-            if (this.model.oauth.scopes === void 0) {
-              this.model.oauth.scopes = [];
+          }
+        } else {
+          _ref7 = this.model.authorizations;
+          for (k in _ref7) {
+            v = _ref7[k];
+            if (k === "oauth2") {
+              if (this.model.oauth === null) {
+                this.model.oauth = {};
+              }
+              if (this.model.oauth.scopes === void 0) {
+                this.model.oauth.scopes = [];
+              }
+              for (_j = 0, _len1 = v.length; _j < _len1; _j++) {
+                o = v[_j];
+                this.model.oauth.scopes.push(o);
+              }
             }
             }
-            for (_i = 0, _len = v.length; _i < _len; _i++) {
-              o = v[_i];
-              this.model.oauth.scopes.push(o);
+          }
+        }
+      }
+      if (typeof this.model.responses !== 'undefined') {
+        this.model.responseMessages = [];
+        _ref8 = this.model.responses;
+        for (code in _ref8) {
+          value = _ref8[code];
+          schema = null;
+          schemaObj = this.model.responses[code].schema;
+          if (schemaObj && schemaObj['$ref']) {
+            schema = schemaObj['$ref'];
+            if (schema.indexOf('#/definitions/') === 0) {
+              schema = schema.substring('#/definitions/'.length);
             }
             }
           }
           }
+          this.model.responseMessages.push({
+            code: code,
+            message: value.description,
+            responseModel: schema
+          });
         }
         }
       }
       }
+      if (typeof this.model.responseMessages === 'undefined') {
+        this.model.responseMessages = [];
+      }
       $(this.el).html(Handlebars.templates.operation(this.model));
       $(this.el).html(Handlebars.templates.operation(this.model));
       if (this.model.responseClassSignature && this.model.responseClassSignature !== 'string') {
       if (this.model.responseClassSignature && this.model.responseClassSignature !== 'string') {
         signatureModel = {
         signatureModel = {
@@ -1609,6 +1874,7 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
         });
         });
         $('.model-signature', $(this.el)).append(responseSignatureView.render().el);
         $('.model-signature', $(this.el)).append(responseSignatureView.render().el);
       } else {
       } else {
+        this.model.responseClassSignature = 'string';
         $('.model-signature', $(this.el)).html(this.model.type);
         $('.model-signature', $(this.el)).html(this.model.type);
       }
       }
       contentTypeModel = {
       contentTypeModel = {
@@ -1616,29 +1882,40 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       };
       };
       contentTypeModel.consumes = this.model.consumes;
       contentTypeModel.consumes = this.model.consumes;
       contentTypeModel.produces = this.model.produces;
       contentTypeModel.produces = this.model.produces;
-      _ref6 = this.model.parameters;
-      for (_j = 0, _len1 = _ref6.length; _j < _len1; _j++) {
-        param = _ref6[_j];
+      _ref9 = this.model.parameters;
+      for (_k = 0, _len2 = _ref9.length; _k < _len2; _k++) {
+        param = _ref9[_k];
         type = param.type || param.dataType;
         type = param.type || param.dataType;
-        if (type.toLowerCase() === 'file') {
+        if (typeof type === 'undefined') {
+          schema = param.schema;
+          if (schema && schema['$ref']) {
+            ref = schema['$ref'];
+            if (ref.indexOf('#/definitions/') === 0) {
+              type = ref.substring('#/definitions/'.length);
+            } else {
+              type = ref;
+            }
+          }
+        }
+        if (type && type.toLowerCase() === 'file') {
           if (!contentTypeModel.consumes) {
           if (!contentTypeModel.consumes) {
-            log("set content type ");
             contentTypeModel.consumes = 'multipart/form-data';
             contentTypeModel.consumes = 'multipart/form-data';
           }
           }
         }
         }
+        param.type = type;
       }
       }
       responseContentTypeView = new ResponseContentTypeView({
       responseContentTypeView = new ResponseContentTypeView({
         model: contentTypeModel
         model: contentTypeModel
       });
       });
       $('.response-content-type', $(this.el)).append(responseContentTypeView.render().el);
       $('.response-content-type', $(this.el)).append(responseContentTypeView.render().el);
-      _ref7 = this.model.parameters;
-      for (_k = 0, _len2 = _ref7.length; _k < _len2; _k++) {
-        param = _ref7[_k];
+      _ref10 = this.model.parameters;
+      for (_l = 0, _len3 = _ref10.length; _l < _len3; _l++) {
+        param = _ref10[_l];
         this.addParameter(param, contentTypeModel.consumes);
         this.addParameter(param, contentTypeModel.consumes);
       }
       }
-      _ref8 = this.model.responseMessages;
-      for (_l = 0, _len3 = _ref8.length; _l < _len3; _l++) {
-        statusCode = _ref8[_l];
+      _ref11 = this.model.responseMessages;
+      for (_m = 0, _len4 = _ref11.length; _m < _len4; _m++) {
+        statusCode = _ref11[_m];
         this.addStatusCode(statusCode);
         this.addStatusCode(statusCode);
       }
       }
       return this;
       return this;
@@ -1684,6 +1961,19 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
           return error_free = false;
           return error_free = false;
         }
         }
       });
       });
+      form.find("textarea.required").each(function() {
+        var _this = this;
+        $(this).removeClass("error");
+        if (jQuery.trim($(this).val()) === "") {
+          $(this).addClass("error");
+          $(this).wiggle({
+            callback: function() {
+              return $(_this).focus();
+            }
+          });
+          return error_free = false;
+        }
+      });
       if (error_free) {
       if (error_free) {
         map = {};
         map = {};
         opts = {
         opts = {
@@ -1704,7 +1994,7 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
         for (_j = 0, _len1 = _ref6.length; _j < _len1; _j++) {
         for (_j = 0, _len1 = _ref6.length; _j < _len1; _j++) {
           o = _ref6[_j];
           o = _ref6[_j];
           if ((o.value != null) && jQuery.trim(o.value).length > 0) {
           if ((o.value != null) && jQuery.trim(o.value).length > 0) {
-            map["body"] = o.value;
+            map[o.name] = o.value;
           }
           }
         }
         }
         _ref7 = form.find("select");
         _ref7 = form.find("select");
@@ -1746,7 +2036,7 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
       for (_j = 0, _len1 = _ref6.length; _j < _len1; _j++) {
       for (_j = 0, _len1 = _ref6.length; _j < _len1; _j++) {
         param = _ref6[_j];
         param = _ref6[_j];
         if (param.paramType === 'form') {
         if (param.paramType === 'form') {
-          if (map[param.name] !== void 0) {
+          if (param.type.toLowerCase() !== 'file' && map[param.name] !== void 0) {
             bodyParam.append(param.name, map[param.name]);
             bodyParam.append(param.name, map[param.name]);
           }
           }
         }
         }
@@ -1759,7 +2049,6 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
           headerParams[param.name] = map[param.name];
           headerParams[param.name] = map[param.name];
         }
         }
       }
       }
-      log(headerParams);
       _ref8 = form.find('input[type~="file"]');
       _ref8 = form.find('input[type~="file"]');
       for (_l = 0, _len3 = _ref8.length; _l < _len3; _l++) {
       for (_l = 0, _len3 = _ref8.length; _l < _len3; _l++) {
         el = _ref8[_l];
         el = _ref8[_l];
@@ -1768,9 +2057,9 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
           params += 1;
           params += 1;
         }
         }
       }
       }
-      log(bodyParam);
-      this.invocationUrl = this.model.supportHeaderParams() ? (headerParams = this.model.getHeaderParams(map), this.model.urlify(map, false)) : this.model.urlify(map, true);
-      $(".request_url", $(this.el)).html("<pre>" + this.invocationUrl + "</pre>");
+      this.invocationUrl = this.model.supportHeaderParams() ? (headerParams = this.model.getHeaderParams(map), delete headerParams['Content-Type'], this.model.urlify(map, false)) : this.model.urlify(map, true);
+      $(".request_url", $(this.el)).html("<pre></pre>");
+      $(".request_url pre", $(this.el)).text(this.invocationUrl);
       obj = {
       obj = {
         type: this.model.method,
         type: this.model.method,
         url: this.invocationUrl,
         url: this.invocationUrl,
@@ -1834,7 +2123,7 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
           }
           }
         }
         }
         if (options.length > 0) {
         if (options.length > 0) {
-          return options.join(",");
+          return options;
         } else {
         } else {
           return null;
           return null;
         }
         }
@@ -1937,7 +2226,7 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
     };
     };
 
 
     OperationView.prototype.showStatus = function(response) {
     OperationView.prototype.showStatus = function(response) {
-      var code, content, contentType, headers, pre, response_body, url;
+      var code, content, contentType, e, headers, json, opts, pre, response_body, response_body_el, url;
       if (response.content === void 0) {
       if (response.content === void 0) {
         content = response.data;
         content = response.data;
         url = response.url;
         url = response.url;
@@ -1946,18 +2235,31 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
         url = response.request.url;
         url = response.request.url;
       }
       }
       headers = response.headers;
       headers = response.headers;
-      contentType = headers && headers["Content-Type"] ? headers["Content-Type"].split(";")[0].trim() : null;
+      contentType = null;
+      if (headers) {
+        contentType = headers["Content-Type"] || headers["content-type"];
+        if (contentType) {
+          contentType = contentType.split(";")[0].trim();
+        }
+      }
       if (!content) {
       if (!content) {
         code = $('<code />').text("no content");
         code = $('<code />').text("no content");
         pre = $('<pre class="json" />').append(code);
         pre = $('<pre class="json" />').append(code);
       } else if (contentType === "application/json" || /\+json$/.test(contentType)) {
       } else if (contentType === "application/json" || /\+json$/.test(contentType)) {
-        code = $('<code />').text(JSON.stringify(JSON.parse(content), null, "  "));
+        json = null;
+        try {
+          json = JSON.stringify(JSON.parse(content), null, "  ");
+        } catch (_error) {
+          e = _error;
+          json = "can't parse JSON.  Raw result:\n\n" + content;
+        }
+        code = $('<code />').text(json);
         pre = $('<pre class="json" />').append(code);
         pre = $('<pre class="json" />').append(code);
       } else if (contentType === "application/xml" || /\+xml$/.test(contentType)) {
       } else if (contentType === "application/xml" || /\+xml$/.test(contentType)) {
         code = $('<code />').text(this.formatXml(content));
         code = $('<code />').text(this.formatXml(content));
         pre = $('<pre class="xml" />').append(code);
         pre = $('<pre class="xml" />').append(code);
       } else if (contentType === "text/html") {
       } else if (contentType === "text/html") {
-        code = $('<code />').html(content);
+        code = $('<code />').html(_.escape(content));
         pre = $('<pre class="xml" />').append(code);
         pre = $('<pre class="xml" />').append(code);
       } else if (/^image\//.test(contentType)) {
       } else if (/^image\//.test(contentType)) {
         pre = $('<img>').attr('src', url);
         pre = $('<img>').attr('src', url);
@@ -1966,19 +2268,26 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
         pre = $('<pre class="json" />').append(code);
         pre = $('<pre class="json" />').append(code);
       }
       }
       response_body = pre;
       response_body = pre;
-      $(".request_url", $(this.el)).html("<pre>" + url + "</pre>");
+      $(".request_url", $(this.el)).html("<pre></pre>");
+      $(".request_url pre", $(this.el)).text(url);
       $(".response_code", $(this.el)).html("<pre>" + response.status + "</pre>");
       $(".response_code", $(this.el)).html("<pre>" + response.status + "</pre>");
       $(".response_body", $(this.el)).html(response_body);
       $(".response_body", $(this.el)).html(response_body);
       $(".response_headers", $(this.el)).html("<pre>" + _.escape(JSON.stringify(response.headers, null, "  ")).replace(/\n/g, "<br>") + "</pre>");
       $(".response_headers", $(this.el)).html("<pre>" + _.escape(JSON.stringify(response.headers, null, "  ")).replace(/\n/g, "<br>") + "</pre>");
       $(".response", $(this.el)).slideDown();
       $(".response", $(this.el)).slideDown();
       $(".response_hider", $(this.el)).show();
       $(".response_hider", $(this.el)).show();
       $(".response_throbber", $(this.el)).hide();
       $(".response_throbber", $(this.el)).hide();
-      return hljs.highlightBlock($('.response_body', $(this.el))[0]);
+      response_body_el = $('.response_body', $(this.el))[0];
+      opts = this.options.swaggerOptions;
+      if (opts.highlightSizeThreshold && response.data.length > opts.highlightSizeThreshold) {
+        return response_body_el;
+      } else {
+        return hljs.highlightBlock(response_body_el);
+      }
     };
     };
 
 
     OperationView.prototype.toggleOperationContent = function() {
     OperationView.prototype.toggleOperationContent = function() {
       var elem;
       var elem;
-      elem = $('#' + Docs.escapeResourceName(this.model.parentId) + "_" + this.model.nickname + "_content");
+      elem = $('#' + Docs.escapeResourceName(this.model.parentId + "_" + this.model.nickname + "_content"));
       if (elem.is(':visible')) {
       if (elem.is(':visible')) {
         return Docs.collapseOperation(elem);
         return Docs.collapseOperation(elem);
       } else {
       } else {
@@ -2048,14 +2357,31 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
     };
     };
 
 
     ParameterView.prototype.render = function() {
     ParameterView.prototype.render = function() {
-      var contentTypeModel, isParam, parameterContentTypeView, responseContentTypeView, signatureModel, signatureView, template, type;
+      var contentTypeModel, isParam, parameterContentTypeView, ref, responseContentTypeView, schema, signatureModel, signatureView, template, type;
       type = this.model.type || this.model.dataType;
       type = this.model.type || this.model.dataType;
+      if (typeof type === 'undefined') {
+        schema = this.model.schema;
+        if (schema && schema['$ref']) {
+          ref = schema['$ref'];
+          if (ref.indexOf('#/definitions/') === 0) {
+            type = ref.substring('#/definitions/'.length);
+          } else {
+            type = ref;
+          }
+        }
+      }
+      this.model.type = type;
+      this.model.paramType = this.model["in"] || this.model.paramType;
       if (this.model.paramType === 'body') {
       if (this.model.paramType === 'body') {
         this.model.isBody = true;
         this.model.isBody = true;
       }
       }
-      if (type.toLowerCase() === 'file') {
+      if (type && type.toLowerCase() === 'file') {
         this.model.isFile = true;
         this.model.isFile = true;
       }
       }
+      this.model["default"] = this.model["default"] || this.model.defaultValue;
+      if (this.model.allowableValues) {
+        this.model.isList = true;
+      }
       template = this.template();
       template = this.template();
       $(this.el).html(template(this.model));
       $(this.el).html(template(this.model));
       signatureModel = {
       signatureModel = {
@@ -2265,4 +2591,107 @@ helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
 
 
   })(Backbone.View);
   })(Backbone.View);
 
 
+  ApiKeyButton = (function(_super) {
+    __extends(ApiKeyButton, _super);
+
+    function ApiKeyButton() {
+      _ref11 = ApiKeyButton.__super__.constructor.apply(this, arguments);
+      return _ref11;
+    }
+
+    ApiKeyButton.prototype.initialize = function() {};
+
+    ApiKeyButton.prototype.render = function() {
+      var template;
+      template = this.template();
+      $(this.el).html(template(this.model));
+      return this;
+    };
+
+    ApiKeyButton.prototype.events = {
+      "click #apikey_button": "toggleApiKeyContainer",
+      "click #apply_api_key": "applyApiKey"
+    };
+
+    ApiKeyButton.prototype.applyApiKey = function() {
+      var elem;
+      window.authorizations.add(this.model.name, new ApiKeyAuthorization(this.model.name, $("#input_apiKey_entry").val(), this.model["in"]));
+      window.swaggerUi.load();
+      return elem = $('#apikey_container').show();
+    };
+
+    ApiKeyButton.prototype.toggleApiKeyContainer = function() {
+      var elem;
+      if ($('#apikey_container').length > 0) {
+        elem = $('#apikey_container').first();
+        if (elem.is(':visible')) {
+          return elem.hide();
+        } else {
+          $('.auth_container').hide();
+          return elem.show();
+        }
+      }
+    };
+
+    ApiKeyButton.prototype.template = function() {
+      return Handlebars.templates.apikey_button_view;
+    };
+
+    return ApiKeyButton;
+
+  })(Backbone.View);
+
+  BasicAuthButton = (function(_super) {
+    __extends(BasicAuthButton, _super);
+
+    function BasicAuthButton() {
+      _ref12 = BasicAuthButton.__super__.constructor.apply(this, arguments);
+      return _ref12;
+    }
+
+    BasicAuthButton.prototype.initialize = function() {};
+
+    BasicAuthButton.prototype.render = function() {
+      var template;
+      template = this.template();
+      $(this.el).html(template(this.model));
+      return this;
+    };
+
+    BasicAuthButton.prototype.events = {
+      "click #basic_auth_button": "togglePasswordContainer",
+      "click #apply_basic_auth": "applyPassword"
+    };
+
+    BasicAuthButton.prototype.applyPassword = function() {
+      var elem, password, username;
+      console.log("applying password");
+      username = $(".input_username").val();
+      password = $(".input_password").val();
+      window.authorizations.add(this.model.type, new PasswordAuthorization("basic", username, password));
+      window.swaggerUi.load();
+      return elem = $('#basic_auth_container').hide();
+    };
+
+    BasicAuthButton.prototype.togglePasswordContainer = function() {
+      var elem;
+      if ($('#basic_auth_container').length > 0) {
+        elem = $('#basic_auth_container').show();
+        if (elem.is(':visible')) {
+          return elem.slideUp();
+        } else {
+          $('.auth_container').hide();
+          return elem.show();
+        }
+      }
+    };
+
+    BasicAuthButton.prototype.template = function() {
+      return Handlebars.templates.basic_auth_button_view;
+    };
+
+    return BasicAuthButton;
+
+  })(Backbone.View);
+
 }).call(this);
 }).call(this);