/***Generated Resource **/
var resource = require('resource');
var FoodEstablishment = resource.define('FoodEstablishment');
FoodEstablishment.schema.description = "A food-related business.";
FoodEstablishment.persist('fs');
FoodEstablishment.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
FoodEstablishment.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
FoodEstablishment.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
var resource = require('resource'),
node = resource.define('node');
node.schema.description = "for managing nodes";
node.persist('memory');
node.property("port", {
"type": "number",
"default": 7777,
"description": "the port of the node"
});
node.property("host", {
"type": "string",
"default": "0.0.0.0",
"description": "the host of the node"
});
node.property("name", {
"type": "string",
"description": "the name of the node"
});
node.property('events', {
"description": "the total amount of events processed by this node",
"type": "number"
});
node.property('username', {
/***Generated Resource **/
var resource = require('resource');
var BedAndBreakfast = resource.define('BedAndBreakfast');
BedAndBreakfast.schema.description = "Bed and breakfast.";
BedAndBreakfast.persist('fs');
BedAndBreakfast.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
BedAndBreakfast.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
BedAndBreakfast.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var Aquarium = resource.define('Aquarium');
Aquarium.schema.description = "Aquarium.";
Aquarium.persist('fs');
Aquarium.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
Aquarium.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
Aquarium.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var SellAction = resource.define('SellAction');
SellAction.schema.description = "The act of taking money from a buyer in exchange for goods or services rendered. An agent sells an object, product, or service to a buyer for a price. Reciprocal of BuyAction.";
SellAction.persist('fs');
SellAction.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
SellAction.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
SellAction.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var MaximumDoseSchedule = resource.define('MaximumDoseSchedule');
MaximumDoseSchedule.schema.description = "The maximum dosing schedule considered safe for a drug or supplement as recommended by an authority or by the drug/supplement's manufacturer. Capture the recommending authority in the recognizingAuthority property of MedicalEntity.";
MaximumDoseSchedule.persist('fs');
MaximumDoseSchedule.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
MaximumDoseSchedule.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
MaximumDoseSchedule.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var MedicalRiskEstimator = resource.define('MedicalRiskEstimator');
MedicalRiskEstimator.schema.description = "Any rule set or interactive tool for estimating the risk of developing a complication or condition.";
MedicalRiskEstimator.persist('fs');
MedicalRiskEstimator.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
MedicalRiskEstimator.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
MedicalRiskEstimator.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
var resource = require('resource'),
view = resource.define('view'),
View = require('./lib/View'),
errors = require('./lib/errors');
//
// Export the View class for convenience
//
exports.View = View;
view.View = View;
view.errors = errors;
view.schema.description = "for managing views";
view.property("path", {
"type": "string",
"description": "the path to the view",
"format": "uri"
});
view.property("template", {
"type": "string",
"description": "the string template of the view"
});
view.property("templatePath", {
"type": "string",
"description": "the path to the template of the view",
"format": "uri"
});
/***Generated Resource **/
var resource = require('resource');
var Rating = resource.define('Rating');
Rating.schema.description = "The rating of the video.";
Rating.persist('fs');
Rating.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
Rating.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
Rating.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
var tap = require('tap');
var resource = require('resource');
var queue = require('../');
// var http = resource.use('http');
// var request = http.request;
var counter = resource.counter = resource.define('counter');
counter.property('message', {
type: 'string'
});
counter.property('timestamp', { type: 'any' });
counter.persist('memory');
counter.before('create', function (data, next) {
console.error('# about to create %j', data);
next(null, data);
});
counter.after('create', function (data, next) {
console.error('# just created %j', data);
next(null, data);
});
queue.on('error', function (err) {
console.log('queue error:');
if (!(err instanceof Error)) {
console.log(err);
}
throw err;
});
/***Generated Resource **/
var resource = require('resource');
var SelfStorage = resource.define('SelfStorage');
SelfStorage.schema.description = "Self-storage facility.";
SelfStorage.persist('fs');
SelfStorage.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
SelfStorage.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
SelfStorage.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var ComedyClub = resource.define('ComedyClub');
ComedyClub.schema.description = "A comedy club.";
ComedyClub.persist('fs');
ComedyClub.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
ComedyClub.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
ComedyClub.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var FindAction = resource.define('FindAction');
FindAction.schema.description = "The act of finding an object.Related actions:SearchAction: FindAction is generally lead by a SearchAction, but not necessarily.";
FindAction.persist('fs');
FindAction.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
FindAction.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
FindAction.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
var resource = require("resource"),
analytics = resource.define("analytics"),
fs = require('fs');
analytics.schema.description = "real-time analytics by google";
var inject = function (gid, callback) {
var template = fs.readFileSync(__dirname + '/template.js').toString();
template = template.replace('{{GID}}', gid);
if (callback) {
return callback(null, template);
} else {
return template;
}
}
analytics.method('inject', inject, {
"description": "returns templatizaed google adsense javascript embed based on account id",
"properties": {
"accountID" : {
"type": "string",
"required": true,
"default": "UA-XXXXX-Y"
}
}
});
exports.analytics = analytics;
/***Generated Resource **/
var resource = require('resource');
var CollegeOrUniversity = resource.define('CollegeOrUniversity');
CollegeOrUniversity.schema.description = "A college, university, or other third-level educational institution.";
CollegeOrUniversity.persist('fs');
CollegeOrUniversity.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
CollegeOrUniversity.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
CollegeOrUniversity.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var RiverBodyOfWater = resource.define('RiverBodyOfWater');
RiverBodyOfWater.schema.description = "A river (for example, the broad majestic Shannon).";
RiverBodyOfWater.persist('fs');
RiverBodyOfWater.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
RiverBodyOfWater.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
RiverBodyOfWater.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/*
Basic Key store for public / private crypto-keys
Currently used to manage developer access keys for public / private hooks
*/
var resource = require('resource');
var keys = resource.define('keys');
var config = require('../../../config');
var uuid = require('node-uuid');
keys.timestamps();
keys.property('name', {
"type": "string",
"default": "my-key-name",
"required": true,
"minLength": 1,
"maxLength": 50
});
keys.property('owner', {
"type": "string",
"default": "anonymous",
"required": true,
"minLength": 1,
"maxLength": 50
});
keys.property('hook_public_key', {
"type": "string",
"default": "public-" + new Date().getTime()
/***Generated Resource **/
var resource = require('resource');
var CafeOrCoffeeShop = resource.define('CafeOrCoffeeShop');
CafeOrCoffeeShop.schema.description = "A cafe or coffee shop.";
CafeOrCoffeeShop.persist('fs');
CafeOrCoffeeShop.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
CafeOrCoffeeShop.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
CafeOrCoffeeShop.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var ExerciseGym = resource.define('ExerciseGym');
ExerciseGym.schema.description = "A gym.";
ExerciseGym.persist('fs');
ExerciseGym.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
ExerciseGym.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
ExerciseGym.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
var resource = require('resource'),
crypto = require('crypto'),
uuid = require('node-uuid');
var user = resource.define('user', {
controller: require('./lib/'),
schema: require('./user.mschema')
});
//
// Setup resource hooks
//
user.before('create', function (data, next) {
// check that user name is available
user.find({ name: data.name }, function(err, result){
if (err) {
return next(err);
}
if (result.length >= 1) {
return next(new Error('user name is unavailable.'));
}
return next(null, data)
});
});
user.before('create', function (_user, next) {
if (typeof _user.password === 'undefined') {
// if no password is present at the time of user creation, create a default password
_user.password = uuid();
}
next(null, _user);
/***Generated Resource **/
var resource = require('resource');
var AboutPage = resource.define('AboutPage');
AboutPage.schema.description = "Web page type: About page.";
AboutPage.persist('fs');
AboutPage.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
AboutPage.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
AboutPage.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var VoteAction = resource.define('VoteAction');
VoteAction.schema.description = "The act of expressing a preference from a fixed/finite/structured set of choices/options.";
VoteAction.persist('fs');
VoteAction.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
VoteAction.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
VoteAction.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var Festival = resource.define('Festival');
Festival.schema.description = "Event type: Festival.";
Festival.persist('fs');
Festival.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
Festival.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
Festival.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
var resource = require('resource');
var domain = resource.define('domain');
//var config = require('../../config');
domain.timestamps();
domain.property('name', {
"type": "string",
"default": "marak.com",
"required": true,
"minLength": 1,
"maxLength": 50
});
domain.property('owner', {
"type": "string",
"required": true
});
module['exports'] = domain;
/***Generated Resource **/
var resource = require('resource');
var MedicalCode = resource.define('MedicalCode');
MedicalCode.schema.description = "A code for a medical entity.";
MedicalCode.persist('fs');
MedicalCode.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
MedicalCode.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
MedicalCode.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var DeliveryChargeSpecification = resource.define('DeliveryChargeSpecification');
DeliveryChargeSpecification.schema.description = "The price for the delivery of an offer using a particular delivery method.";
DeliveryChargeSpecification.persist('fs');
DeliveryChargeSpecification.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
DeliveryChargeSpecification.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
DeliveryChargeSpecification.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var WebApplication = resource.define('WebApplication');
WebApplication.schema.description = "Web applications.";
WebApplication.persist('fs');
WebApplication.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
WebApplication.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
WebApplication.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
/***Generated Resource **/
var resource = require('resource');
var InfectiousDisease = resource.define('InfectiousDisease');
InfectiousDisease.schema.description = "An infectious disease is a clinically evident human disease resulting from the presence of pathogenic microbial agents, like pathogenic viruses, pathogenic bacteria, fungi, protozoa, multicellular parasites, and prions. To be considered an infectious disease, such pathogens are known to be able to cause this disease.";
InfectiousDisease.persist('fs');
InfectiousDisease.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
InfectiousDisease.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
InfectiousDisease.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});
var resource = require('resource'),
admin = resource.define('admin');
admin.schema.description = "a web based admin panel";
//
// The admin requires a view engine
//
resource.use('view');
//
// The html resource provides simple HTML templating
//
resource.use('html');
//
// The system resource helps gather information about the system
//
resource.use('system');
//
// The datasource resource is used to store datasource persistence connections
//
resource.use('datasource', { datasource: "fs" });
//
// replication and node resources are used to store information about replicator and mesh history.
// Although the replicator and mesh resource aren't automatically installed with the admin,
// they easily can be added
//
resource.use('replication', { datasource: "fs"});
/***Generated Resource **/
var resource = require('resource');
var Mountain = resource.define('Mountain');
Mountain.schema.description = "A mountain, like Mount Whitney or Mount Everest";
Mountain.persist('fs');
Mountain.property('additionalType', {
"name" : "additionalType",
"displayName" : "Additional Type",
"description" : "An additional type for the item, typically used for adding more specific types from external vocabularies in microdata syntax. This is a relationship between something and a class that the thing is in. In RDFa syntax, it is better to use the native RDFa syntax - the 'typeof' attribute - for multiple types. Schema.org tools may have only weaker understanding of extra types, in particular those defined externally.",
"type": "string"
});
Mountain.property('description', {
"name" : "description",
"displayName" : "Description",
"description" : "A short description of the item.",
"type": "string"
});
Mountain.property('image', {
"name" : "image",
"displayName" : "Image",
"description" : "URL of an image of the item.",
"type": "string"
});