rethinkdb/ast.js

// Generated by CoffeeScript 1.10.0
var Add, And, Append, Args, Asc, Avg, Between, Binary, Bracket, Branch, Ceil, ChangeAt, Changes, Circle, CoerceTo, ConcatMap, Config, Contains, Count, DatumTerm, Day, DayOfWeek, DayOfYear, Db, DbCreate, DbDrop, DbList, Default, Delete, DeleteAt, Desc, Difference, Distance, Distinct, Div, Downcase, During, EpochTime, Eq, EqJoin, Fill, Filter, Floor, Fold, ForEach, FunCall, Func, Ge, Geojson, Get, GetAll, GetField, GetIntersecting, GetNearest, Grant, Group, Gt, HasFields, Hours, Http, ISO8601, ImplicitVar, InTimezone, Includes, IndexCreate, IndexDrop, IndexList, IndexRename, IndexStatus, IndexWait, Info, InnerJoin, Insert, InsertAt, Intersects, IsEmpty, JavaScript, Json, Keys, Le, Limit, Line, Literal, Lt, MakeArray, MakeObject, Map, Match, Max, Merge, Min, Minutes, Mod, Month, Mul, Ne, Not, Now, Nth, Object_, OffsetsOf, Or, OrderBy, OuterJoin, Pluck, Point, Polygon, PolygonSub, Prepend, Promise, RDBConstant, RDBOp, RDBVal, RQLDate, Random, Range, Rebalance, Reconfigure, Reduce, Replace, Round, Sample, Seconds, SetDifference, SetInsert, SetIntersection, SetUnion, Skip, Slice, SpliceAt, Split, Status, Sub, Sum, Sync, Table, TableCreate, TableDrop, TableList, TermBase, Time, TimeOfDay, Timezone, ToEpochTime, ToGeojson, ToISO8601, ToJsonString, TypeOf, UUID, Ungroup, Union, Upcase, Update, UserError, Values, Var, Wait, WithFields, Without, Year, Zip, ar, aropt, err, funcWrap, hasImplicit, intsp, intspallargs, kved, net, protoTermType, rethinkdb, shouldWrap, translateBackOptargs, translateOptargs, util, varar,
  slice = [].slice,
  hasProp = {}.hasOwnProperty,
  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

util = require('./util');

err = require('./errors');

net = require('./net');

protoTermType = require('./proto-def').Term.TermType;

Promise = require('bluebird');

ar = util.ar;

varar = util.varar;

aropt = util.aropt;

rethinkdb = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return rethinkdb.expr.apply(rethinkdb, args);
};

funcWrap = function(val) {
  var ivarScan;
  if (val === void 0) {
    return val;
  }
  val = rethinkdb.expr(val);
  ivarScan = function(node) {
    var k, v;
    if (!(node instanceof TermBase)) {
      return false;
    }
    if (node instanceof ImplicitVar) {
      return true;
    }
    if ((node.args.map(ivarScan)).some(function(a) {
      return a;
    })) {
      return true;
    }
    if (((function() {
      var ref, results;
      ref = node.optargs;
      results = [];
      for (k in ref) {
        if (!hasProp.call(ref, k)) continue;
        v = ref[k];
        results.push(v);
      }
      return results;
    })()).map(ivarScan).some(function(a) {
      return a;
    })) {
      return true;
    }
    return false;
  };
  if (ivarScan(val)) {
    return new Func({}, function(x) {
      return val;
    });
  }
  return val;
};

hasImplicit = function(args) {
  var arg, j, len;
  if (Array.isArray(args)) {
    for (j = 0, len = args.length; j < len; j++) {
      arg = args[j];
      if (hasImplicit(arg) === true) {
        return true;
      }
    }
  } else if (args === 'r.row') {
    return true;
  }
  return false;
};

TermBase = (function() {
  TermBase.prototype.showRunWarning = true;

  function TermBase() {
    var self;
    if ({}.__proto__ !== void 0) {
      self = ar(function(field) {
        return self.bracket(field);
      });
      self.__proto__ = this.__proto__;
      return self;
    } else {
      return this;
    }
  }

  TermBase.prototype.run = function(connection, options, callback) {
    if (net.isConnection(connection) === true) {
      if (typeof options === "function") {
        if (callback === void 0) {
          callback = options;
          options = {};
        } else {
          return Promise.reject(new err.ReqlDriverError("Second argument to `run` cannot be a function if a third argument is provided.")).nodeify(options);
        }
      }
    } else if ((connection != null ? connection.constructor : void 0) === Object) {
      if (this.showRunWarning === true) {
        if (typeof process !== "undefined" && process !== null) {
          process.stderr.write("RethinkDB warning: This syntax is deprecated. Please use `run(connection[, options], callback)`.");
        }
        this.showRunWarning = false;
      }
      callback = options;
      options = connection;
      connection = connection.connection;
      delete options["connection"];
    }
    if (options == null) {
      options = {};
    }
    if ((callback != null) && typeof callback !== 'function') {
      return Promise.reject(new err.ReqlDriverError("If provided, the callback must be a function. Please use `run(connection[, options][, callback])"));
    }
    if (net.isConnection(connection) === false) {
      return Promise.reject(new err.ReqlDriverError("First argument to `run` must be an open connection.")).nodeify(callback);
    }
    return new Promise((function(_this) {
      return function(resolve, reject) {
        var e, error, wrappedCb;
        wrappedCb = function(err, result) {
          if (err != null) {
            return reject(err);
          } else {
            return resolve(result);
          }
        };
        try {
          return connection._start(_this, wrappedCb, options);
        } catch (error) {
          e = error;
          return wrappedCb(e);
        }
      };
    })(this)).nodeify(callback);
  };

  TermBase.prototype.toString = function() {
    return err.printQuery(this);
  };

  return TermBase;

})();

RDBVal = (function(superClass) {
  extend(RDBVal, superClass);

  function RDBVal() {
    return RDBVal.__super__.constructor.apply(this, arguments);
  }

  RDBVal.prototype.eq = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Eq, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.ne = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Ne, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.lt = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Lt, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.le = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Le, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.gt = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Gt, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.ge = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Ge, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.not = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Not, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.add = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Add, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.sub = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Sub, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.mul = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Mul, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.div = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Div, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.mod = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Mod, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.floor = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Floor, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.ceil = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Ceil, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.round = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Round, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.append = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Append, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.prepend = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Prepend, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.difference = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Difference, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.setInsert = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(SetInsert, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.setUnion = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(SetUnion, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.setIntersection = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(SetIntersection, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.setDifference = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(SetDifference, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.slice = varar(1, 3, function(left, right_or_opts, opts) {
    if (opts != null) {
      return new Slice(opts, this, left, right_or_opts);
    } else if (typeof right_or_opts !== 'undefined') {
      if ((Object.prototype.toString.call(right_or_opts) === '[object Object]') && !(right_or_opts instanceof TermBase)) {
        return new Slice(right_or_opts, this, left);
      } else {
        return new Slice({}, this, left, right_or_opts);
      }
    } else {
      return new Slice({}, this, left);
    }
  });

  RDBVal.prototype.skip = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Skip, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.limit = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Limit, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.getField = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(GetField, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.contains = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Contains, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.insertAt = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(InsertAt, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.spliceAt = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(SpliceAt, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.deleteAt = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(DeleteAt, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.changeAt = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(ChangeAt, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.offsetsOf = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(OffsetsOf, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.hasFields = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(HasFields, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.withFields = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(WithFields, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.keys = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Keys, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.values = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Values, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.changes = aropt(function(opts) {
    return new Changes(opts, this);
  });

  RDBVal.prototype.pluck = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Pluck, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.without = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Without, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.merge = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Merge, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.between = aropt(function(left, right, opts) {
    return new Between(opts, this, left, right);
  });

  RDBVal.prototype.reduce = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Reduce, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.map = varar(1, null, function() {
    var args, funcArg, j;
    args = 2 <= arguments.length ? slice.call(arguments, 0, j = arguments.length - 1) : (j = 0, []), funcArg = arguments[j++];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Map, [{}, this].concat(slice.call(args), [funcWrap(funcArg)]), function(){});
  });

  RDBVal.prototype.fold = aropt(function(baseArg, accFuncArg, opts) {
    return new Fold(opts, this, baseArg, funcWrap(accFuncArg));
  });

  RDBVal.prototype.filter = aropt(function(predicate, opts) {
    return new Filter(opts, this, funcWrap(predicate));
  });

  RDBVal.prototype.concatMap = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(ConcatMap, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.distinct = aropt(function(opts) {
    return new Distinct(opts, this);
  });

  RDBVal.prototype.count = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Count, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.union = function() {
    var attr, attrs, attrsAndOpts, opts, perhapsOptDict;
    attrsAndOpts = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    opts = {};
    attrs = attrsAndOpts;
    perhapsOptDict = attrsAndOpts[attrsAndOpts.length - 1];
    if (perhapsOptDict && (Object.prototype.toString.call(perhapsOptDict) === '[object Object]') && !(perhapsOptDict instanceof TermBase)) {
      opts = perhapsOptDict;
      attrs = attrsAndOpts.slice(0, attrsAndOpts.length - 1);
    }
    attrs = (function() {
      var j, len, results;
      results = [];
      for (j = 0, len = attrs.length; j < len; j++) {
        attr = attrs[j];
        if (attr instanceof Asc || attr instanceof Desc) {
          results.push(attr);
        } else {
          results.push(funcWrap(attr));
        }
      }
      return results;
    })();
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Union, [opts, this].concat(slice.call(attrs)), function(){});
  };

  RDBVal.prototype.nth = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Nth, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.bracket = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Bracket, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.toJSON = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(ToJsonString, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.toJsonString = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(ToJsonString, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.match = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Match, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.split = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Split, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.upcase = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Upcase, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.downcase = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Downcase, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.isEmpty = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(IsEmpty, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.innerJoin = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(InnerJoin, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.outerJoin = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(OuterJoin, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.eqJoin = aropt(function(left_attr, right, opts) {
    return new EqJoin(opts, this, funcWrap(left_attr), right);
  });

  RDBVal.prototype.zip = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Zip, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.coerceTo = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(CoerceTo, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.ungroup = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Ungroup, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.typeOf = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(TypeOf, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.update = aropt(function(func, opts) {
    return new Update(opts, this, funcWrap(func));
  });

  RDBVal.prototype["delete"] = aropt(function(opts) {
    return new Delete(opts, this);
  });

  RDBVal.prototype.replace = aropt(function(func, opts) {
    return new Replace(opts, this, funcWrap(func));
  });

  RDBVal.prototype["do"] = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(FunCall, [{}, funcWrap(args.slice(-1)[0]), this].concat(slice.call(args.slice(0, -1))), function(){});
  };

  RDBVal.prototype["default"] = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Default, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.or = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Or, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.and = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(And, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.branch = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Branch, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.forEach = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(ForEach, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.sum = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Sum, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.avg = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Avg, [{}, this].concat(slice.call(args.map(funcWrap))), function(){});
  };

  RDBVal.prototype.info = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Info, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.sample = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Sample, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.group = function() {
    var fields, fieldsAndOpts, opts, perhapsOptDict;
    fieldsAndOpts = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    opts = {};
    fields = fieldsAndOpts;
    if (fieldsAndOpts.length > 0) {
      perhapsOptDict = fieldsAndOpts[fieldsAndOpts.length - 1];
      if (perhapsOptDict && (Object.prototype.toString.call(perhapsOptDict) === '[object Object]') && !(perhapsOptDict instanceof TermBase)) {
        opts = perhapsOptDict;
        fields = fieldsAndOpts.slice(0, fieldsAndOpts.length - 1);
      }
    }
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Group, [opts, this].concat(slice.call(fields.map(funcWrap))), function(){});
  };

  RDBVal.prototype.orderBy = function() {
    var attr, attrs, attrsAndOpts, opts, perhapsOptDict;
    attrsAndOpts = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    opts = {};
    attrs = attrsAndOpts;
    perhapsOptDict = attrsAndOpts[attrsAndOpts.length - 1];
    if (perhapsOptDict && (Object.prototype.toString.call(perhapsOptDict) === '[object Object]') && !(perhapsOptDict instanceof TermBase)) {
      opts = perhapsOptDict;
      attrs = attrsAndOpts.slice(0, attrsAndOpts.length - 1);
    }
    attrs = (function() {
      var j, len, results;
      results = [];
      for (j = 0, len = attrs.length; j < len; j++) {
        attr = attrs[j];
        if (attr instanceof Asc || attr instanceof Desc) {
          results.push(attr);
        } else {
          results.push(funcWrap(attr));
        }
      }
      return results;
    })();
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(OrderBy, [opts, this].concat(slice.call(attrs)), function(){});
  };

  RDBVal.prototype.toGeojson = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(ToGeojson, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.distance = aropt(function(g, opts) {
    return new Distance(opts, this, g);
  });

  RDBVal.prototype.intersects = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Intersects, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.includes = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Includes, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.fill = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Fill, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.polygonSub = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(PolygonSub, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.tableCreate = aropt(function(tblName, opts) {
    return new TableCreate(opts, this, tblName);
  });

  RDBVal.prototype.tableDrop = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(TableDrop, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.tableList = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(TableList, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.config = function() {
    return new Config({}, this);
  };

  RDBVal.prototype.status = function() {
    return new Status({}, this);
  };

  RDBVal.prototype.wait = aropt(function(opts) {
    return new Wait(opts, this);
  });

  RDBVal.prototype.table = aropt(function(tblName, opts) {
    return new Table(opts, this, tblName);
  });

  RDBVal.prototype.get = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Get, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.getAll = function() {
    var keys, keysAndOpts, opts, perhapsOptDict;
    keysAndOpts = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    opts = {};
    keys = keysAndOpts;
    if (keysAndOpts.length > 1) {
      perhapsOptDict = keysAndOpts[keysAndOpts.length - 1];
      if (perhapsOptDict && ((Object.prototype.toString.call(perhapsOptDict) === '[object Object]') && !(perhapsOptDict instanceof TermBase))) {
        opts = perhapsOptDict;
        keys = keysAndOpts.slice(0, keysAndOpts.length - 1);
      }
    }
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(GetAll, [opts, this].concat(slice.call(keys)), function(){});
  };

  RDBVal.prototype.min = function() {
    var keys, keysAndOpts, opts, perhapsOptDict;
    keysAndOpts = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    opts = {};
    keys = keysAndOpts;
    if (keysAndOpts.length === 1) {
      perhapsOptDict = keysAndOpts[0];
      if (perhapsOptDict && ((Object.prototype.toString.call(perhapsOptDict) === '[object Object]') && !(perhapsOptDict instanceof TermBase))) {
        opts = perhapsOptDict;
        keys = [];
      }
    }
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Min, [opts, this].concat(slice.call(keys.map(funcWrap))), function(){});
  };

  RDBVal.prototype.max = function() {
    var keys, keysAndOpts, opts, perhapsOptDict;
    keysAndOpts = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    opts = {};
    keys = keysAndOpts;
    if (keysAndOpts.length === 1) {
      perhapsOptDict = keysAndOpts[0];
      if (perhapsOptDict && ((Object.prototype.toString.call(perhapsOptDict) === '[object Object]') && !(perhapsOptDict instanceof TermBase))) {
        opts = perhapsOptDict;
        keys = [];
      }
    }
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Max, [opts, this].concat(slice.call(keys.map(funcWrap))), function(){});
  };

  RDBVal.prototype.insert = aropt(function(doc, opts) {
    return new Insert(opts, this, rethinkdb.expr(doc));
  });

  RDBVal.prototype.indexCreate = varar(1, 3, function(name, defun_or_opts, opts) {
    if (opts != null) {
      return new IndexCreate(opts, this, name, funcWrap(defun_or_opts));
    } else if (defun_or_opts != null) {
      if ((Object.prototype.toString.call(defun_or_opts) === '[object Object]') && !(typeof defun_or_opts === 'function') && !(defun_or_opts instanceof TermBase)) {
        return new IndexCreate(defun_or_opts, this, name);
      } else {
        return new IndexCreate({}, this, name, funcWrap(defun_or_opts));
      }
    } else {
      return new IndexCreate({}, this, name);
    }
  });

  RDBVal.prototype.indexDrop = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(IndexDrop, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.indexList = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(IndexList, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.indexStatus = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(IndexStatus, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.indexWait = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(IndexWait, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.indexRename = aropt(function(old_name, new_name, opts) {
    return new IndexRename(opts, this, old_name, new_name);
  });

  RDBVal.prototype.reconfigure = function(opts) {
    return new Reconfigure(opts, this);
  };

  RDBVal.prototype.rebalance = function() {
    return new Rebalance({}, this);
  };

  RDBVal.prototype.sync = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Sync, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.grant = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Grant, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.toISO8601 = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(ToISO8601, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.toEpochTime = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(ToEpochTime, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.inTimezone = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(InTimezone, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.during = aropt(function(t2, t3, opts) {
    return new During(opts, this, t2, t3);
  });

  RDBVal.prototype.date = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(RQLDate, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.timeOfDay = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(TimeOfDay, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.timezone = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Timezone, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.year = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Year, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.month = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Month, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.day = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Day, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.dayOfWeek = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(DayOfWeek, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.dayOfYear = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(DayOfYear, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.hours = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Hours, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.minutes = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Minutes, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.seconds = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(Seconds, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.uuid = function() {
    var args;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(UUID, [{}, this].concat(slice.call(args)), function(){});
  };

  RDBVal.prototype.getIntersecting = aropt(function(g, opts) {
    return new GetIntersecting(opts, this, g);
  });

  RDBVal.prototype.getNearest = aropt(function(g, opts) {
    return new GetNearest(opts, this, g);
  });

  return RDBVal;

})(TermBase);

DatumTerm = (function(superClass) {
  extend(DatumTerm, superClass);

  DatumTerm.prototype.args = [];

  DatumTerm.prototype.optargs = {};

  function DatumTerm(val) {
    var self;
    self = DatumTerm.__super__.constructor.call(this);
    self.data = val;
    return self;
  }

  DatumTerm.prototype.compose = function() {
    switch (typeof this.data) {
      case 'string':
        return '"' + this.data + '"';
      default:
        return '' + this.data;
    }
  };

  DatumTerm.prototype.build = function() {
    if (typeof this.data === 'number') {
      if (!isFinite(this.data)) {
        throw new TypeError("Illegal non-finite number `" + this.data.toString() + "`.");
      }
    }
    return this.data;
  };

  return DatumTerm;

})(RDBVal);

translateBackOptargs = function(optargs) {
  var key, result, val;
  result = {};
  for (key in optargs) {
    if (!hasProp.call(optargs, key)) continue;
    val = optargs[key];
    result[util.toCamelCase(key)] = val;
  }
  return result;
};

translateOptargs = function(optargs) {
  var key, result, val;
  result = {};
  for (key in optargs) {
    if (!hasProp.call(optargs, key)) continue;
    val = optargs[key];
    if (key === void 0 || val === void 0) {
      continue;
    }
    result[util.fromCamelCase(key)] = rethinkdb.expr(val);
  }
  return result;
};

RDBOp = (function(superClass) {
  extend(RDBOp, superClass);

  function RDBOp() {
    var arg, args, i, optargs, self;
    optargs = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
    self = RDBOp.__super__.constructor.call(this);
    self.args = (function() {
      var j, len, results;
      results = [];
      for (i = j = 0, len = args.length; j < len; i = ++j) {
        arg = args[i];
        if (arg !== void 0) {
          results.push(rethinkdb.expr(arg));
        } else {
          throw new err.ReqlDriverCompileError("Argument " + i + " to " + (this.st || this.mt) + " may not be `undefined`.");
        }
      }
      return results;
    }).call(this);
    self.optargs = translateOptargs(optargs);
    return self;
  }

  RDBOp.prototype.build = function() {
    var add_opts, arg, j, key, len, opts, ref, ref1, res, val;
    res = [this.tt, []];
    ref = this.args;
    for (j = 0, len = ref.length; j < len; j++) {
      arg = ref[j];
      res[1].push(arg.build());
    }
    opts = {};
    add_opts = false;
    ref1 = this.optargs;
    for (key in ref1) {
      if (!hasProp.call(ref1, key)) continue;
      val = ref1[key];
      add_opts = true;
      opts[key] = val.build();
    }
    if (add_opts) {
      res.push(opts);
    }
    return res;
  };

  RDBOp.prototype.compose = function(args, optargs) {
    if (this.st) {
      return ['r.', this.st, '(', intspallargs(args, optargs), ')'];
    } else {
      if (shouldWrap(this.args[0])) {
        args[0] = ['r(', args[0], ')'];
      }
      return [args[0], '.', this.mt, '(', intspallargs(args.slice(1), optargs), ')'];
    }
  };

  return RDBOp;

})(RDBVal);

RDBConstant = (function(superClass) {
  extend(RDBConstant, superClass);

  function RDBConstant() {
    return RDBConstant.__super__.constructor.apply(this, arguments);
  }

  RDBConstant.prototype.compose = function(args, optargs) {
    return ['r.', this.st];
  };

  return RDBConstant;

})(RDBOp);

intsp = function(seq) {
  var e, j, len, ref, res;
  if (seq[0] == null) {
    return [];
  }
  res = [seq[0]];
  ref = seq.slice(1);
  for (j = 0, len = ref.length; j < len; j++) {
    e = ref[j];
    res.push(', ', e);
  }
  return res;
};

kved = function(optargs) {
  var k, v;
  return [
    '{', intsp((function() {
      var results;
      results = [];
      for (k in optargs) {
        if (!hasProp.call(optargs, k)) continue;
        v = optargs[k];
        results.push([JSON.stringify(k), ': ', v]);
      }
      return results;
    })()), '}'
  ];
};

intspallargs = function(args, optargs) {
  var argrepr;
  argrepr = [];
  if (args.length > 0) {
    argrepr.push(intsp(args));
  }
  if (Object.keys(optargs).length > 0) {
    if (argrepr.length > 0) {
      argrepr.push(', ');
    }
    argrepr.push(kved(translateBackOptargs(optargs)));
  }
  return argrepr;
};

shouldWrap = function(arg) {
  return arg instanceof DatumTerm || arg instanceof MakeArray || arg instanceof MakeObject;
};

MakeArray = (function(superClass) {
  extend(MakeArray, superClass);

  function MakeArray() {
    return MakeArray.__super__.constructor.apply(this, arguments);
  }

  MakeArray.prototype.tt = protoTermType.MAKE_ARRAY;

  MakeArray.prototype.st = '[...]';

  MakeArray.prototype.compose = function(args) {
    return ['[', intsp(args), ']'];
  };

  return MakeArray;

})(RDBOp);

MakeObject = (function(superClass) {
  extend(MakeObject, superClass);

  MakeObject.prototype.tt = protoTermType.MAKE_OBJ;

  MakeObject.prototype.st = '{...}';

  function MakeObject(obj, nestingDepth) {
    var key, self, val;
    if (nestingDepth == null) {
      nestingDepth = 20;
    }
    self = MakeObject.__super__.constructor.call(this, {});
    self.optargs = {};
    for (key in obj) {
      if (!hasProp.call(obj, key)) continue;
      val = obj[key];
      if (typeof val === 'undefined') {
        throw new err.ReqlDriverCompileError("Object field '" + key + "' may not be undefined");
      }
      self.optargs[key] = rethinkdb.expr(val, nestingDepth - 1);
    }
    return self;
  }

  MakeObject.prototype.compose = function(args, optargs) {
    return kved(optargs);
  };

  MakeObject.prototype.build = function() {
    var key, ref, res, val;
    res = {};
    ref = this.optargs;
    for (key in ref) {
      if (!hasProp.call(ref, key)) continue;
      val = ref[key];
      res[key] = val.build();
    }
    return res;
  };

  return MakeObject;

})(RDBOp);

Var = (function(superClass) {
  extend(Var, superClass);

  function Var() {
    return Var.__super__.constructor.apply(this, arguments);
  }

  Var.prototype.tt = protoTermType.VAR;

  Var.prototype.compose = function(args) {
    return ['var_' + args];
  };

  return Var;

})(RDBOp);

JavaScript = (function(superClass) {
  extend(JavaScript, superClass);

  function JavaScript() {
    return JavaScript.__super__.constructor.apply(this, arguments);
  }

  JavaScript.prototype.tt = protoTermType.JAVASCRIPT;

  JavaScript.prototype.st = 'js';

  return JavaScript;

})(RDBOp);

Http = (function(superClass) {
  extend(Http, superClass);

  function Http() {
    return Http.__super__.constructor.apply(this, arguments);
  }

  Http.prototype.tt = protoTermType.HTTP;

  Http.prototype.st = 'http';

  return Http;

})(RDBOp);

Json = (function(superClass) {
  extend(Json, superClass);

  function Json() {
    return Json.__super__.constructor.apply(this, arguments);
  }

  Json.prototype.tt = protoTermType.JSON;

  Json.prototype.st = 'json';

  return Json;

})(RDBOp);

Binary = (function(superClass) {
  extend(Binary, superClass);

  Binary.prototype.tt = protoTermType.BINARY;

  Binary.prototype.st = 'binary';

  function Binary(data) {
    var self;
    if (data instanceof TermBase) {
      self = Binary.__super__.constructor.call(this, {}, data);
    } else if (data instanceof Buffer) {
      self = Binary.__super__.constructor.call(this);
      self.base64_data = data.toString("base64");
    } else {
      throw new TypeError("Parameter to `r.binary` must be a Buffer object or RQL query.");
    }
    return self;
  }

  Binary.prototype.compose = function() {
    if (this.args.length === 0) {
      return 'r.binary(<data>)';
    } else {
      return Binary.__super__.compose.apply(this, arguments);
    }
  };

  Binary.prototype.build = function() {
    if (this.args.length === 0) {
      return {
        '$reql_type$': 'BINARY',
        'data': this.base64_data
      };
    } else {
      return Binary.__super__.build.apply(this, arguments);
    }
  };

  return Binary;

})(RDBOp);

Args = (function(superClass) {
  extend(Args, superClass);

  function Args() {
    return Args.__super__.constructor.apply(this, arguments);
  }

  Args.prototype.tt = protoTermType.ARGS;

  Args.prototype.st = 'args';

  return Args;

})(RDBOp);

UserError = (function(superClass) {
  extend(UserError, superClass);

  function UserError() {
    return UserError.__super__.constructor.apply(this, arguments);
  }

  UserError.prototype.tt = protoTermType.ERROR;

  UserError.prototype.st = 'error';

  return UserError;

})(RDBOp);

Random = (function(superClass) {
  extend(Random, superClass);

  function Random() {
    return Random.__super__.constructor.apply(this, arguments);
  }

  Random.prototype.tt = protoTermType.RANDOM;

  Random.prototype.st = 'random';

  return Random;

})(RDBOp);

ImplicitVar = (function(superClass) {
  extend(ImplicitVar, superClass);

  function ImplicitVar() {
    return ImplicitVar.__super__.constructor.apply(this, arguments);
  }

  ImplicitVar.prototype.tt = protoTermType.IMPLICIT_VAR;

  ImplicitVar.prototype.compose = function() {
    return ['r.row'];
  };

  return ImplicitVar;

})(RDBOp);

Db = (function(superClass) {
  extend(Db, superClass);

  function Db() {
    return Db.__super__.constructor.apply(this, arguments);
  }

  Db.prototype.tt = protoTermType.DB;

  Db.prototype.st = 'db';

  return Db;

})(RDBOp);

Table = (function(superClass) {
  extend(Table, superClass);

  function Table() {
    return Table.__super__.constructor.apply(this, arguments);
  }

  Table.prototype.tt = protoTermType.TABLE;

  Table.prototype.st = 'table';

  Table.prototype.compose = function(args, optargs) {
    if (this.args[0] instanceof Db) {
      return [args[0], '.table(', intspallargs(args.slice(1), optargs), ')'];
    } else {
      return ['r.table(', intspallargs(args, optargs), ')'];
    }
  };

  return Table;

})(RDBOp);

Get = (function(superClass) {
  extend(Get, superClass);

  function Get() {
    return Get.__super__.constructor.apply(this, arguments);
  }

  Get.prototype.tt = protoTermType.GET;

  Get.prototype.mt = 'get';

  return Get;

})(RDBOp);

GetAll = (function(superClass) {
  extend(GetAll, superClass);

  function GetAll() {
    return GetAll.__super__.constructor.apply(this, arguments);
  }

  GetAll.prototype.tt = protoTermType.GET_ALL;

  GetAll.prototype.mt = 'getAll';

  return GetAll;

})(RDBOp);

Eq = (function(superClass) {
  extend(Eq, superClass);

  function Eq() {
    return Eq.__super__.constructor.apply(this, arguments);
  }

  Eq.prototype.tt = protoTermType.EQ;

  Eq.prototype.mt = 'eq';

  return Eq;

})(RDBOp);

Ne = (function(superClass) {
  extend(Ne, superClass);

  function Ne() {
    return Ne.__super__.constructor.apply(this, arguments);
  }

  Ne.prototype.tt = protoTermType.NE;

  Ne.prototype.mt = 'ne';

  return Ne;

})(RDBOp);

Lt = (function(superClass) {
  extend(Lt, superClass);

  function Lt() {
    return Lt.__super__.constructor.apply(this, arguments);
  }

  Lt.prototype.tt = protoTermType.LT;

  Lt.prototype.mt = 'lt';

  return Lt;

})(RDBOp);

Le = (function(superClass) {
  extend(Le, superClass);

  function Le() {
    return Le.__super__.constructor.apply(this, arguments);
  }

  Le.prototype.tt = protoTermType.LE;

  Le.prototype.mt = 'le';

  return Le;

})(RDBOp);

Gt = (function(superClass) {
  extend(Gt, superClass);

  function Gt() {
    return Gt.__super__.constructor.apply(this, arguments);
  }

  Gt.prototype.tt = protoTermType.GT;

  Gt.prototype.mt = 'gt';

  return Gt;

})(RDBOp);

Ge = (function(superClass) {
  extend(Ge, superClass);

  function Ge() {
    return Ge.__super__.constructor.apply(this, arguments);
  }

  Ge.prototype.tt = protoTermType.GE;

  Ge.prototype.mt = 'ge';

  return Ge;

})(RDBOp);

Not = (function(superClass) {
  extend(Not, superClass);

  function Not() {
    return Not.__super__.constructor.apply(this, arguments);
  }

  Not.prototype.tt = protoTermType.NOT;

  Not.prototype.mt = 'not';

  return Not;

})(RDBOp);

Add = (function(superClass) {
  extend(Add, superClass);

  function Add() {
    return Add.__super__.constructor.apply(this, arguments);
  }

  Add.prototype.tt = protoTermType.ADD;

  Add.prototype.mt = 'add';

  return Add;

})(RDBOp);

Sub = (function(superClass) {
  extend(Sub, superClass);

  function Sub() {
    return Sub.__super__.constructor.apply(this, arguments);
  }

  Sub.prototype.tt = protoTermType.SUB;

  Sub.prototype.mt = 'sub';

  return Sub;

})(RDBOp);

Mul = (function(superClass) {
  extend(Mul, superClass);

  function Mul() {
    return Mul.__super__.constructor.apply(this, arguments);
  }

  Mul.prototype.tt = protoTermType.MUL;

  Mul.prototype.mt = 'mul';

  return Mul;

})(RDBOp);

Div = (function(superClass) {
  extend(Div, superClass);

  function Div() {
    return Div.__super__.constructor.apply(this, arguments);
  }

  Div.prototype.tt = protoTermType.DIV;

  Div.prototype.mt = 'div';

  return Div;

})(RDBOp);

Mod = (function(superClass) {
  extend(Mod, superClass);

  function Mod() {
    return Mod.__super__.constructor.apply(this, arguments);
  }

  Mod.prototype.tt = protoTermType.MOD;

  Mod.prototype.mt = 'mod';

  return Mod;

})(RDBOp);

Floor = (function(superClass) {
  extend(Floor, superClass);

  function Floor() {
    return Floor.__super__.constructor.apply(this, arguments);
  }

  Floor.prototype.tt = protoTermType.FLOOR;

  Floor.prototype.mt = 'floor';

  return Floor;

})(RDBOp);

Ceil = (function(superClass) {
  extend(Ceil, superClass);

  function Ceil() {
    return Ceil.__super__.constructor.apply(this, arguments);
  }

  Ceil.prototype.tt = protoTermType.CEIL;

  Ceil.prototype.mt = 'ceil';

  return Ceil;

})(RDBOp);

Round = (function(superClass) {
  extend(Round, superClass);

  function Round() {
    return Round.__super__.constructor.apply(this, arguments);
  }

  Round.prototype.tt = protoTermType.ROUND;

  Round.prototype.mt = 'round';

  return Round;

})(RDBOp);

Append = (function(superClass) {
  extend(Append, superClass);

  function Append() {
    return Append.__super__.constructor.apply(this, arguments);
  }

  Append.prototype.tt = protoTermType.APPEND;

  Append.prototype.mt = 'append';

  return Append;

})(RDBOp);

Prepend = (function(superClass) {
  extend(Prepend, superClass);

  function Prepend() {
    return Prepend.__super__.constructor.apply(this, arguments);
  }

  Prepend.prototype.tt = protoTermType.PREPEND;

  Prepend.prototype.mt = 'prepend';

  return Prepend;

})(RDBOp);

Difference = (function(superClass) {
  extend(Difference, superClass);

  function Difference() {
    return Difference.__super__.constructor.apply(this, arguments);
  }

  Difference.prototype.tt = protoTermType.DIFFERENCE;

  Difference.prototype.mt = 'difference';

  return Difference;

})(RDBOp);

SetInsert = (function(superClass) {
  extend(SetInsert, superClass);

  function SetInsert() {
    return SetInsert.__super__.constructor.apply(this, arguments);
  }

  SetInsert.prototype.tt = protoTermType.SET_INSERT;

  SetInsert.prototype.mt = 'setInsert';

  return SetInsert;

})(RDBOp);

SetUnion = (function(superClass) {
  extend(SetUnion, superClass);

  function SetUnion() {
    return SetUnion.__super__.constructor.apply(this, arguments);
  }

  SetUnion.prototype.tt = protoTermType.SET_UNION;

  SetUnion.prototype.mt = 'setUnion';

  return SetUnion;

})(RDBOp);

SetIntersection = (function(superClass) {
  extend(SetIntersection, superClass);

  function SetIntersection() {
    return SetIntersection.__super__.constructor.apply(this, arguments);
  }

  SetIntersection.prototype.tt = protoTermType.SET_INTERSECTION;

  SetIntersection.prototype.mt = 'setIntersection';

  return SetIntersection;

})(RDBOp);

SetDifference = (function(superClass) {
  extend(SetDifference, superClass);

  function SetDifference() {
    return SetDifference.__super__.constructor.apply(this, arguments);
  }

  SetDifference.prototype.tt = protoTermType.SET_DIFFERENCE;

  SetDifference.prototype.mt = 'setDifference';

  return SetDifference;

})(RDBOp);

Slice = (function(superClass) {
  extend(Slice, superClass);

  function Slice() {
    return Slice.__super__.constructor.apply(this, arguments);
  }

  Slice.prototype.tt = protoTermType.SLICE;

  Slice.prototype.mt = 'slice';

  return Slice;

})(RDBOp);

Skip = (function(superClass) {
  extend(Skip, superClass);

  function Skip() {
    return Skip.__super__.constructor.apply(this, arguments);
  }

  Skip.prototype.tt = protoTermType.SKIP;

  Skip.prototype.mt = 'skip';

  return Skip;

})(RDBOp);

Limit = (function(superClass) {
  extend(Limit, superClass);

  function Limit() {
    return Limit.__super__.constructor.apply(this, arguments);
  }

  Limit.prototype.tt = protoTermType.LIMIT;

  Limit.prototype.mt = 'limit';

  return Limit;

})(RDBOp);

GetField = (function(superClass) {
  extend(GetField, superClass);

  function GetField() {
    return GetField.__super__.constructor.apply(this, arguments);
  }

  GetField.prototype.tt = protoTermType.GET_FIELD;

  GetField.prototype.mt = 'getField';

  return GetField;

})(RDBOp);

Bracket = (function(superClass) {
  extend(Bracket, superClass);

  function Bracket() {
    return Bracket.__super__.constructor.apply(this, arguments);
  }

  Bracket.prototype.tt = protoTermType.BRACKET;

  Bracket.prototype.st = '(...)';

  Bracket.prototype.compose = function(args) {
    return [args[0], '(', args[1], ')'];
  };

  return Bracket;

})(RDBOp);

Contains = (function(superClass) {
  extend(Contains, superClass);

  function Contains() {
    return Contains.__super__.constructor.apply(this, arguments);
  }

  Contains.prototype.tt = protoTermType.CONTAINS;

  Contains.prototype.mt = 'contains';

  return Contains;

})(RDBOp);

InsertAt = (function(superClass) {
  extend(InsertAt, superClass);

  function InsertAt() {
    return InsertAt.__super__.constructor.apply(this, arguments);
  }

  InsertAt.prototype.tt = protoTermType.INSERT_AT;

  InsertAt.prototype.mt = 'insertAt';

  return InsertAt;

})(RDBOp);

SpliceAt = (function(superClass) {
  extend(SpliceAt, superClass);

  function SpliceAt() {
    return SpliceAt.__super__.constructor.apply(this, arguments);
  }

  SpliceAt.prototype.tt = protoTermType.SPLICE_AT;

  SpliceAt.prototype.mt = 'spliceAt';

  return SpliceAt;

})(RDBOp);

DeleteAt = (function(superClass) {
  extend(DeleteAt, superClass);

  function DeleteAt() {
    return DeleteAt.__super__.constructor.apply(this, arguments);
  }

  DeleteAt.prototype.tt = protoTermType.DELETE_AT;

  DeleteAt.prototype.mt = 'deleteAt';

  return DeleteAt;

})(RDBOp);

ChangeAt = (function(superClass) {
  extend(ChangeAt, superClass);

  function ChangeAt() {
    return ChangeAt.__super__.constructor.apply(this, arguments);
  }

  ChangeAt.prototype.tt = protoTermType.CHANGE_AT;

  ChangeAt.prototype.mt = 'changeAt';

  return ChangeAt;

})(RDBOp);

HasFields = (function(superClass) {
  extend(HasFields, superClass);

  function HasFields() {
    return HasFields.__super__.constructor.apply(this, arguments);
  }

  HasFields.prototype.tt = protoTermType.HAS_FIELDS;

  HasFields.prototype.mt = 'hasFields';

  return HasFields;

})(RDBOp);

WithFields = (function(superClass) {
  extend(WithFields, superClass);

  function WithFields() {
    return WithFields.__super__.constructor.apply(this, arguments);
  }

  WithFields.prototype.tt = protoTermType.WITH_FIELDS;

  WithFields.prototype.mt = 'withFields';

  return WithFields;

})(RDBOp);

Keys = (function(superClass) {
  extend(Keys, superClass);

  function Keys() {
    return Keys.__super__.constructor.apply(this, arguments);
  }

  Keys.prototype.tt = protoTermType.KEYS;

  Keys.prototype.mt = 'keys';

  return Keys;

})(RDBOp);

Values = (function(superClass) {
  extend(Values, superClass);

  function Values() {
    return Values.__super__.constructor.apply(this, arguments);
  }

  Values.prototype.tt = protoTermType.VALUES;

  Values.prototype.mt = 'values';

  return Values;

})(RDBOp);

Changes = (function(superClass) {
  extend(Changes, superClass);

  function Changes() {
    return Changes.__super__.constructor.apply(this, arguments);
  }

  Changes.prototype.tt = protoTermType.CHANGES;

  Changes.prototype.mt = 'changes';

  return Changes;

})(RDBOp);

Object_ = (function(superClass) {
  extend(Object_, superClass);

  function Object_() {
    return Object_.__super__.constructor.apply(this, arguments);
  }

  Object_.prototype.tt = protoTermType.OBJECT;

  Object_.prototype.mt = 'object';

  return Object_;

})(RDBOp);

Pluck = (function(superClass) {
  extend(Pluck, superClass);

  function Pluck() {
    return Pluck.__super__.constructor.apply(this, arguments);
  }

  Pluck.prototype.tt = protoTermType.PLUCK;

  Pluck.prototype.mt = 'pluck';

  return Pluck;

})(RDBOp);

OffsetsOf = (function(superClass) {
  extend(OffsetsOf, superClass);

  function OffsetsOf() {
    return OffsetsOf.__super__.constructor.apply(this, arguments);
  }

  OffsetsOf.prototype.tt = protoTermType.OFFSETS_OF;

  OffsetsOf.prototype.mt = 'offsetsOf';

  return OffsetsOf;

})(RDBOp);

Without = (function(superClass) {
  extend(Without, superClass);

  function Without() {
    return Without.__super__.constructor.apply(this, arguments);
  }

  Without.prototype.tt = protoTermType.WITHOUT;

  Without.prototype.mt = 'without';

  return Without;

})(RDBOp);

Merge = (function(superClass) {
  extend(Merge, superClass);

  function Merge() {
    return Merge.__super__.constructor.apply(this, arguments);
  }

  Merge.prototype.tt = protoTermType.MERGE;

  Merge.prototype.mt = 'merge';

  return Merge;

})(RDBOp);

Between = (function(superClass) {
  extend(Between, superClass);

  function Between() {
    return Between.__super__.constructor.apply(this, arguments);
  }

  Between.prototype.tt = protoTermType.BETWEEN;

  Between.prototype.mt = 'between';

  return Between;

})(RDBOp);

Reduce = (function(superClass) {
  extend(Reduce, superClass);

  function Reduce() {
    return Reduce.__super__.constructor.apply(this, arguments);
  }

  Reduce.prototype.tt = protoTermType.REDUCE;

  Reduce.prototype.mt = 'reduce';

  return Reduce;

})(RDBOp);

Map = (function(superClass) {
  extend(Map, superClass);

  function Map() {
    return Map.__super__.constructor.apply(this, arguments);
  }

  Map.prototype.tt = protoTermType.MAP;

  Map.prototype.mt = 'map';

  return Map;

})(RDBOp);

Fold = (function(superClass) {
  extend(Fold, superClass);

  function Fold() {
    return Fold.__super__.constructor.apply(this, arguments);
  }

  Fold.prototype.tt = protoTermType.FOLD;

  Fold.prototype.mt = 'fold';

  return Fold;

})(RDBOp);

Filter = (function(superClass) {
  extend(Filter, superClass);

  function Filter() {
    return Filter.__super__.constructor.apply(this, arguments);
  }

  Filter.prototype.tt = protoTermType.FILTER;

  Filter.prototype.mt = 'filter';

  return Filter;

})(RDBOp);

ConcatMap = (function(superClass) {
  extend(ConcatMap, superClass);

  function ConcatMap() {
    return ConcatMap.__super__.constructor.apply(this, arguments);
  }

  ConcatMap.prototype.tt = protoTermType.CONCAT_MAP;

  ConcatMap.prototype.mt = 'concatMap';

  return ConcatMap;

})(RDBOp);

OrderBy = (function(superClass) {
  extend(OrderBy, superClass);

  function OrderBy() {
    return OrderBy.__super__.constructor.apply(this, arguments);
  }

  OrderBy.prototype.tt = protoTermType.ORDER_BY;

  OrderBy.prototype.mt = 'orderBy';

  return OrderBy;

})(RDBOp);

Distinct = (function(superClass) {
  extend(Distinct, superClass);

  function Distinct() {
    return Distinct.__super__.constructor.apply(this, arguments);
  }

  Distinct.prototype.tt = protoTermType.DISTINCT;

  Distinct.prototype.mt = 'distinct';

  return Distinct;

})(RDBOp);

Count = (function(superClass) {
  extend(Count, superClass);

  function Count() {
    return Count.__super__.constructor.apply(this, arguments);
  }

  Count.prototype.tt = protoTermType.COUNT;

  Count.prototype.mt = 'count';

  return Count;

})(RDBOp);

Union = (function(superClass) {
  extend(Union, superClass);

  function Union() {
    return Union.__super__.constructor.apply(this, arguments);
  }

  Union.prototype.tt = protoTermType.UNION;

  Union.prototype.mt = 'union';

  return Union;

})(RDBOp);

Nth = (function(superClass) {
  extend(Nth, superClass);

  function Nth() {
    return Nth.__super__.constructor.apply(this, arguments);
  }

  Nth.prototype.tt = protoTermType.NTH;

  Nth.prototype.mt = 'nth';

  return Nth;

})(RDBOp);

ToJsonString = (function(superClass) {
  extend(ToJsonString, superClass);

  function ToJsonString() {
    return ToJsonString.__super__.constructor.apply(this, arguments);
  }

  ToJsonString.prototype.tt = protoTermType.TO_JSON_STRING;

  ToJsonString.prototype.mt = 'toJsonString';

  return ToJsonString;

})(RDBOp);

Match = (function(superClass) {
  extend(Match, superClass);

  function Match() {
    return Match.__super__.constructor.apply(this, arguments);
  }

  Match.prototype.tt = protoTermType.MATCH;

  Match.prototype.mt = 'match';

  return Match;

})(RDBOp);

Split = (function(superClass) {
  extend(Split, superClass);

  function Split() {
    return Split.__super__.constructor.apply(this, arguments);
  }

  Split.prototype.tt = protoTermType.SPLIT;

  Split.prototype.mt = 'split';

  return Split;

})(RDBOp);

Upcase = (function(superClass) {
  extend(Upcase, superClass);

  function Upcase() {
    return Upcase.__super__.constructor.apply(this, arguments);
  }

  Upcase.prototype.tt = protoTermType.UPCASE;

  Upcase.prototype.mt = 'upcase';

  return Upcase;

})(RDBOp);

Downcase = (function(superClass) {
  extend(Downcase, superClass);

  function Downcase() {
    return Downcase.__super__.constructor.apply(this, arguments);
  }

  Downcase.prototype.tt = protoTermType.DOWNCASE;

  Downcase.prototype.mt = 'downcase';

  return Downcase;

})(RDBOp);

IsEmpty = (function(superClass) {
  extend(IsEmpty, superClass);

  function IsEmpty() {
    return IsEmpty.__super__.constructor.apply(this, arguments);
  }

  IsEmpty.prototype.tt = protoTermType.IS_EMPTY;

  IsEmpty.prototype.mt = 'isEmpty';

  return IsEmpty;

})(RDBOp);

Group = (function(superClass) {
  extend(Group, superClass);

  function Group() {
    return Group.__super__.constructor.apply(this, arguments);
  }

  Group.prototype.tt = protoTermType.GROUP;

  Group.prototype.mt = 'group';

  return Group;

})(RDBOp);

Sum = (function(superClass) {
  extend(Sum, superClass);

  function Sum() {
    return Sum.__super__.constructor.apply(this, arguments);
  }

  Sum.prototype.tt = protoTermType.SUM;

  Sum.prototype.mt = 'sum';

  return Sum;

})(RDBOp);

Avg = (function(superClass) {
  extend(Avg, superClass);

  function Avg() {
    return Avg.__super__.constructor.apply(this, arguments);
  }

  Avg.prototype.tt = protoTermType.AVG;

  Avg.prototype.mt = 'avg';

  return Avg;

})(RDBOp);

Min = (function(superClass) {
  extend(Min, superClass);

  function Min() {
    return Min.__super__.constructor.apply(this, arguments);
  }

  Min.prototype.tt = protoTermType.MIN;

  Min.prototype.mt = 'min';

  return Min;

})(RDBOp);

Max = (function(superClass) {
  extend(Max, superClass);

  function Max() {
    return Max.__super__.constructor.apply(this, arguments);
  }

  Max.prototype.tt = protoTermType.MAX;

  Max.prototype.mt = 'max';

  return Max;

})(RDBOp);

InnerJoin = (function(superClass) {
  extend(InnerJoin, superClass);

  function InnerJoin() {
    return InnerJoin.__super__.constructor.apply(this, arguments);
  }

  InnerJoin.prototype.tt = protoTermType.INNER_JOIN;

  InnerJoin.prototype.mt = 'innerJoin';

  return InnerJoin;

})(RDBOp);

OuterJoin = (function(superClass) {
  extend(OuterJoin, superClass);

  function OuterJoin() {
    return OuterJoin.__super__.constructor.apply(this, arguments);
  }

  OuterJoin.prototype.tt = protoTermType.OUTER_JOIN;

  OuterJoin.prototype.mt = 'outerJoin';

  return OuterJoin;

})(RDBOp);

EqJoin = (function(superClass) {
  extend(EqJoin, superClass);

  function EqJoin() {
    return EqJoin.__super__.constructor.apply(this, arguments);
  }

  EqJoin.prototype.tt = protoTermType.EQ_JOIN;

  EqJoin.prototype.mt = 'eqJoin';

  return EqJoin;

})(RDBOp);

Zip = (function(superClass) {
  extend(Zip, superClass);

  function Zip() {
    return Zip.__super__.constructor.apply(this, arguments);
  }

  Zip.prototype.tt = protoTermType.ZIP;

  Zip.prototype.mt = 'zip';

  return Zip;

})(RDBOp);

Range = (function(superClass) {
  extend(Range, superClass);

  function Range() {
    return Range.__super__.constructor.apply(this, arguments);
  }

  Range.prototype.tt = protoTermType.RANGE;

  Range.prototype.st = 'range';

  return Range;

})(RDBOp);

CoerceTo = (function(superClass) {
  extend(CoerceTo, superClass);

  function CoerceTo() {
    return CoerceTo.__super__.constructor.apply(this, arguments);
  }

  CoerceTo.prototype.tt = protoTermType.COERCE_TO;

  CoerceTo.prototype.mt = 'coerceTo';

  return CoerceTo;

})(RDBOp);

Ungroup = (function(superClass) {
  extend(Ungroup, superClass);

  function Ungroup() {
    return Ungroup.__super__.constructor.apply(this, arguments);
  }

  Ungroup.prototype.tt = protoTermType.UNGROUP;

  Ungroup.prototype.mt = 'ungroup';

  return Ungroup;

})(RDBOp);

TypeOf = (function(superClass) {
  extend(TypeOf, superClass);

  function TypeOf() {
    return TypeOf.__super__.constructor.apply(this, arguments);
  }

  TypeOf.prototype.tt = protoTermType.TYPE_OF;

  TypeOf.prototype.mt = 'typeOf';

  return TypeOf;

})(RDBOp);

Info = (function(superClass) {
  extend(Info, superClass);

  function Info() {
    return Info.__super__.constructor.apply(this, arguments);
  }

  Info.prototype.tt = protoTermType.INFO;

  Info.prototype.mt = 'info';

  return Info;

})(RDBOp);

Sample = (function(superClass) {
  extend(Sample, superClass);

  function Sample() {
    return Sample.__super__.constructor.apply(this, arguments);
  }

  Sample.prototype.tt = protoTermType.SAMPLE;

  Sample.prototype.mt = 'sample';

  return Sample;

})(RDBOp);

Update = (function(superClass) {
  extend(Update, superClass);

  function Update() {
    return Update.__super__.constructor.apply(this, arguments);
  }

  Update.prototype.tt = protoTermType.UPDATE;

  Update.prototype.mt = 'update';

  return Update;

})(RDBOp);

Delete = (function(superClass) {
  extend(Delete, superClass);

  function Delete() {
    return Delete.__super__.constructor.apply(this, arguments);
  }

  Delete.prototype.tt = protoTermType.DELETE;

  Delete.prototype.mt = 'delete';

  return Delete;

})(RDBOp);

Replace = (function(superClass) {
  extend(Replace, superClass);

  function Replace() {
    return Replace.__super__.constructor.apply(this, arguments);
  }

  Replace.prototype.tt = protoTermType.REPLACE;

  Replace.prototype.mt = 'replace';

  return Replace;

})(RDBOp);

Insert = (function(superClass) {
  extend(Insert, superClass);

  function Insert() {
    return Insert.__super__.constructor.apply(this, arguments);
  }

  Insert.prototype.tt = protoTermType.INSERT;

  Insert.prototype.mt = 'insert';

  return Insert;

})(RDBOp);

DbCreate = (function(superClass) {
  extend(DbCreate, superClass);

  function DbCreate() {
    return DbCreate.__super__.constructor.apply(this, arguments);
  }

  DbCreate.prototype.tt = protoTermType.DB_CREATE;

  DbCreate.prototype.st = 'dbCreate';

  return DbCreate;

})(RDBOp);

DbDrop = (function(superClass) {
  extend(DbDrop, superClass);

  function DbDrop() {
    return DbDrop.__super__.constructor.apply(this, arguments);
  }

  DbDrop.prototype.tt = protoTermType.DB_DROP;

  DbDrop.prototype.st = 'dbDrop';

  return DbDrop;

})(RDBOp);

DbList = (function(superClass) {
  extend(DbList, superClass);

  function DbList() {
    return DbList.__super__.constructor.apply(this, arguments);
  }

  DbList.prototype.tt = protoTermType.DB_LIST;

  DbList.prototype.st = 'dbList';

  return DbList;

})(RDBOp);

TableCreate = (function(superClass) {
  extend(TableCreate, superClass);

  function TableCreate() {
    return TableCreate.__super__.constructor.apply(this, arguments);
  }

  TableCreate.prototype.tt = protoTermType.TABLE_CREATE;

  TableCreate.prototype.mt = 'tableCreate';

  return TableCreate;

})(RDBOp);

TableDrop = (function(superClass) {
  extend(TableDrop, superClass);

  function TableDrop() {
    return TableDrop.__super__.constructor.apply(this, arguments);
  }

  TableDrop.prototype.tt = protoTermType.TABLE_DROP;

  TableDrop.prototype.mt = 'tableDrop';

  return TableDrop;

})(RDBOp);

TableList = (function(superClass) {
  extend(TableList, superClass);

  function TableList() {
    return TableList.__super__.constructor.apply(this, arguments);
  }

  TableList.prototype.tt = protoTermType.TABLE_LIST;

  TableList.prototype.mt = 'tableList';

  return TableList;

})(RDBOp);

IndexCreate = (function(superClass) {
  extend(IndexCreate, superClass);

  function IndexCreate() {
    return IndexCreate.__super__.constructor.apply(this, arguments);
  }

  IndexCreate.prototype.tt = protoTermType.INDEX_CREATE;

  IndexCreate.prototype.mt = 'indexCreate';

  return IndexCreate;

})(RDBOp);

IndexDrop = (function(superClass) {
  extend(IndexDrop, superClass);

  function IndexDrop() {
    return IndexDrop.__super__.constructor.apply(this, arguments);
  }

  IndexDrop.prototype.tt = protoTermType.INDEX_DROP;

  IndexDrop.prototype.mt = 'indexDrop';

  return IndexDrop;

})(RDBOp);

IndexRename = (function(superClass) {
  extend(IndexRename, superClass);

  function IndexRename() {
    return IndexRename.__super__.constructor.apply(this, arguments);
  }

  IndexRename.prototype.tt = protoTermType.INDEX_RENAME;

  IndexRename.prototype.mt = 'indexRename';

  return IndexRename;

})(RDBOp);

IndexList = (function(superClass) {
  extend(IndexList, superClass);

  function IndexList() {
    return IndexList.__super__.constructor.apply(this, arguments);
  }

  IndexList.prototype.tt = protoTermType.INDEX_LIST;

  IndexList.prototype.mt = 'indexList';

  return IndexList;

})(RDBOp);

IndexStatus = (function(superClass) {
  extend(IndexStatus, superClass);

  function IndexStatus() {
    return IndexStatus.__super__.constructor.apply(this, arguments);
  }

  IndexStatus.prototype.tt = protoTermType.INDEX_STATUS;

  IndexStatus.prototype.mt = 'indexStatus';

  return IndexStatus;

})(RDBOp);

IndexWait = (function(superClass) {
  extend(IndexWait, superClass);

  function IndexWait() {
    return IndexWait.__super__.constructor.apply(this, arguments);
  }

  IndexWait.prototype.tt = protoTermType.INDEX_WAIT;

  IndexWait.prototype.mt = 'indexWait';

  return IndexWait;

})(RDBOp);

Config = (function(superClass) {
  extend(Config, superClass);

  function Config() {
    return Config.__super__.constructor.apply(this, arguments);
  }

  Config.prototype.tt = protoTermType.CONFIG;

  Config.prototype.mt = 'config';

  return Config;

})(RDBOp);

Status = (function(superClass) {
  extend(Status, superClass);

  function Status() {
    return Status.__super__.constructor.apply(this, arguments);
  }

  Status.prototype.tt = protoTermType.STATUS;

  Status.prototype.mt = 'status';

  return Status;

})(RDBOp);

Wait = (function(superClass) {
  extend(Wait, superClass);

  function Wait() {
    return Wait.__super__.constructor.apply(this, arguments);
  }

  Wait.prototype.tt = protoTermType.WAIT;

  Wait.prototype.mt = 'wait';

  return Wait;

})(RDBOp);

Reconfigure = (function(superClass) {
  extend(Reconfigure, superClass);

  function Reconfigure() {
    return Reconfigure.__super__.constructor.apply(this, arguments);
  }

  Reconfigure.prototype.tt = protoTermType.RECONFIGURE;

  Reconfigure.prototype.mt = 'reconfigure';

  return Reconfigure;

})(RDBOp);

Rebalance = (function(superClass) {
  extend(Rebalance, superClass);

  function Rebalance() {
    return Rebalance.__super__.constructor.apply(this, arguments);
  }

  Rebalance.prototype.tt = protoTermType.REBALANCE;

  Rebalance.prototype.mt = 'rebalance';

  return Rebalance;

})(RDBOp);

Sync = (function(superClass) {
  extend(Sync, superClass);

  function Sync() {
    return Sync.__super__.constructor.apply(this, arguments);
  }

  Sync.prototype.tt = protoTermType.SYNC;

  Sync.prototype.mt = 'sync';

  return Sync;

})(RDBOp);

Grant = (function(superClass) {
  extend(Grant, superClass);

  function Grant() {
    return Grant.__super__.constructor.apply(this, arguments);
  }

  Grant.prototype.tt = protoTermType.GRANT;

  Grant.prototype.mt = 'grant';

  return Grant;

})(RDBOp);

FunCall = (function(superClass) {
  extend(FunCall, superClass);

  function FunCall() {
    return FunCall.__super__.constructor.apply(this, arguments);
  }

  FunCall.prototype.tt = protoTermType.FUNCALL;

  FunCall.prototype.st = 'do';

  FunCall.prototype.compose = function(args) {
    if (args.length > 2) {
      return ['r.do(', intsp(args.slice(1)), ', ', args[0], ')'];
    } else {
      if (shouldWrap(this.args[1])) {
        args[1] = ['r(', args[1], ')'];
      }
      return [args[1], '.do(', args[0], ')'];
    }
  };

  return FunCall;

})(RDBOp);

Default = (function(superClass) {
  extend(Default, superClass);

  function Default() {
    return Default.__super__.constructor.apply(this, arguments);
  }

  Default.prototype.tt = protoTermType.DEFAULT;

  Default.prototype.mt = 'default';

  return Default;

})(RDBOp);

Branch = (function(superClass) {
  extend(Branch, superClass);

  function Branch() {
    return Branch.__super__.constructor.apply(this, arguments);
  }

  Branch.prototype.tt = protoTermType.BRANCH;

  Branch.prototype.st = 'branch';

  return Branch;

})(RDBOp);

Or = (function(superClass) {
  extend(Or, superClass);

  function Or() {
    return Or.__super__.constructor.apply(this, arguments);
  }

  Or.prototype.tt = protoTermType.OR;

  Or.prototype.mt = 'or';

  return Or;

})(RDBOp);

And = (function(superClass) {
  extend(And, superClass);

  function And() {
    return And.__super__.constructor.apply(this, arguments);
  }

  And.prototype.tt = protoTermType.AND;

  And.prototype.mt = 'and';

  return And;

})(RDBOp);

ForEach = (function(superClass) {
  extend(ForEach, superClass);

  function ForEach() {
    return ForEach.__super__.constructor.apply(this, arguments);
  }

  ForEach.prototype.tt = protoTermType.FOR_EACH;

  ForEach.prototype.mt = 'forEach';

  return ForEach;

})(RDBOp);

Func = (function(superClass) {
  extend(Func, superClass);

  Func.prototype.tt = protoTermType.FUNC;

  Func.nextVarId = 0;

  function Func(optargs, func) {
    var argNums, args, argsArr, body, i;
    args = [];
    argNums = [];
    i = 0;
    while (i < func.length) {
      argNums.push(Func.nextVarId);
      args.push(new Var({}, Func.nextVarId));
      Func.nextVarId++;
      i++;
    }
    body = func.apply(null, args);
    if (body === void 0) {
      throw new err.ReqlDriverCompileError("Anonymous function returned `undefined`. Did you forget a `return`?");
    }
    argsArr = (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(MakeArray, [{}].concat(slice.call(argNums)), function(){});
    return Func.__super__.constructor.call(this, optargs, argsArr, body);
  }

  Func.prototype.compose = function(args) {
    var arg, i, j, len, ref, varStr;
    if (hasImplicit(args[1]) === true) {
      return [args[1]];
    } else {
      varStr = "";
      ref = args[0][1];
      for (i = j = 0, len = ref.length; j < len; i = ++j) {
        arg = ref[i];
        if (i % 2 === 0) {
          varStr += Var.prototype.compose(arg);
        } else {
          varStr += arg;
        }
      }
      return ['function(', varStr, ') { return ', args[1], '; }'];
    }
  };

  return Func;

})(RDBOp);

Asc = (function(superClass) {
  extend(Asc, superClass);

  function Asc() {
    return Asc.__super__.constructor.apply(this, arguments);
  }

  Asc.prototype.tt = protoTermType.ASC;

  Asc.prototype.st = 'asc';

  return Asc;

})(RDBOp);

Desc = (function(superClass) {
  extend(Desc, superClass);

  function Desc() {
    return Desc.__super__.constructor.apply(this, arguments);
  }

  Desc.prototype.tt = protoTermType.DESC;

  Desc.prototype.st = 'desc';

  return Desc;

})(RDBOp);

Literal = (function(superClass) {
  extend(Literal, superClass);

  function Literal() {
    return Literal.__super__.constructor.apply(this, arguments);
  }

  Literal.prototype.tt = protoTermType.LITERAL;

  Literal.prototype.st = 'literal';

  return Literal;

})(RDBOp);

ISO8601 = (function(superClass) {
  extend(ISO8601, superClass);

  function ISO8601() {
    return ISO8601.__super__.constructor.apply(this, arguments);
  }

  ISO8601.prototype.tt = protoTermType.ISO8601;

  ISO8601.prototype.st = 'ISO8601';

  return ISO8601;

})(RDBOp);

ToISO8601 = (function(superClass) {
  extend(ToISO8601, superClass);

  function ToISO8601() {
    return ToISO8601.__super__.constructor.apply(this, arguments);
  }

  ToISO8601.prototype.tt = protoTermType.TO_ISO8601;

  ToISO8601.prototype.mt = 'toISO8601';

  return ToISO8601;

})(RDBOp);

EpochTime = (function(superClass) {
  extend(EpochTime, superClass);

  function EpochTime() {
    return EpochTime.__super__.constructor.apply(this, arguments);
  }

  EpochTime.prototype.tt = protoTermType.EPOCH_TIME;

  EpochTime.prototype.st = 'epochTime';

  return EpochTime;

})(RDBOp);

ToEpochTime = (function(superClass) {
  extend(ToEpochTime, superClass);

  function ToEpochTime() {
    return ToEpochTime.__super__.constructor.apply(this, arguments);
  }

  ToEpochTime.prototype.tt = protoTermType.TO_EPOCH_TIME;

  ToEpochTime.prototype.mt = 'toEpochTime';

  return ToEpochTime;

})(RDBOp);

Now = (function(superClass) {
  extend(Now, superClass);

  function Now() {
    return Now.__super__.constructor.apply(this, arguments);
  }

  Now.prototype.tt = protoTermType.NOW;

  Now.prototype.st = 'now';

  return Now;

})(RDBOp);

InTimezone = (function(superClass) {
  extend(InTimezone, superClass);

  function InTimezone() {
    return InTimezone.__super__.constructor.apply(this, arguments);
  }

  InTimezone.prototype.tt = protoTermType.IN_TIMEZONE;

  InTimezone.prototype.mt = 'inTimezone';

  return InTimezone;

})(RDBOp);

During = (function(superClass) {
  extend(During, superClass);

  function During() {
    return During.__super__.constructor.apply(this, arguments);
  }

  During.prototype.tt = protoTermType.DURING;

  During.prototype.mt = 'during';

  return During;

})(RDBOp);

RQLDate = (function(superClass) {
  extend(RQLDate, superClass);

  function RQLDate() {
    return RQLDate.__super__.constructor.apply(this, arguments);
  }

  RQLDate.prototype.tt = protoTermType.DATE;

  RQLDate.prototype.mt = 'date';

  return RQLDate;

})(RDBOp);

TimeOfDay = (function(superClass) {
  extend(TimeOfDay, superClass);

  function TimeOfDay() {
    return TimeOfDay.__super__.constructor.apply(this, arguments);
  }

  TimeOfDay.prototype.tt = protoTermType.TIME_OF_DAY;

  TimeOfDay.prototype.mt = 'timeOfDay';

  return TimeOfDay;

})(RDBOp);

Timezone = (function(superClass) {
  extend(Timezone, superClass);

  function Timezone() {
    return Timezone.__super__.constructor.apply(this, arguments);
  }

  Timezone.prototype.tt = protoTermType.TIMEZONE;

  Timezone.prototype.mt = 'timezone';

  return Timezone;

})(RDBOp);

Year = (function(superClass) {
  extend(Year, superClass);

  function Year() {
    return Year.__super__.constructor.apply(this, arguments);
  }

  Year.prototype.tt = protoTermType.YEAR;

  Year.prototype.mt = 'year';

  return Year;

})(RDBOp);

Month = (function(superClass) {
  extend(Month, superClass);

  function Month() {
    return Month.__super__.constructor.apply(this, arguments);
  }

  Month.prototype.tt = protoTermType.MONTH;

  Month.prototype.mt = 'month';

  return Month;

})(RDBOp);

Day = (function(superClass) {
  extend(Day, superClass);

  function Day() {
    return Day.__super__.constructor.apply(this, arguments);
  }

  Day.prototype.tt = protoTermType.DAY;

  Day.prototype.mt = 'day';

  return Day;

})(RDBOp);

DayOfWeek = (function(superClass) {
  extend(DayOfWeek, superClass);

  function DayOfWeek() {
    return DayOfWeek.__super__.constructor.apply(this, arguments);
  }

  DayOfWeek.prototype.tt = protoTermType.DAY_OF_WEEK;

  DayOfWeek.prototype.mt = 'dayOfWeek';

  return DayOfWeek;

})(RDBOp);

DayOfYear = (function(superClass) {
  extend(DayOfYear, superClass);

  function DayOfYear() {
    return DayOfYear.__super__.constructor.apply(this, arguments);
  }

  DayOfYear.prototype.tt = protoTermType.DAY_OF_YEAR;

  DayOfYear.prototype.mt = 'dayOfYear';

  return DayOfYear;

})(RDBOp);

Hours = (function(superClass) {
  extend(Hours, superClass);

  function Hours() {
    return Hours.__super__.constructor.apply(this, arguments);
  }

  Hours.prototype.tt = protoTermType.HOURS;

  Hours.prototype.mt = 'hours';

  return Hours;

})(RDBOp);

Minutes = (function(superClass) {
  extend(Minutes, superClass);

  function Minutes() {
    return Minutes.__super__.constructor.apply(this, arguments);
  }

  Minutes.prototype.tt = protoTermType.MINUTES;

  Minutes.prototype.mt = 'minutes';

  return Minutes;

})(RDBOp);

Seconds = (function(superClass) {
  extend(Seconds, superClass);

  function Seconds() {
    return Seconds.__super__.constructor.apply(this, arguments);
  }

  Seconds.prototype.tt = protoTermType.SECONDS;

  Seconds.prototype.mt = 'seconds';

  return Seconds;

})(RDBOp);

Time = (function(superClass) {
  extend(Time, superClass);

  function Time() {
    return Time.__super__.constructor.apply(this, arguments);
  }

  Time.prototype.tt = protoTermType.TIME;

  Time.prototype.st = 'time';

  return Time;

})(RDBOp);

Geojson = (function(superClass) {
  extend(Geojson, superClass);

  function Geojson() {
    return Geojson.__super__.constructor.apply(this, arguments);
  }

  Geojson.prototype.tt = protoTermType.GEOJSON;

  Geojson.prototype.st = 'geojson';

  return Geojson;

})(RDBOp);

ToGeojson = (function(superClass) {
  extend(ToGeojson, superClass);

  function ToGeojson() {
    return ToGeojson.__super__.constructor.apply(this, arguments);
  }

  ToGeojson.prototype.tt = protoTermType.TO_GEOJSON;

  ToGeojson.prototype.mt = 'toGeojson';

  return ToGeojson;

})(RDBOp);

Point = (function(superClass) {
  extend(Point, superClass);

  function Point() {
    return Point.__super__.constructor.apply(this, arguments);
  }

  Point.prototype.tt = protoTermType.POINT;

  Point.prototype.st = 'point';

  return Point;

})(RDBOp);

Line = (function(superClass) {
  extend(Line, superClass);

  function Line() {
    return Line.__super__.constructor.apply(this, arguments);
  }

  Line.prototype.tt = protoTermType.LINE;

  Line.prototype.st = 'line';

  return Line;

})(RDBOp);

Polygon = (function(superClass) {
  extend(Polygon, superClass);

  function Polygon() {
    return Polygon.__super__.constructor.apply(this, arguments);
  }

  Polygon.prototype.tt = protoTermType.POLYGON;

  Polygon.prototype.st = 'polygon';

  return Polygon;

})(RDBOp);

Distance = (function(superClass) {
  extend(Distance, superClass);

  function Distance() {
    return Distance.__super__.constructor.apply(this, arguments);
  }

  Distance.prototype.tt = protoTermType.DISTANCE;

  Distance.prototype.mt = 'distance';

  return Distance;

})(RDBOp);

Intersects = (function(superClass) {
  extend(Intersects, superClass);

  function Intersects() {
    return Intersects.__super__.constructor.apply(this, arguments);
  }

  Intersects.prototype.tt = protoTermType.INTERSECTS;

  Intersects.prototype.mt = 'intersects';

  return Intersects;

})(RDBOp);

Includes = (function(superClass) {
  extend(Includes, superClass);

  function Includes() {
    return Includes.__super__.constructor.apply(this, arguments);
  }

  Includes.prototype.tt = protoTermType.INCLUDES;

  Includes.prototype.mt = 'includes';

  return Includes;

})(RDBOp);

Circle = (function(superClass) {
  extend(Circle, superClass);

  function Circle() {
    return Circle.__super__.constructor.apply(this, arguments);
  }

  Circle.prototype.tt = protoTermType.CIRCLE;

  Circle.prototype.st = 'circle';

  return Circle;

})(RDBOp);

GetIntersecting = (function(superClass) {
  extend(GetIntersecting, superClass);

  function GetIntersecting() {
    return GetIntersecting.__super__.constructor.apply(this, arguments);
  }

  GetIntersecting.prototype.tt = protoTermType.GET_INTERSECTING;

  GetIntersecting.prototype.mt = 'getIntersecting';

  return GetIntersecting;

})(RDBOp);

GetNearest = (function(superClass) {
  extend(GetNearest, superClass);

  function GetNearest() {
    return GetNearest.__super__.constructor.apply(this, arguments);
  }

  GetNearest.prototype.tt = protoTermType.GET_NEAREST;

  GetNearest.prototype.mt = 'getNearest';

  return GetNearest;

})(RDBOp);

Fill = (function(superClass) {
  extend(Fill, superClass);

  function Fill() {
    return Fill.__super__.constructor.apply(this, arguments);
  }

  Fill.prototype.tt = protoTermType.FILL;

  Fill.prototype.mt = 'fill';

  return Fill;

})(RDBOp);

PolygonSub = (function(superClass) {
  extend(PolygonSub, superClass);

  function PolygonSub() {
    return PolygonSub.__super__.constructor.apply(this, arguments);
  }

  PolygonSub.prototype.tt = protoTermType.POLYGON_SUB;

  PolygonSub.prototype.mt = 'polygonSub';

  return PolygonSub;

})(RDBOp);

UUID = (function(superClass) {
  extend(UUID, superClass);

  function UUID() {
    return UUID.__super__.constructor.apply(this, arguments);
  }

  UUID.prototype.tt = protoTermType.UUID;

  UUID.prototype.st = 'uuid';

  return UUID;

})(RDBOp);

rethinkdb.expr = varar(1, 2, function(val, nestingDepth) {
  var v;
  if (nestingDepth == null) {
    nestingDepth = 20;
  }
  if (val === void 0) {
    throw new err.ReqlDriverCompileError("Cannot wrap undefined with r.expr().");
  }
  if (nestingDepth <= 0) {
    throw new err.ReqlDriverCompileError("Nesting depth limit exceeded.");
  }
  if (typeof nestingDepth !== "number" || isNaN(nestingDepth)) {
    throw new err.ReqlDriverCompileError("Second argument to `r.expr` must be a number or undefined.");
  } else if (val instanceof TermBase) {
    return val;
  } else if (typeof val === 'function') {
    return new Func({}, val);
  } else if (val instanceof Date) {
    return new ISO8601({}, val.toISOString());
  } else if (val instanceof Buffer) {
    return new Binary(val);
  } else if (Array.isArray(val)) {
    val = (function() {
      var j, len, results;
      results = [];
      for (j = 0, len = val.length; j < len; j++) {
        v = val[j];
        results.push(rethinkdb.expr(v, nestingDepth - 1));
      }
      return results;
    })();
    return (function(func, args, ctor) {
      ctor.prototype = func.prototype;
      var child = new ctor, result = func.apply(child, args);
      return Object(result) === result ? result : child;
    })(MakeArray, [{}].concat(slice.call(val)), function(){});
  } else if (typeof val === 'number') {
    return new DatumTerm(val);
  } else if (Object.prototype.toString.call(val) === '[object Object]') {
    return new MakeObject(val, nestingDepth);
  } else {
    return new DatumTerm(val);
  }
});

rethinkdb.js = aropt(function(jssrc, opts) {
  return new JavaScript(opts, jssrc);
});

rethinkdb.http = aropt(function(url, opts) {
  return new Http(opts, url);
});

rethinkdb.json = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Json, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.error = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(UserError, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.random = function() {
  var limits, limitsAndOpts, opts, perhapsOptDict;
  limitsAndOpts = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  opts = {};
  limits = limitsAndOpts;
  perhapsOptDict = limitsAndOpts[limitsAndOpts.length - 1];
  if (perhapsOptDict && ((Object.prototype.toString.call(perhapsOptDict) === '[object Object]') && !(perhapsOptDict instanceof TermBase))) {
    opts = perhapsOptDict;
    limits = limitsAndOpts.slice(0, limitsAndOpts.length - 1);
  }
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Random, [opts].concat(slice.call(limits)), function(){});
};

rethinkdb.binary = ar(function(data) {
  return new Binary(data);
});

rethinkdb.row = new ImplicitVar({});

rethinkdb.table = aropt(function(tblName, opts) {
  return new Table(opts, tblName);
});

rethinkdb.db = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Db, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.dbCreate = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(DbCreate, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.dbDrop = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(DbDrop, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.dbList = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(DbList, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.tableCreate = aropt(function(tblName, opts) {
  return new TableCreate(opts, tblName);
});

rethinkdb.tableDrop = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(TableDrop, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.tableList = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(TableList, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.grant = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Grant, [{}].concat(slice.call(args)), function(){});
};

rethinkdb["do"] = varar(1, null, function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(FunCall, [{}, funcWrap(args.slice(-1)[0])].concat(slice.call(args.slice(0, -1))), function(){});
});

rethinkdb.branch = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Branch, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.map = varar(1, null, function() {
  var args, funcArg, j;
  args = 2 <= arguments.length ? slice.call(arguments, 0, j = arguments.length - 1) : (j = 0, []), funcArg = arguments[j++];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Map, [{}].concat(slice.call(args), [funcWrap(funcArg)]), function(){});
});

rethinkdb.group = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Group, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.reduce = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Reduce, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.count = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Count, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.sum = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Sum, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.avg = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Avg, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.min = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Min, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.max = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Max, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.distinct = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Distinct, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.contains = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Contains, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.asc = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Asc, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.desc = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Desc, [{}].concat(slice.call(args.map(funcWrap))), function(){});
};

rethinkdb.eq = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Eq, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.ne = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Ne, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.lt = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Lt, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.le = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Le, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.gt = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Gt, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.ge = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Ge, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.or = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Or, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.and = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(And, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.not = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Not, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.add = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Add, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.sub = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Sub, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.div = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Div, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.mul = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Mul, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.mod = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Mod, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.floor = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Floor, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.ceil = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Ceil, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.round = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Round, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.typeOf = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(TypeOf, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.info = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Info, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.literal = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Literal, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.ISO8601 = aropt(function(str, opts) {
  return new ISO8601(opts, str);
});

rethinkdb.epochTime = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(EpochTime, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.now = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Now, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.time = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Time, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.monday = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.MONDAY;

  _Class.prototype.st = 'monday';

  return _Class;

})(RDBConstant))();

rethinkdb.tuesday = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.TUESDAY;

  _Class.prototype.st = 'tuesday';

  return _Class;

})(RDBConstant))();

rethinkdb.wednesday = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.WEDNESDAY;

  _Class.prototype.st = 'wednesday';

  return _Class;

})(RDBConstant))();

rethinkdb.thursday = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.THURSDAY;

  _Class.prototype.st = 'thursday';

  return _Class;

})(RDBConstant))();

rethinkdb.friday = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.FRIDAY;

  _Class.prototype.st = 'friday';

  return _Class;

})(RDBConstant))();

rethinkdb.saturday = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.SATURDAY;

  _Class.prototype.st = 'saturday';

  return _Class;

})(RDBConstant))();

rethinkdb.sunday = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.SUNDAY;

  _Class.prototype.st = 'sunday';

  return _Class;

})(RDBConstant))();

rethinkdb.january = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.JANUARY;

  _Class.prototype.st = 'january';

  return _Class;

})(RDBConstant))();

rethinkdb.february = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.FEBRUARY;

  _Class.prototype.st = 'february';

  return _Class;

})(RDBConstant))();

rethinkdb.march = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.MARCH;

  _Class.prototype.st = 'march';

  return _Class;

})(RDBConstant))();

rethinkdb.april = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.APRIL;

  _Class.prototype.st = 'april';

  return _Class;

})(RDBConstant))();

rethinkdb.may = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.MAY;

  _Class.prototype.st = 'may';

  return _Class;

})(RDBConstant))();

rethinkdb.june = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.JUNE;

  _Class.prototype.st = 'june';

  return _Class;

})(RDBConstant))();

rethinkdb.july = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.JULY;

  _Class.prototype.st = 'july';

  return _Class;

})(RDBConstant))();

rethinkdb.august = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.AUGUST;

  _Class.prototype.st = 'august';

  return _Class;

})(RDBConstant))();

rethinkdb.september = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.SEPTEMBER;

  _Class.prototype.st = 'september';

  return _Class;

})(RDBConstant))();

rethinkdb.october = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.OCTOBER;

  _Class.prototype.st = 'october';

  return _Class;

})(RDBConstant))();

rethinkdb.november = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.NOVEMBER;

  _Class.prototype.st = 'november';

  return _Class;

})(RDBConstant))();

rethinkdb.december = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.DECEMBER;

  _Class.prototype.st = 'december';

  return _Class;

})(RDBConstant))();

rethinkdb.minval = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.MINVAL;

  _Class.prototype.st = 'minval';

  return _Class;

})(RDBConstant))();

rethinkdb.maxval = new ((function(superClass) {
  extend(_Class, superClass);

  function _Class() {
    return _Class.__super__.constructor.apply(this, arguments);
  }

  _Class.prototype.tt = protoTermType.MAXVAL;

  _Class.prototype.st = 'maxval';

  return _Class;

})(RDBConstant))();

rethinkdb.object = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Object_, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.args = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Args, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.geojson = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Geojson, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.point = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Point, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.line = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Line, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.polygon = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Polygon, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.intersects = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Intersects, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.distance = aropt(function(g1, g2, opts) {
  return new Distance(opts, g1, g2);
});

rethinkdb.circle = aropt(function(cen, rad, opts) {
  return new Circle(opts, cen, rad);
});

rethinkdb.uuid = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(UUID, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.range = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Range, [{}].concat(slice.call(args)), function(){});
};

rethinkdb.union = function() {
  var args;
  args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
  return (function(func, args, ctor) {
    ctor.prototype = func.prototype;
    var child = new ctor, result = func.apply(child, args);
    return Object(result) === result ? result : child;
  })(Union, [{}].concat(slice.call(args)), function(){});
};

module.exports = rethinkdb;