text:
/* exported Handlebars */
var Handlebars = (function() {
// handlebars/safe-string.js
var __module3__ = (function() {
  "use strict";
  var __exports__;
  // Build out our basic SafeString type
  function SafeString(string) {
    this.string = string;
  }

  SafeString.prototype.toString = function() {
    return "" + this.string;
  };

  __exports__ = SafeString;
  return __exports__;
})();

// handlebars/utils.js
var __module2__ = (function(__dependency1__) {
  "use strict";
  var __exports__ = {};
  /*jshint -W004 */
  var SafeString = __dependency1__;

  var escape = {
    "&": "&",
    "<": "<",
    ">": ">",
    '"': """,
    "'": "'",
    "`": "`"
  };

  var badChars = /[&<>"'`]/g;
  var possible = /[&<>"'`]/;

  function escapeChar(chr) {
    return escape[chr] || "&";
  }

  function extend(obj, value) {
    for(var key in value) {
      if(Object.prototype.hasOwnProperty.call(value, key)) {
        obj[key] = value[key];
      }
    }
  }

  __exports__.extend = extend;var toString = Object.prototype.toString;
  __exports__.toString = toString;
  // Sourced from lodash
  // https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
  var isFunction = function(value) {
    return typeof value === 'function';
  };
  // fallback for older versions of Chrome and Safari
  if (isFunction(/x/)) {
    isFunction = function(value) {
      return typeof value === 'function' && toString.call(value) === '[object Function]';
    };
  }
  var isFunction;
  __exports__.isFunction = isFunction;
  var isArray = Array.isArray || function(value) {
    return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
  };
  __exports__.isArray = isArray;

  function escapeExpression(string) {
    // don't escape SafeStrings, since they're already safe
    if (string instanceof SafeString) {
      return string.toString();
    } else if (!string && string !== 0) {
      return "";
    }

    // Force a string conversion as this will be done by the append regardless and
    // the regex test will do this transparently behind the scenes, causing issues if
    // an object's to string has escaped characters in it.
    string = "" + string;

    if(!possible.test(string)) { return string; }
    return string.replace(badChars, escapeChar);
  }

  __exports__.escapeExpression = escapeExpression;function isEmpty(value) {
    if (!value && value !== 0) {
      return true;
    } else if (isArray(value) && value.length === 0) {
      return true;
    } else {
      return false;
    }
  }

  __exports__.isEmpty = isEmpty;
  return __exports__;
})(__module3__);

// handlebars/exception.js
var __module4__ = (function() {
  "use strict";
  var __exports__;

  var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];

  function Exception(message, node) {
    var line;
    if (node && node.firstLine) {
      line = node.firstLine;

      message += ' - ' + line + ':' + node.firstColumn;
    }

    var tmp = Error.prototype.constructor.call(this, message);

    // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
    for (var idx = 0; idx < errorProps.length; idx++) {
      this[errorProps[idx]] = tmp[errorProps[idx]];
    }

    if (line) {
      this.lineNumber = line;
      this.column = node.firstColumn;
    }
  }

  Exception.prototype = new Error();

  __exports__ = Exception;
  return __exports__;
})();

// handlebars/base.js
var __module1__ = (function(__dependency1__, __dependency2__) {
  "use strict";
  var __exports__ = {};
  var Utils = __dependency1__;
  var Exception = __dependency2__;

  var VERSION = "1.3.0";
  __exports__.VERSION = VERSION;var COMPILER_REVISION = 4;
  __exports__.COMPILER_REVISION = COMPILER_REVISION;
  var REVISION_CHANGES = {
    1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
    2: '== 1.0.0-rc.3',
    3: '== 1.0.0-rc.4',
    4: '>= 1.0.0'
  };
  __exports__.REVISION_CHANGES = REVISION_CHANGES;
  var isArray = Utils.isArray,
      isFunction = Utils.isFunction,
      toString = Utils.toString,
      objectType = '[object Object]';

  function HandlebarsEnvironment(helpers, partials) {
    this.helpers = helpers || {};
    this.partials = partials || {};

    registerDefaultHelpers(this);
  }

  __exports__.HandlebarsEnvironment = HandlebarsEnvironment;HandlebarsEnvironment.prototype = {
    constructor: HandlebarsEnvironment,

    logger: logger,
    log: log,

    registerHelper: function(name, fn, inverse) {
      if (toString.call(name) === objectType) {
        if (inverse || fn) { throw new Exception('Arg not supported with multiple helpers'); }
        Utils.extend(this.helpers, name);
      } else {
        if (inverse) { fn.not = inverse; }
        this.helpers[name] = fn;
      }
    },

    registerPartial: function(name, str) {
      if (toString.call(name) === objectType) {
        Utils.extend(this.partials,  name);
      } else {
        this.partials[name] = str;
      }
    }
  };

  function registerDefaultHelpers(instance) {
    instance.registerHelper('helperMissing', function(arg) {
      if(arguments.length === 2) {
        return undefined;
      } else {
        throw new Exception("Missing helper: '" + arg + "'");
      }
    });

    instance.registerHelper('blockHelperMissing', function(context, options) {
      var inverse = options.inverse || function() {}, fn = options.fn;

      if (isFunction(context)) { context = context.call(this); }

      if(context === true) {
        return fn(this);
      } else if(context === false || context == null) {
        return inverse(this);
      } else if (isArray(context)) {
        if(context.length > 0) {
          return instance.helpers.each(context, options);
        } else {
          return inverse(this);
        }
      } else {
        return fn(context);
      }
    });

    instance.registerHelper('each', function(context, options) {
      var fn = options.fn, inverse = options.inverse;
      var i = 0, ret = "", data;

      if (isFunction(context)) { context = context.call(this); }

      if (options.data) {
        data = createFrame(options.data);
      }

      if(context && typeof context === 'object') {
        if (isArray(context)) {
          for(var j = context.length; i<j; i++) {
            if (data) {
              data.index = i;
              data.first = (i === 0);
              data.last  = (i === (context.length-1));
            }
            ret = ret + fn(context[i], { data: data });
          }
        } else {
          for(var key in context) {
            if(context.hasOwnProperty(key)) {
              if(data) {
                data.key = key;
                data.index = i;
                data.first = (i === 0);
              }
              ret = ret + fn(context[key], {data: data});
              i++;
            }
          }
        }
      }

      if(i === 0){
        ret = inverse(this);
      }

      return ret;
    });

    instance.registerHelper('if', function(conditional, options) {
      if (isFunction(conditional)) { conditional = conditional.call(this); }

      // Default behavior is to render the positive path if the value is truthy and not empty.
      // The `includeZero` option may be set to treat the condtional as purely not empty based on the
      // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
      if ((!options.hash.includeZero && !conditional) || Utils.isEmpty(conditional)) {
        return options.inverse(this);
      } else {
        return options.fn(this);
      }
    });

    instance.registerHelper('unless', function(conditional, options) {
      return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash});
    });

    instance.registerHelper('with', function(context, options) {
      if (isFunction(context)) { context = context.call(this); }

      if (!Utils.isEmpty(context)) return options.fn(context);
    });

    instance.registerHelper('log', function(context, options) {
      var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
      instance.log(level, context);
    });
  }

  var logger = {
    methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },

    // State enum
    DEBUG: 0,
    INFO: 1,
    WARN: 2,
    ERROR: 3,
    level: 3,

    // can be overridden in the host environment
    log: function(level, obj) {
      if (logger.level <= level) {
        var method = logger.methodMap[level];
        if (typeof console !== 'undefined' && console[method]) {
          console[method].call(console, obj);
        }
      }
    }
  };
  __exports__.logger = logger;
  function log(level, obj) { logger.log(level, obj); }

  __exports__.log = log;var createFrame = function(object) {
    var obj = {};
    Utils.extend(obj, object);
    return obj;
  };
  __exports__.createFrame = createFrame;
  return __exports__;
})(__module2__, __module4__);

// handlebars/runtime.js
var __module5__ = (function(__dependency1__, __dependency2__, __dependency3__) {
  "use strict";
  var __exports__ = {};
  var Utils = __dependency1__;
  var Exception = __dependency2__;
  var COMPILER_REVISION = __dependency3__.COMPILER_REVISION;
  var REVISION_CHANGES = __dependency3__.REVISION_CHANGES;

  function checkRevision(compilerInfo) {
    var compilerRevision = compilerInfo && compilerInfo[0] || 1,
        currentRevision = COMPILER_REVISION;

    if (compilerRevision !== currentRevision) {
      if (compilerRevision < currentRevision) {
        var runtimeVersions = REVISION_CHANGES[currentRevision],
            compilerVersions = REVISION_CHANGES[compilerRevision];
        throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+
              "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").");
      } else {
        // Use the embedded version info since the runtime doesn't know about this revision yet
        throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+
              "Please update your runtime to a newer version ("+compilerInfo[1]+").");
      }
    }
  }

  __exports__.checkRevision = checkRevision;// TODO: Remove this line and break up compilePartial

  function template(templateSpec, env) {
    if (!env) {
      throw new Exception("No environment passed to template");
    }

    // Note: Using env.VM references rather than local var references throughout this section to allow
    // for external users to override these as psuedo-supported APIs.
    var invokePartialWrapper = function(partial, name, context, helpers, partials, data) {
      var result = env.VM.invokePartial.apply(this, arguments);
      if (result != null) { return result; }

      if (env.compile) {
        var options = { helpers: helpers, partials: partials, data: data };
        partials[name] = env.compile(partial, { data: data !== undefined }, env);
        return partials[name](context, options);
      } else {
        throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
      }
    };

    // Just add water
    var container = {
      escapeExpression: Utils.escapeExpression,
      invokePartial: invokePartialWrapper,
      programs: [],
      program: function(i, fn, data) {
        var programWrapper = this.programs[i];
        if(data) {
          programWrapper = program(i, fn, data);
        } else if (!programWrapper) {
          programWrapper = this.programs[i] = program(i, fn);
        }
        return programWrapper;
      },
      merge: function(param, common) {
        var ret = param || common;

        if (param && common && (param !== common)) {
          ret = {};
          Utils.extend(ret, common);
          Utils.extend(ret, param);
        }
        return ret;
      },
      programWithDepth: env.VM.programWithDepth,
      noop: env.VM.noop,
      compilerInfo: null
    };

    return function(context, options) {
      options = options || {};
      var namespace = options.partial ? options : env,
          helpers,
          partials;

      if (!options.partial) {
        helpers = options.helpers;
        partials = options.partials;
      }
      var result = templateSpec.call(
            container,
            namespace, context,
            helpers,
            partials,
            options.data);

      if (!options.partial) {
        env.VM.checkRevision(container.compilerInfo);
      }

      return result;
    };
  }

  __exports__.template = template;function programWithDepth(i, fn, data /*, $depth */) {
    var args = Array.prototype.slice.call(arguments, 3);

    var prog = function(context, options) {
      options = options || {};

      return fn.apply(this, [context, options.data || data].concat(args));
    };
    prog.program = i;
    prog.depth = args.length;
    return prog;
  }

  __exports__.programWithDepth = programWithDepth;function program(i, fn, data) {
    var prog = function(context, options) {
      options = options || {};

      return fn(context, options.data || data);
    };
    prog.program = i;
    prog.depth = 0;
    return prog;
  }

  __exports__.program = program;function invokePartial(partial, name, context, helpers, partials, data) {
    var options = { partial: true, helpers: helpers, partials: partials, data: data };

    if(partial === undefined) {
      throw new Exception("The partial " + name + " could not be found");
    } else if(partial instanceof Function) {
      return partial(context, options);
    }
  }

  __exports__.invokePartial = invokePartial;function noop() { return ""; }

  __exports__.noop = noop;
  return __exports__;
})(__module2__, __module4__, __module1__);

// handlebars.runtime.js
var __module0__ = (function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__) {
  "use strict";
  var __exports__;
  /*globals Handlebars: true */
  var base = __dependency1__;

  // Each of these augment the Handlebars object. No need to setup here.
  // (This is done to easily share code between commonjs and browse envs)
  var SafeString = __dependency2__;
  var Exception = __dependency3__;
  var Utils = __dependency4__;
  var runtime = __dependency5__;

  // For compatibility and usage outside of module systems, make the Handlebars object a namespace
  var create = function() {
    var hb = new base.HandlebarsEnvironment();

    Utils.extend(hb, base);
    hb.SafeString = SafeString;
    hb.Exception = Exception;
    hb.Utils = Utils;

    hb.VM = runtime;
    hb.template = function(spec) {
      return runtime.template(spec, hb);
    };

    return hb;
  };

  var Handlebars = create();
  Handlebars.create = create;

  __exports__ = Handlebars;
  return __exports__;
})(__module1__, __module3__, __module4__, __module2__, __module5__);

  return __module0__;
})();

(function() {
var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
templates['Address'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Address Template\r\n
\r\n
\r\n            <input type=\"text\" id=\"addressTemplate-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"addressTemplate\" value=\"";
  if (helper = helpers.addressTemplate) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.addressTemplate); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Array'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, options, functionType="function", escapeExpression=this.escapeExpression, self=this, blockHelperMissing=helpers.blockHelperMissing;

function program1(depth0,data) {

  var buffer = "", stack1, helper;
  buffer += "<option value=\"";
  if (helper = helpers._id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0._id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">";
  if (helper = helpers.name) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.name); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "</option>";
  return buffer;
  }

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Object Name\r\n
\r\n
\r\n            <select id=\"objectContract-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"objectContract\" class=\"objectContract\">\r\n                <option value=\"\" class=\"title-option\">No Object selected</option>\r\n                ";
  options={hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data}
  if (helper = helpers.contracts) { stack1 = helper.call(depth0, options); }
  else { helper = (depth0 && depth0.contracts); stack1 = typeof helper === functionType ? helper.call(depth0, options) : helper; }
  if (!helpers.contracts) { stack1 = blockHelperMissing.call(depth0, stack1, {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data}); }
  if(stack1 || stack1 === 0) { buffer += stack1; }
  buffer += "\r\n            </select>\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Minimum number of elements\r\n
\r\n
\r\n            <input type=\"text\" id=\"min-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"min\" value=\"";
  if (helper = helpers.min) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.min); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Maximum number of elements\r\n
\r\n
\r\n            <input type=\"text\" id=\"max-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"max\" value=\"";
  if (helper = helpers.max) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.max); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Bank'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Currency'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Minimum value\r\n
\r\n
\r\n            <input type=\"text\" id=\"min-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"min\" value=\"";
  if (helper = helpers.min) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.min); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Maximum value\r\n
\r\n
\r\n            <input type=\"text\" id=\"max-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"max\" value=\"";
  if (helper = helpers.max) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.max); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Currency Codes\r\n
\r\n
\r\n            <textarea id=\"currencyCode-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"currencyCode\">";
  if (helper = helpers.currencyCodeList) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.currencyCodeList); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "</textarea>\r\n
\r\n
\r\n
\r\n
\r\n            Decimal Places\r\n
\r\n
\r\n            <input type=\"text\" id=\"decimalPlaces-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"decimalPlaces\" value=\"";
  if (helper = helpers.decimalPlaces) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.decimalPlaces); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Decimal Separator\r\n
\r\n
\r\n            <input type=\"text\" id=\"decimalSeparator-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"decimalSeparator\" value=\"";
  if (helper = helpers.decimalSeparator) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.decimalSeparator); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Thousands Separator\r\n
\r\n
\r\n            <input type=\"text\" id=\"thousandsSeparator-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"thousandsSeparator\" value=\"";
  if (helper = helpers.thousandsSeparator) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.thousandsSeparator); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Date'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            All the dates are computed from today's date. The minimum and maximum values specify the number of days in the range. A positive value in the minimum and maximum fields will yield a date in the future. A negative value will yield a date in the past.
\r\n            For instance to generate dates in the last 30 days enter -30 in the minimum and -1 in the maximum fields.\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Minimum value (use a negative value for dates in the past)\r\n
\r\n
\r\n            <input type=\"text\" id=\"min-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"min\" value=\"";
  if (helper = helpers.min) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.min); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Maximum value\r\n
\r\n
\r\n            <input type=\"text\" id=\"max-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"max\" value=\"";
  if (helper = helpers.max) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.max); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Date Seed\r\n
\r\n
\r\n            <input type=\"text\" id=\"dateSeed-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"dateSeed\" value=\"";
  if (helper = helpers.dateSeed) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.dateSeed); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Date Format Visit this page for date format specification\r\n
\r\n
\r\n            <input type=\"text\" id=\"format-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"format\" value=\"";
  if (helper = helpers.format) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.format); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Guid'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Global Unique Identifier Prefix\r\n
\r\n
\r\n            <input type=\"text\" id=\"prefix-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"prefix\" value=\"";
  if (helper = helpers.prefix) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.prefix); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Integer'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Minimum value\r\n
\r\n
\r\n            <input type=\"text\" id=\"min-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"min\" value=\"";
  if (helper = helpers.min) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.min); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Maximum value\r\n
\r\n
\r\n            <input type=\"text\" id=\"max-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"max\" value=\"";
  if (helper = helpers.max) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.max); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Ipsum'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Phrase minimum words\r\n
\r\n
\r\n            <input type=\"text\" id=\"phraseMin-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"phraseMin\" value=\"";
  if (helper = helpers.phraseMin) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.phraseMin); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Phrase maximum words\r\n
\r\n
\r\n            <input type=\"text\" id=\"phraseMax-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"phraseMax\" value=\"";
  if (helper = helpers.phraseMax) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.phraseMax); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Minimum words in a paragraph\r\n
\r\n
\r\n            <input type=\"text\" id=\"wordMin-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"wordMin\" value=\"";
  if (helper = helpers.wordMin) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.wordMin); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Maximum words in a paragraph\r\n
\r\n
\r\n            <input type=\"text\" id=\"wordMax-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"wordMax\" value=\"";
  if (helper = helpers.wordMax) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.wordMax); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n
\r\n            Number of paragraphs\r\n
\r\n
\r\n            <input type=\"text\" id=\"paragraphNum-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"paragraphNum\" value=\"";
  if (helper = helpers.paragraphNum) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.paragraphNum); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Markup'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Markup template name\r\n
\r\n
\r\n            <input type=\"text\" id=\"template-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"template\" value=\"";
  if (helper = helpers.template) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.template); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Enter markup here (it takes precedence over markup template)\r\n
\r\n
\r\n            <textarea id=\"markup-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"markup\">";
  if (helper = helpers.markup) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.markup); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "</textarea>\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Markup Data (JSON)\r\n
\r\n
\r\n            <textarea id=\"data-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"data\">";
  if (helper = helpers.data) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.data); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "</textarea>\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Name'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            First / Last order\r\n
\r\n
\r\n            <select id=\"order-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"order\" class=\"order\">\r\n                <option value=\"fl\">First Last</option>\r\n                <option value=\"lf\">Last, First</option>\r\n            </select>\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Number'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Minimum value\r\n
\r\n
\r\n            <input type=\"text\" id=\"min-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"min\" value=\"";
  if (helper = helpers.min) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.min); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Maximum value\r\n
\r\n
\r\n            <input type=\"text\" id=\"max-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"max\" value=\"";
  if (helper = helpers.max) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.max); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Object'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, options, functionType="function", escapeExpression=this.escapeExpression, self=this, blockHelperMissing=helpers.blockHelperMissing;

function program1(depth0,data) {

  var buffer = "", stack1, helper;
  buffer += "<option value=\"";
  if (helper = helpers._id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0._id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">";
  if (helper = helpers.name) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.name); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "</option>";
  return buffer;
  }

  buffer += "
\r\n
\r\n
\r\n            The data generator can generate columns with arbitrary objects values. The generator uses exactly the same syntax for inner objects as for the main object. To include inner objects, define and save the object first as a global object, then refer to it by name in the objectName field.
\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Object Name\r\n
\r\n
\r\n            <select id=\"objectContract-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"objectContract\" class=\"objectContract\">\r\n                <option value=\"\" class=\"title-option\">No Object selected</option>\r\n                ";
  options={hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data}
  if (helper = helpers.contracts) { stack1 = helper.call(depth0, options); }
  else { helper = (depth0 && depth0.contracts); stack1 = typeof helper === functionType ? helper.call(depth0, options) : helper; }
  if (!helpers.contracts) { stack1 = blockHelperMissing.call(depth0, stack1, {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data}); }
  if(stack1 || stack1 === 0) { buffer += stack1; }
  buffer += "\r\n            </select>\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['OneOfList'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Enter a list name\r\n
\r\n
\r\n            <input type=\"text\" id=\"listName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"listName\" value=\"";
  if (helper = helpers.listName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.listName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            \r\n                Enter a list of values separated by commas.
\r\n                This list takes precedence over the list named above\r\n            \r\n
\r\n
\r\n            <textarea id=\"list-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"list\" ";
  if (helper = helpers.readOnly) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.readOnly); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + ">";
  if (helper = helpers.listFormatted) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.listFormatted); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "</textarea>\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Mode\r\n
\r\n
\r\n            <select id=\"mode-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"mode\" class=\"mode\">\r\n                <option value=\"sequence\">Sequence</option>\r\n                <option value=\"shuffle\">Shuffle</option>\r\n            </select>\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Index first value\r\n
\r\n
\r\n            <input type=\"text\" id=\"index-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"index\" value=\"";
  if (helper = helpers.index) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.index); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['Pattern'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            \r\n                Pattern
\r\n                Use:
\r\n                "a" for lower case letter
\r\n                "A" for upper case letter
\r\n                "@" for either upper or lower case letter
\r\n                "#" for a digit
\r\n                "\\" to make the next character literal
\r\n                All other sequences are used as is
\r\n            \r\n
\r\n
\r\n            <input type=\"text\" id=\"pattern-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"pattern\" value=\"";
  if (helper = helpers.pattern) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.pattern); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['String'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression;

  buffer += "
\r\n
\r\n
\r\n            Attribute Name\r\n
\r\n
\r\n            <input type=\"text\" id=\"attrName-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"attributeName\" value=\"";
  if (helper = helpers.attributeName) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.attributeName); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Minimum length\r\n
\r\n
\r\n            <input type=\"text\" id=\"min-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"min\" value=\"";
  if (helper = helpers.min) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.min); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n\r\n
\r\n
\r\n            Maximum length\r\n
\r\n
\r\n            <input type=\"text\" id=\"max-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"max\" value=\"";
  if (helper = helpers.max) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.max); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n
\r\n
\r\n
\r\n";
  return buffer;
  });

templates['dataType'] = template(function (Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
helpers = this.merge(helpers, Handlebars.helpers); data = data || {};
  var buffer = "", stack1, helper, functionType="function", escapeExpression=this.escapeExpression, self=this;

function program1(depth0,data) {

  var buffer = "";
  buffer += "\r\n            <option value="
    + escapeExpression((typeof depth0 === functionType ? depth0.apply(depth0) : depth0))
    + ">"
    + escapeExpression((typeof depth0 === functionType ? depth0.apply(depth0) : depth0))
    + "</option>\r\n            ";
  return buffer;
  }

  buffer += "
\r\n
\r\n        Data Type\r\n
\r\n
\r\n        <select id=\"dataType-";
  if (helper = helpers.id) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.id); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\" name=\"dataType\" class=\"dataType\" value=\"";
  if (helper = helpers.dataType) { stack1 = helper.call(depth0, {hash:{},data:data}); }
  else { helper = (depth0 && depth0.dataType); stack1 = typeof helper === functionType ? helper.call(depth0, {hash:{},data:data}) : helper; }
  buffer += escapeExpression(stack1)
    + "\">\r\n            ";
  stack1 = helpers.each.call(depth0, (depth0 && depth0.validTypes), {hash:{},inverse:self.noop,fn:self.program(1, program1, data),data:data});
  if(stack1 || stack1 === 0) { buffer += stack1; }
  buffer += "\r\n        </select>\r\n
\r\n
\r\n";
  return buffer;
  });
}());
YUI.add('util-json-pretty-print', function (Y) {
    "use strict";
    Y.namespace('Util').JsonPrettyPrint = function (jsObject, indentLength, outputTo) {
        var indentString,
            newLine,
            newLineJoin,
            TOSTRING,
            TYPES,
            valueType,
            repeatString,
            prettyObject,
            prettyObjectJSON,
            prettyObjectPrint,
            prettyArray,
            pretty;

        TOSTRING = Object.prototype.toString;

        TYPES = {
            'undefined'        : 'undefined',
            'number'           : 'number',
            'boolean'          : 'boolean',
            'string'           : 'string',
            '[object Function]': 'function',
            '[object RegExp]'  : 'regexp',
            '[object Array]'   : 'array',
            '[object Date]'    : 'date',
            '[object Error]'   : 'error'
        };

        valueType = function (o) {
            var type = TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? 'object' : 'null');
            return type;
        };

        repeatString = function (src, length) {
            var dst = '',
                index;
            for (index = 0; index < length; index += 1) {
                dst += src;
            }

            return dst;
        };

        prettyObjectJSON = function (object, indent) {
            var value = [],
                property;

            indent += indentString;
            for (property in object) {
                if (object.hasOwnProperty(property)) {
                    value.push(indent + '"' + property + '": ' + pretty(object[property], indent));
                }
            }

            return value.join(newLineJoin) + newLine;
        };

        prettyObjectPrint = function (object, indent) {
            var value = [],
                property;

            indent += indentString;
            for (property in object) {
                if (object.hasOwnProperty(property)) {
                    value.push(indent + property + ': ' + pretty(object[property], indent));
                }
            }

            return value.join(newLineJoin) + newLine;
        };

        prettyArray = function (array, indent) {
            var index,
                length = array.length,
                value = [];

            indent += indentString;
            for (index = 0; index < length; index += 1) {
                value.push(pretty(array[index], indent, indent));
            }

            return value.join(newLineJoin) + newLine;
        };

        pretty = function (element, indent, fromArray) {
            var type;

            if (element) {
                type = valueType(element);
                fromArray = fromArray || '';

                switch (type) {
                case 'array':
                    return fromArray + '[' + newLine + prettyArray(element, indent) + indent + ']';

                case 'boolean':
                    return fromArray + (element ? 'true' : 'false');

                case 'date':
                    return fromArray + '"' + element.toString() + '"';

                case 'number':
                    return fromArray + element;

                case 'object':
                    return fromArray + '{' + newLine + prettyObject(element, indent) + indent + '}';

                case 'string':
                    return fromArray + '"' + element + '"';

                default:
                    return fromArray + element.toString();
                }
            }
        };

        if (jsObject) {
            if (indentLength === undefined) {
                indentLength = 4;
            }

            outputTo = (outputTo || 'print').toLowerCase();
            indentString = repeatString(outputTo === 'html' ? ' ' : ' ', indentLength);
            prettyObject = outputTo === 'json' ? prettyObjectJSON : prettyObjectPrint;
            newLine = outputTo === 'html' ? '
' : '\n';
            newLineJoin = ',' + newLine;
            return pretty(jsObject, '') + newLine;
        }

        return 'Error: no Javascript object provided';
    };
}, '0.1');

YUI.add('util-messagebox', function (Y) {
    "use strict";

    var YL = Y.Lang,
        NAME = this.name,
        NAMESPACE = 'Util',
        CSS_PREFIX = 'messagebox',
        DOT_CSS_PREFIX = '.' + CSS_PREFIX,
        CSS_CLASS = {
            'waitMessage': [DOT_CSS_PREFIX, 'wait-message'].join('-'),
            'errorCause': [DOT_CSS_PREFIX, 'error-cause'].join('-'),
            'message': [DOT_CSS_PREFIX, 'message'].join('-')
        },
        panelMarkup = [
            '
',
            '

',
            '

',
            '

',
            '
'
        ].join(''),
        bodyMarkup = [
            '
',
            '

',
            '
',
            '
',
            '
',
            '

',
            '
',
            '
',
            '
{message}
',
            '
',
            '
'
        ].join(''),
        footerMarkup = [
            '
',
            '
',
            '
',
            '
',
            '
',
            '

',
            '
'
        ].join(''),
        inputMarkup = '
<input type="text" name="defaultTextInputControl" value=""/>
',
        waitMarkup = [
            '
',
            '
',
            '
',
            '
{message}
',
            '
'
        ].join(''),
        buttonLibrary = {
            'close': {
                'name': 'close',
                'value': 'Close',
                'section': Y.WidgetStdMod.FOOTER,
                'action': 'closeWithButton'
            },
            'yes': {
                'name': 'yes',
                'value': 'Yes',
                'section': Y.WidgetStdMod.FOOTER,
                'action': 'closeWithButton'
            },
            'no': {
                'name': 'no',
                'value': 'No',
                'section': Y.WidgetStdMod.FOOTER,
                'action': 'closeWithButton'
            },
            'ok': {
                'name': 'ok',
                'value': 'OK',
                'section': Y.WidgetStdMod.FOOTER,
                'action': 'closeWithButton'
            },
            'cancel': {
                'name': 'cancel',
                'value': 'Cancel',
                'section': Y.WidgetStdMod.FOOTER,
                'action': 'closeWithButton'
            }
        },
        MessageBox,
        messageBoxInstance,
        getMessageBox,
        waitMessage,
        getWaitMessage;

    MessageBox = Y.Base.create(NAME, Y.Panel, [], {
        'closeWithButton': function (event) {
            var widget = this,
                target = event.target,
                buttonName = target.getData('name'),
                contentBox = widget.get('contentBox'),
                inputNodes = contentBox.all('input'),
                valueList = {};

            inputNodes.each(function (node) {
                var name = node.get('name'),
                    value = node.get('value');

                if (!name) {
                    name = node.get('id');
                }

                if (valueList[name]) {
                    if (!YL.isArray(valueList[name])) {
                        valueList[name] = [valueList[name]];
                    }
                    valueList[name].push(value);
                } else {
                    valueList[name] = value;
                }
            });

            event.stopImmediatePropagation();
            event.preventDefault();

            widget.fire('close', {
                'buttonName': buttonName,
                'valueList': valueList
            });
            widget.close();
        },

        'renderUI': function () {
            var widget = this,
                contentBox = widget.get('contentBox'),
                header = contentBox.one('.yui3-widget-hd'),
                footer = contentBox.one('.yui3-widget-ft'),
                buttons;

            if (header && !widget.get('headerContent')) {
                header.addClass('hiddenNode');
            }

            buttons = widget.get('buttons');
            if (!(buttons && buttons.footer && buttons.footer.length)) {
                footer.addClass('hiddenNode');
            }
        },

        'bindUI': function () {
            var widget = this;
            widget.publish('close', {
                'emitFacade': true,
                'preventable': true,
                'preventedFn': widget.preventClose,
                'defaultFn': widget.close
            });
        },

        'preventClose': function (event) {
            var contentBox = this.get('contentBox'),
                causeNode;
            if (event.cause) {
                causeNode = contentBox.one(CSS_CLASS.errorCause);
                causeNode.removeClass('hiddenNode');
                causeNode.set('innerHTML', event.cause);
            }
        },

        'syncUI': function () {
            var widget = this,
                contentBox = widget.get('contentBox'),
                footer = contentBox.one('.yui3-widget-ft'),
                buttonWrapper,
                footerContent;

            if (footer) {
                buttonWrapper = footer.one('yui3-widget-button-wrapper');
                if (buttonWrapper) {
                    footerContent = Y.Node.create(YL.sub(footerMarkup, {'CSS_PREFIX': CSS_PREFIX}));
                    footerContent.one(CSS_CLASS.message).append(buttonWrapper);
                    widget.set('footerContent', footerContent);
                }
            }
        },

        '_removeNode': function (cssSelector) {
            var node = Y.one(cssSelector);

            if (node && node.getDOMNode()) {
                node.remove(true);
            }
        },

        'close': function () {
            var widget = this;

            widget.hide();
            widget.destroy();
        }
    }, {
        'ATTRS': {
            'buttons': {
                'value': null,
                'setter': '_setButtons'
            },
            'centered': {
                'value': true
            },
            'visible': {
                'value': true
            },
            'modal': {
                'value': true
            },
            'srcNode': {
                'setter': function (srcNode) {
                    if (!srcNode) {
                        srcNode = Y.Node.create(panelMarkup);
                    }
                    return srcNode;
                }
            },
            'render': {
                'value': 'body'
            }
        },
        'CSS_PREFIX': CSS_PREFIX
    });

    messageBoxInstance = null;
    getMessageBox = function (message, title, type, buttons, hasInput) {
        var bodyContent = Y.Node.create(YL.sub(bodyMarkup, {'type': type, 'message': message, 'CSS_PREFIX': CSS_PREFIX})),
            inputNode;
        if (!YL.isArray(buttons)) {
            buttons = [buttons];
        }

        if (hasInput) {
            if (type === 'input') {
                inputNode = Y.Node.create(YL.sub(inputMarkup, {'CSS_PREFIX': CSS_PREFIX}));
                bodyContent.one('.pure-g').append(inputNode);
            }
        }

        messageBoxInstance = new MessageBox({
            'bodyContent': bodyContent,
            'headerContent': title,
            'buttons': buttons,
            'zIndex': 100,
            'modal': true
        });
        messageBoxInstance.render();
        return messageBoxInstance;
    };

    waitMessage = null;
    getWaitMessage = function (message, title) {
        if (waitMessage) {
            if (title) {
                waitMessage.set('headerContent', title);
            }

            if (message) {
                var contentBox = waitMessage.get('contentBox');
                contentBox.one(CSS_CLASS.waitMessage).set('innerHTML', message);
            }
            return waitMessage;
        }

        if (waitMessage) {
            waitMessage.destroy();
        }

        waitMessage = new MessageBox({
            'bodyContent': YL.sub(waitMarkup, {'message': message, 'CSS_PREFIX': CSS_PREFIX}),
            'headerContent': title,
            'buttons': [],
            'zIndex': 100,
            'modal': true
        });
        waitMessage.render();
        return waitMessage;
    };

    getWaitMessage.prototype.close = function () {
        if (waitMessage) {
            waitMessage.close();
        }

        waitMessage = null;
    };

    Y.namespace(NAMESPACE).MessageBox = {
        'getInstance': function (config) {
            return new MessageBox(config);
        },
        'info': function (message, title) {
            title = title || 'Info';
            return getMessageBox(message, title, 'info', buttonLibrary.close);
        },
        'input': function (message, title) {
            title = title || 'Input';
            return getMessageBox(message, title, 'input', [buttonLibrary.ok, buttonLibrary.cancel], true);
        },
        'form': function (formMarkup, title) {
            title = title || 'Form';
            return getMessageBox(formMarkup, title, 'form', [buttonLibrary.ok, buttonLibrary.cancel], true);
        },
        'confirm': function (message, title) {
            title = title || 'Confirm';
            return getMessageBox(message, title, 'confirm', [buttonLibrary.yes, buttonLibrary.no]);
        },
        'warning': function (message, title) {
            title = title || 'Warning';
            return getMessageBox(message, title, 'warning', buttonLibrary.close);
        },
        'alert': function (message, title) {
            title = title || 'Alert';
            return getMessageBox(message, title, 'alert', buttonLibrary.close);
        },
        'verification': function (message, title) {
            title = title || 'Verification';
            return getMessageBox(message, title, 'verification', [buttonLibrary.yes, buttonLibrary.no]);
        }
    };

    Y.namespace(NAMESPACE).Wait = getWaitMessage;
}, '0.1', {
    'requires': ['panel']
});

/*jslint nomen:true*/
YUI.add('generator-metadata', function (Y, NAME) {
    "use strict";
    var YA,
        YL,
        YUMsg,
        CSS_PREFIX,
        ATTRS,
        OPTION_TEMPLATE,
        DATATABLE_CAPTION_TEMPLATE = 'Attributes for {name}';

    YA = Y.Array;
    YL = Y.Lang;
    YUMsg = Y.Util.MessageBox;

    CSS_PREFIX = NAME;
    ATTRS = {
        'metadata': {},
        'name': {},
        '_id': {},
        'dataChanged': {
            'value': false
        },
        'contracts': {}
    };

    OPTION_TEMPLATE = '<option value="{_id}">{name}</option>';

    Y.namespace('Generator').Metadata = Y.Base.create(NAME, Y.Widget, [], {
        'renderUI': function () {
            var self = this;

            self.renderDataTable();
            self.renderButtons();
            self.selectContract = Y.one('#mongoContracts');
            self.propertiesEditor = new Y.Generator.PropertiesEditor({}).render(Y.one('#properties-container'));
        },

        'bindUI': function () {
            var self = this;

            self.dataTable.delegate('click', self.onSelected, '.yui3-datatable-data', self);
            self.addAttribute.on('click', self.onAddAttribute, self);
            self.removeAttribute.on('click', self.onRemoveAttribute, self);
            self.propertiesEditor.on('addOrUpdate', self.onAddOrUpdate, self);
            self.propertiesEditor.on('cancel', self.finishEdit, self);
            self.generateData.on('click', self.onGenerateData, self);
            self.selectContract.on('change', self.handleContractChange, self);
            self.save.on('click', self.handleSave, self);
            self.saveAs.on('click', self.handleSaveAs, self);
            self.delete.on('click', self.handleDelete, self);
        },

        'syncUI': function () {
            var self = this,
                contractList = self.get('contracts');

            YA.some(contractList, function (contract) {
                if (contract.metadata) {
                    self.syncDataUI(contract);
                    return true;
                }
            });
        },

        'renderDataTable': function () {
            var self = this;
            self.dataTable = new Y.DataTable({
                'columns': [
                    {
                        'key': 'selected',
                        'label': ' ',
                        'allowHTML': true,
                        'formatter': function (rowObject) {
                            return Y.Lang.sub('<input type="radio" name="selectedRow" title="Select row for attribute {attributeName}" />', rowObject.data);
                        }
                    },
                    {
                        'key': 'attributeName',
                        'label': 'Attribute',
                        'sortable': true
                    },
                    {
                        'key': 'dataType',
                        'label': 'Type',
                        'sortable': true
                    },
                    {
                        'key': 'objectName',
                        'label': ' '
                    }
                ],
                'render': self.get('contentBox')
            });
        },

        'renderButtons': function () {
            var self = this;

            self.addAttribute = new Y.Button({
                'srcNode': Y.one('#addAttribute'),
                'render': true
            });
            self.removeAttribute = new Y.Button({
                'srcNode': Y.one('#removeAttribute'),
                'render': true,
                'disabled': true
            });
            self.generateData = new Y.Button({
                'srcNode': Y.one('#generate-data'),
                'render': true
            });
            self.save = new Y.Button({
                'srcNode': Y.one('#save'),
                'render': true,
                'disabled': true
            });
            self.saveAs = new Y.Button({
                'srcNode': Y.one('#saveAs'),
                'render': true
            });
            self.delete = new Y.Button({
                'srcNode': Y.one('#delete'),
                'render': true
            });
        },

        'syncDataUI': function (data) {
            var self = this;

            data = data || {
                '_id': null,
                'name': '',
                'metadata': null
            };

            self.set('_id', data._id);
            self.set('name', data.name);
            self.set('metadata', data.metadata);
            self.set('dataChanged', false);

            self.dataTable.set('data', data.metadata);
            self.dataTable.set('caption', YL.sub(DATATABLE_CAPTION_TEMPLATE, data));

            self.selectContract.all('option').each(function (optionNode) {
                optionNode.set('selected', optionNode.get('value') === data._id);
            });

            Y.one('.sampleData-container').setHTML('');

            if (self.propertiesEditor) {
                self.propertiesEditor.hide();
            }

            Y.one('#fileOperations').toggleClass('hidden-node', !data.metadata);
            Y.one('#generateSampleRecord').toggleClass('hidden-node', !data.metadata);

            self.addAttribute.set('disabled', false);
            self.removeAttribute.set('disabled', true);
            self.delete.set('disabled', !data.name);

            Y.one('.sampleData-container').addClass('hidden-node');
        },

        'ioMessage': function (message) {
            var ioMessageContainer = Y.one('div.io-message-container');

            ioMessageContainer.set('text', message);
            ioMessageContainer.removeClass('hidden-node');
            Y.later(3000, this, function () {
                ioMessageContainer.addClass('hidden-node');
            });
        },

        'handleClear': function () {
            var self = this,
                onOKToLose;

            onOKToLose = function (event) {
                if (event && event.buttonName === 'yes') {
                    self.syncDataUI();
                }
            };

            if (self.get('dataChanged')) {
                YUMsg.confirm('There are changes to this contract metadata. Are you sure you want to lose them?').on('close', onOKToLose, self);
            } else {
                self.syncDataUI();
            }
        },

        'getMetadata': function () {
            var self = this,
                scrub,
                meta;

            scrub = function (metadata) {
                YA.each(metadata.metadata, scrub);

                delete metadata.rowNum;
                delete metadata.selected;
                delete metadata.initialized;
                delete metadata.destroyed;
                delete metadata.id;
            };

            meta = self.get('metadata');
            YA.each(meta, scrub);
            return meta;
        },

        'handleSaveAs': function () {
            var self = this,
                handleResult;

            handleResult = Y.bind(function (result) {
                var contractList,
                    contracts,
                    selectContract;

                if (!result) {
                    return;
                }

                contracts = self.get('contracts');
                selectContract = self.selectContract;
                contractList = result.contractList;
                YA.each(contractList, function (contract) {
                    var option = selectContract.one('option[value="' + contract._id + '"]');

                    if (!option) {
                        selectContract.append(YL.sub(OPTION_TEMPLATE, contract));
                        contracts.push(contract);
                        self.set('contracts', contracts);
                        self.ioMessage('Contract ' + contract.name + ' was saved in the database');
                    }
                    self.loadContract(contract._id);
                }, self);
            }, self);

            YUMsg.input('Enter Object Name').on('close', function (event) {
                var valueList,
                    name;

                if (event.buttonName === 'ok') {
                    valueList = event.valueList;
                    if (valueList) {
                        name = valueList.defaultTextInputControl;
                        if (name) {
                            Y.Generator.RestIO({
                                'action': 'Create',
                                'data': {
                                    'name': name,
                                    'metadata': Y.JSON.stringify(self.getMetadata()),
                                    'collection': 'metadata'
                                }
                            }, handleResult);
                        }
                    }
                }
            }, self);
        },

        'handleSave': function () {
            var self = this,
                handleResult,
                id = self.get('_id');

            handleResult = Y.bind(function (result) {
                if (result) {
                    self.set('dataChanged', false);
                    self.save.set('disabled', true);
                    self.ioMessage('Contract ' + self.get('name') + ' was saved in the database');
                }
            }, self);

            if (id) {

                Y.Generator.RestIO({
                    'action': 'Update',
                    'data': {
                        '_id': id,
                        'name': self.get('name'),
                        'metadata': Y.JSON.stringify(self.getMetadata()),
                        'collection': 'metadata'
                    }
                }, handleResult);
            }
        },

        'handleDelete': function () {
            var self = this,
                name = self.get('name'),
                id = self.get('_id'),
                handleResult;

            handleResult = Y.bind(function (data) {
                var contracts = self.get('contracts'),
                    selectContract = self.selectContract;

                if (data.numberOfRemovedDocs) {
                    YA.some(contracts, function (contract, index, array) {
                        if (contract._id === id) {
                            array.splice(index, 1);
                            return true;
                        }
                    });
                    selectContract.one('option[value="' + id + '"]').remove();
                    self.syncDataUI();
                    self.ioMessage('Contract ' + name + ' was removed from the database');
                }
            }, self);

            if (id) {
                YUMsg.confirm('Do you want to delete contract ' + name).on('close', function (event) {
                    if (event && event.buttonName === 'yes') {
                        Y.Generator.RestIO({
                            'action': 'Delete',
                            'data': {
                                'collection': 'metadata',
                                'id': id
                            }
                        }, handleResult);
                    }
                }, self);
            }
        },

        'loadContract': function (contractID) {
            var self = this,
                handleResult;

            handleResult = Y.bind(function (data) {
                if (!data) {
                    return;
                }

                if (YL.isArray(data) && data.length > 0) {
                    data = data[0];
                }

                self.syncDataUI(data);
            }, self);

            Y.Generator.RestIO({
                'action': 'Read',
                'data': {
                    'collection': 'metadata',
                    'id': contractID
                }
            }, handleResult);
        },

        'handleContractChange': function (event) {
            var self = this,
                contractID = event.target.get('value');

            function onOKToLose(event) {
                if (event && event.buttonName === 'yes') {
                    self.loadContract(contractID);
                }
            }

            if (contractID === self.get('_id')) {
                return;
            }

            if (contractID === '--clear--') {
                self.handleClear();
            } else {
                if (self.get('dataChanged')) {
                    YUMsg.confirm('There are changes to this contract metadata. Are you sure you want to lose them?').on('close', onOKToLose, self);
                } else {
                    self.loadContract(contractID);
                }
            }
        },

        'getRowNum': function () {
            var rowNum = this.rowNum;

            if (!rowNum) {
                rowNum = 1;
            }

            this.rowNum = rowNum + 1;
            return rowNum;
        },

        'onAddAttribute': function () {
            var self = this;

            self.startEditor(Y.Generator.String.defaultMetadata());
            self.setAddToTableLabel('Add');
        },

        'onRemoveAttribute': function () {
            var self = this,
                table = self.dataTable,
                radioBtns = table.get('contentBox').all('.yui3-datatable-data input[type="radio"]'),
                record,
                remove;

            remove = function (event) {
                if (event.buttonName === 'yes') {
                    table.removeRow(record);
                    self.setMetadata();
                    self.finishEdit();
                }
            };

            radioBtns.some(function (button) {
                if (button.get('checked')) {
                    record = table.getRecord(button);

                    if (record) {
                        YUMsg.confirm('Do you want to delete attribute ' + record.get('attributeName') + '?').on('close', remove, self);
                        return true;
                    }
                }
            });
        },

        'setMetadata': function () {
            var self = this,
                metadata,
                hideFileControls,
                id = self.get('_id');

            metadata = [];
            self.dataTable.data.each(function (record) {
                var attributes = record.getAttrs();
                delete attributes.clientId;
                metadata.push(attributes);
            });

            self.set('metadata', metadata);

            hideFileControls = metadata.length === 0;
            Y.one('#fileOperations').toggleClass('hidden-node', hideFileControls);
            Y.one('#generateSampleRecord').toggleClass('hidden-node', hideFileControls);

            if (id) {
                self.save.set('disabled', false);
            }
            self.set('dataChanged', true);
        },

        'onGenerateData': function () {
            var self = this,
                numRecords = parseInt(Y.one('#num-records').get('value'), 10),
                generator,
                dataList;

            if (isNaN(numRecords) || numRecords === 0) {
                numRecords = 1;
            }

            generator = new Y.Generator.Object({
                'metadata': self.get('metadata')
            });
            dataList = generator.getValue(numRecords);

            Y.one('.sampleData-container').removeClass('hidden-node').setHTML(Y.Util.JsonPrettyPrint(dataList, 4, 'html'));
        },

        'onAddOrUpdate': function (event) {
            var self = this,
                metadata = event.metadata,
                table = self.dataTable;

            if (metadata.clientId) {
                table.modifyRow(metadata.clientId, metadata);
            } else {
                delete metadata.id;
                table.addRow(metadata);
            }
            self.setMetadata();
            self.finishEdit();
        },

        'finishEdit': function () {
            var self = this,
                table = self.dataTable,
                data = self.get('metadata'),
                newData = [];

            YA.each(data, function (item, index) {
                item.rowNum = index + 1;
                item.selected = false;
                newData.push(item);
            });
            table.set('data', newData);

            self.addAttribute.set('disabled', false);
            self.removeAttribute.set('disabled', true);
            self.propertiesEditor.hide();
        },

        'setAddToTableLabel': function (label) {
            Y.one('#add-to-table').setHTML(label);
        },

        'startEditor': function (metadata) {
            var self = this,
                contracts = self.get('contracts'),
                propertiesEditor;

            propertiesEditor = self.propertiesEditor;
            if (propertiesEditor) {
                propertiesEditor.set('metadata', metadata);
                propertiesEditor.set('contracts', contracts);
            } else {
                self.propertiesEditor = new Y.Generator.PropertiesEditor({
                    'metadata': metadata,
                    'contracts': contracts
                }).render(Y.one('.properties-container'));
            }
            self.addAttribute.set('disabled', true);
            propertiesEditor.show();
        },

        'onSelected': function (event) {
            var self = this,
                row = event.target.ancestor('tr'),
                record = self.dataTable.getRecord(event.target);

            if (record) {
                row.one('input[type="radio"]').set('checked', true);
                self.startEditor(record.getAttrs());
                self.setAddToTableLabel('Update');
                self.removeAttribute.set('disabled', false);
            }
        }
    }, {
        'ATTRS': ATTRS,
        'CSS_PREFIX' : CSS_PREFIX
    });
}, '0.1', {
    'requires' : [
        'base',
        'transition',
        'widget',
        'generator-properties-editor',
        'generator-object',
        'generator-rest-io',
        'datatable',
        'button',
        'util-messagebox',
        'json'
    ]
});

YUI.add('generator-properties-editor', function (Y) {
    "use strict";
    var YL,
        NAME,
        CSS_PREFIX,
        ATTRS;

    YL = Y.Lang;

    NAME = this.name;
    CSS_PREFIX = NAME;

    ATTRS = {
        'metadata': {
            'value': {},
            'setter': 'setMetadata'
        },
        'contracts': {
            'value': Y.ContractsBase
        }
    };

    Y.namespace('Generator').PropertiesEditor = Y.Base.create(NAME, Y.Widget, [], {
        'renderUI': function () {
            var node = Y.Node.create(Handlebars.templates.dataType({
                'validTypes': Y.Generator.Base.VALID_TYPES
            }));
            Y.one('#dataType-select').append(node);
        },

        'bindUI': function () {
            var self = this;

            self.addOrUpdate = self.publish('addOrUpdate', {
                'emitFacade': true
            });

            self.cancel = self.publish('cancel', {
                'emitFacade': true
            });

            Y.one('select.dataType').on('change', self.onDataTypeChange, self);
            Y.one('#generate-sample').on('click', self.generateSample, self);
            Y.one('#clear-sample').on('click', self.clearSample, self);
            Y.one('#add-to-table').on('click', self.onAddToTable, self);
            Y.one('#cancel').on('click', self.onCancel, self);
            self.after('metadataChange', self.syncUI, self);
        },

        'syncUI': function () {
            var self = this,
                syncMarkup,
                contentBox,
                metadata,
                dataType,
                generator,
                selectObject;

            syncMarkup = function (renderNode, metadata) {
                var setSelect,
                    setRadio,
                    setCheckbox,
                    markup;

                setSelect = function (selectNode) {
                    var name = selectNode.get('name'),
                        value = metadata[name];

                    if (value) {
                        selectNode.set('value', value);
                    }
                };

                setRadio = function (node) {
                    node.set('checked', node.get('value') === metadata[node.get('name')]);
                };

                setCheckbox = function (node) {
                    var value = metadata[node.get('name')];
                    node.set('checked', value.indexOf(node.get('value')) !== -1);
                };

                markup = Handlebars.templates[dataType](metadata);
                renderNode.setHTML(markup);
                Y.one('select.dataType').set('value', dataType);
                renderNode.all('select').each(setSelect);
                renderNode.all('input[type="radio"]').each(setRadio);
                renderNode.all('input[type="checkbox"]').each(setCheckbox);
            };

            metadata = self.get('metadata');
            dataType = metadata.dataType;
            if (metadata && dataType) {
                contentBox = self.get('contentBox');
                Y.one('.properties-editor h2').setHTML(dataType);
                generator = self.getGenerator(metadata);
                metadata = Y.mix(metadata, generator.getAttrs());
                if (dataType === 'Object' || dataType === 'Array') {
                    metadata = Y.mix({'contracts' : self.get('contracts')}, metadata);
                }

                syncMarkup(contentBox, metadata);

                selectObject = contentBox.one('select.objectContract');
                if (selectObject) {
                    self.objectNameChange = selectObject.on('change', self.handleObjectNameChange, self);
                }
                self.clearSample();
            }
        },

        'handleObjectNameChange': function (event) {
            var self = this,
                target = event.target,
                id,
                handleResult;

            handleResult = Y.bind(function (data) {
                if (!data) {
                    return;
                }

                if (Y.Lang.isArray(data) && data.length > 0) {
                    data = data[0];
                }
                self.generator.set('metadata', data.metadata);
            }, self);

            id = target.get('value');
            if (id) {
                Y.Generator.RestIO({
                    'action': 'Read',
                    'data': {
                        'collection': 'metadata',
                        'id': id
                    }
                }, handleResult);
                target.one('option[value="' + id + '"]').set('selected', true);
            }
        },

        'setSampleValue': function (value) {
            Y.one('#generated-value').setHTML(value).removeClass('hidden-node');
        },

        'generateSample': function () {
            var self = this,
                generator = self.generator,
                value;

            if (generator) {
                self.saveMetadataFromForm();
                value = generator.getValue();
                self.setSampleValue(Y.Util.JsonPrettyPrint(value, 4, 'html'));
            }
        },

        'clearSample': function () {
            Y.one('#generated-value').addClass('hidden-node');
        },

        'onAddToTable': function () {
            var self = this,
                generator,
                error;

            self.saveMetadataFromForm();
            generator = self.generator;
            error = generator.isValid();
            if (error && error.length) {
                Y.Util.MessageBox.alert(error.join('
'));
            } else {
                self.addOrUpdate.fire({'metadata': generator.getAttrs()});
                self.hide();
            }
        },

        'onCancel': function () {
            var self = this;
            self.hide();
            self.cancel.fire();
        },

        'show': function () {
            Y.one('.properties-editor').removeClass('hidden-node');
        },

        'hide': function () {
            Y.one('.properties-editor').addClass('hidden-node');
        },

        'getGenerator': function (metadata) {
            var self = this,
                dataType,
                generator;

            if (metadata) {
                if (self.generator) {
                    self.generator.destroy();
                }

                dataType = metadata.dataType;
                generator = new Y.Generator[dataType](metadata);
                self.generator = generator;
            }
            return generator;
        },

        'setMetadata': function (metadata) {
            var dataType;
            if (metadata) {
                metadata.id = metadata.id || Y.guid();
                dataType = metadata.dataType;
                if (dataType) {
                    metadata['is' + dataType] = true;
                }
            }

            return metadata;
        },

        'saveMetadataFromForm': function () {
            var self = this,
                optionTemplate = 'select.objectContract option[value="{objectContract}"]',
                optionNode,
                form,
                inputNodes,
                metadata,
                generator,
                getNodeValue;

            getNodeValue = function (node) {
                var name,
                    type,
                    checked,
                    value,
                    previousValue;

                name = node.get('name');
                type = node.get('type').toLowerCase();
                value = node.get('value');
                switch (type) {
                case 'radio':
                    checked = node.get('checked');
                    if (checked) {
                        metadata[name] = value;
                    }
                    break;

                case 'checkbox':
                    checked = node.get('checked');
                    if (checked) {
                        previousValue = metadata[name];
                        if (previousValue) {
                            metadata[name].push(value);
                        } else {
                            metadata[name] = [value];
                        }
                    }
                    break;

                default:
                    metadata[name] = value;
                }
            };

            metadata = {};
            generator = self.generator;
            if (generator) {
                form = Y.one('div#properties-input-form');
                inputNodes = form.all('input, textarea, select');
                inputNodes.each(getNodeValue);
                metadata = Y.mix(metadata, self.get('metadata'));
                if (metadata.dataType === 'Object' || metadata.dataType === 'Array') {
                    optionNode = form.one(YL.sub(optionTemplate, metadata));
                    metadata.objectName = optionNode ? optionNode.get('text') : '';
                    metadata.metadata = self.generator.get('metadata');
                }
                generator.setMetadata(metadata);
                self.generator = generator;
            }
        },

        'preserveColumnData': function () {
            var metadata = this.get('metadata');

            return {
                'attributeName': metadata.attributeName,
                'clientId': metadata.clientId
            };
        },

        'onDataTypeChange': function (event) {
            var self = this,
                dataType = event.target.get('value'),
                metadata,
                columnData,
                generator;

            self.saveMetadataFromForm();

            if (self.objectNameChange) {
                self.objectNameChange.detach();
                delete self.objectNameChange;
            }

            columnData = self.preserveColumnData();
            metadata = Y.Generator[dataType].defaultMetadata();
            generator = self.getGenerator(metadata);
            if (generator) {
                self.set('metadata', Y.mix(columnData, generator.getMetadata()));
            }
        }
    }, {
        'ATTRS': ATTRS,
        'CSS_PREFIX' : CSS_PREFIX
    });
}, '0.1', {
    'requires' : [
        'base',
        'widget',
        'generator-base',
        'generator-object',
        'util-json-pretty-print'
    ]
});

YUI.add('generator-rest-io', function (Y) {
    "use strict";
    Y.namespace('Generator').RestIO = function (config, callback) {
        var action,
            url,
            methodMap,
            ioConfig,
            handleFailure,
            handleSuccess;

        handleFailure = function (txId, result, action) {
            /*jslint unparam: true*/ //txId is not required but used for position
            Y.Util.MessageBox.alert(Y.Util.JsonPrettyPrint(result), action + ' Failed');
            if (callback) {
                callback();
            }
        };

        handleSuccess = function (txId, result, action) {
            /*jslint unparam: true*/ //txId is not required but used for position
            var data;

            if (callback) {
                data = Y.JSON.parse(result.responseText);
                callback(data);
            }
        };

        methodMap = {
            'create': 'POST',
            'read': 'GET',
            'update': 'PUT',
            'delete': 'DELETE'
        };

        action = config.action.toLowerCase();
        url = '/' + action;

        ioConfig = {
            'method': methodMap[action],
            'data': config.data,
            'arguments': config.action,
            'on': {
                'failure': handleFailure,
                'success': handleSuccess
            }
        };

        Y.io(url, ioConfig);
    };
}, '0.1', {
    'requires' : [
        'io',
        'util-json-pretty-print'
    ]
});