@loaders.gl/schema 3.1.0-alpha.4 → 3.1.0-alpha.5

package/dist/es5/lib/schema/impl/type.js

@@ -7,586 +7,375 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "Type", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _enum.Type;
   }
 });
 exports.Struct = exports.FixedSizeList = exports.IntervalYearMonth = exports.IntervalDayTime = exports.Interval = exports.TimestampNanosecond = exports.TimestampMicrosecond = exports.TimestampMillisecond = exports.TimestampSecond = exports.Timestamp = exports.TimeMillisecond = exports.TimeSecond = exports.Time = exports.DateMillisecond = exports.DateDay = exports.Date = exports.Utf8 = exports.Binary = exports.Float64 = exports.Float32 = exports.Float16 = exports.Float = exports.Uint64 = exports.Uint32 = exports.Uint16 = exports.Uint8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int8 = exports.Int = exports.Bool = exports.Null = exports.DataType = void 0;
 
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _enum = require("./enum");
 
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+let _Symbol$toStringTag, _Symbol$toStringTag2, _Symbol$toStringTag3, _Symbol$toStringTag4, _Symbol$toStringTag5, _Symbol$toStringTag6, _Symbol$toStringTag7, _Symbol$toStringTag8;
 
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+class DataType {
+  static isNull(x) {
+    return x && x.typeId === _enum.Type.Null;
+  }
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+  static isInt(x) {
+    return x && x.typeId === _enum.Type.Int;
+  }
 
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+  static isFloat(x) {
+    return x && x.typeId === _enum.Type.Float;
+  }
 
-var _enum = require("./enum");
+  static isBinary(x) {
+    return x && x.typeId === _enum.Type.Binary;
+  }
 
-var _Symbol$toStringTag, _Symbol$toStringTag2, _Symbol$toStringTag3, _Symbol$toStringTag4, _Symbol$toStringTag5, _Symbol$toStringTag6, _Symbol$toStringTag7, _Symbol$toStringTag8;
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
-var DataType = function () {
-  function DataType() {
-    (0, _classCallCheck2.default)(this, DataType);
-  }
-
-  (0, _createClass2.default)(DataType, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.NONE;
-    }
-  }, {
-    key: "compareTo",
-    value: function compareTo(other) {
-      return this === other;
-    }
-  }], [{
-    key: "isNull",
-    value: function isNull(x) {
-      return x && x.typeId === _enum.Type.Null;
-    }
-  }, {
-    key: "isInt",
-    value: function isInt(x) {
-      return x && x.typeId === _enum.Type.Int;
-    }
-  }, {
-    key: "isFloat",
-    value: function isFloat(x) {
-      return x && x.typeId === _enum.Type.Float;
-    }
-  }, {
-    key: "isBinary",
-    value: function isBinary(x) {
-      return x && x.typeId === _enum.Type.Binary;
-    }
-  }, {
-    key: "isUtf8",
-    value: function isUtf8(x) {
-      return x && x.typeId === _enum.Type.Utf8;
-    }
-  }, {
-    key: "isBool",
-    value: function isBool(x) {
-      return x && x.typeId === _enum.Type.Bool;
-    }
-  }, {
-    key: "isDecimal",
-    value: function isDecimal(x) {
-      return x && x.typeId === _enum.Type.Decimal;
-    }
-  }, {
-    key: "isDate",
-    value: function isDate(x) {
-      return x && x.typeId === _enum.Type.Date;
-    }
-  }, {
-    key: "isTime",
-    value: function isTime(x) {
-      return x && x.typeId === _enum.Type.Time;
-    }
-  }, {
-    key: "isTimestamp",
-    value: function isTimestamp(x) {
-      return x && x.typeId === _enum.Type.Timestamp;
-    }
-  }, {
-    key: "isInterval",
-    value: function isInterval(x) {
-      return x && x.typeId === _enum.Type.Interval;
-    }
-  }, {
-    key: "isList",
-    value: function isList(x) {
-      return x && x.typeId === _enum.Type.List;
-    }
-  }, {
-    key: "isStruct",
-    value: function isStruct(x) {
-      return x && x.typeId === _enum.Type.Struct;
-    }
-  }, {
-    key: "isUnion",
-    value: function isUnion(x) {
-      return x && x.typeId === _enum.Type.Union;
-    }
-  }, {
-    key: "isFixedSizeBinary",
-    value: function isFixedSizeBinary(x) {
-      return x && x.typeId === _enum.Type.FixedSizeBinary;
-    }
-  }, {
-    key: "isFixedSizeList",
-    value: function isFixedSizeList(x) {
-      return x && x.typeId === _enum.Type.FixedSizeList;
-    }
-  }, {
-    key: "isMap",
-    value: function isMap(x) {
-      return x && x.typeId === _enum.Type.Map;
-    }
-  }, {
-    key: "isDictionary",
-    value: function isDictionary(x) {
-      return x && x.typeId === _enum.Type.Dictionary;
-    }
-  }]);
-  return DataType;
-}();
+  static isUtf8(x) {
+    return x && x.typeId === _enum.Type.Utf8;
+  }
 
-exports.DataType = DataType;
+  static isBool(x) {
+    return x && x.typeId === _enum.Type.Bool;
+  }
 
-var Null = function (_DataType) {
-  (0, _inherits2.default)(Null, _DataType);
-
-  var _super = _createSuper(Null);
-
-  function Null() {
-    (0, _classCallCheck2.default)(this, Null);
-    return _super.apply(this, arguments);
-  }
-
-  (0, _createClass2.default)(Null, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Null;
-    }
-  }, {
-    key: Symbol.toStringTag,
-    get: function get() {
-      return 'Null';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return 'Null';
-    }
-  }]);
-  return Null;
-}(DataType);
+  static isDecimal(x) {
+    return x && x.typeId === _enum.Type.Decimal;
+  }
 
-exports.Null = Null;
+  static isDate(x) {
+    return x && x.typeId === _enum.Type.Date;
+  }
 
-var Bool = function (_DataType2) {
-  (0, _inherits2.default)(Bool, _DataType2);
-
-  var _super2 = _createSuper(Bool);
-
-  function Bool() {
-    (0, _classCallCheck2.default)(this, Bool);
-    return _super2.apply(this, arguments);
-  }
-
-  (0, _createClass2.default)(Bool, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Bool;
-    }
-  }, {
-    key: Symbol.toStringTag,
-    get: function get() {
-      return 'Bool';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return 'Bool';
-    }
-  }]);
-  return Bool;
-}(DataType);
+  static isTime(x) {
+    return x && x.typeId === _enum.Type.Time;
+  }
 
-exports.Bool = Bool;
-_Symbol$toStringTag = Symbol.toStringTag;
+  static isTimestamp(x) {
+    return x && x.typeId === _enum.Type.Timestamp;
+  }
 
-var Int = function (_DataType3) {
-  (0, _inherits2.default)(Int, _DataType3);
-
-  var _super3 = _createSuper(Int);
-
-  function Int(isSigned, bitWidth) {
-    var _this;
-
-    (0, _classCallCheck2.default)(this, Int);
-    _this = _super3.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isSigned", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "bitWidth", void 0);
-    _this.isSigned = isSigned;
-    _this.bitWidth = bitWidth;
-    return _this;
-  }
-
-  (0, _createClass2.default)(Int, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Int;
-    }
-  }, {
-    key: _Symbol$toStringTag,
-    get: function get() {
-      return 'Int';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "".concat(this.isSigned ? 'I' : 'Ui', "nt").concat(this.bitWidth);
-    }
-  }]);
-  return Int;
-}(DataType);
+  static isInterval(x) {
+    return x && x.typeId === _enum.Type.Interval;
+  }
 
-exports.Int = Int;
+  static isList(x) {
+    return x && x.typeId === _enum.Type.List;
+  }
 
-var Int8 = function (_Int) {
-  (0, _inherits2.default)(Int8, _Int);
+  static isStruct(x) {
+    return x && x.typeId === _enum.Type.Struct;
+  }
 
-  var _super4 = _createSuper(Int8);
+  static isUnion(x) {
+    return x && x.typeId === _enum.Type.Union;
+  }
 
-  function Int8() {
-    (0, _classCallCheck2.default)(this, Int8);
-    return _super4.call(this, true, 8);
+  static isFixedSizeBinary(x) {
+    return x && x.typeId === _enum.Type.FixedSizeBinary;
   }
 
-  return Int8;
-}(Int);
+  static isFixedSizeList(x) {
+    return x && x.typeId === _enum.Type.FixedSizeList;
+  }
 
-exports.Int8 = Int8;
+  static isMap(x) {
+    return x && x.typeId === _enum.Type.Map;
+  }
 
-var Int16 = function (_Int2) {
-  (0, _inherits2.default)(Int16, _Int2);
+  static isDictionary(x) {
+    return x && x.typeId === _enum.Type.Dictionary;
+  }
 
-  var _super5 = _createSuper(Int16);
+  get typeId() {
+    return _enum.Type.NONE;
+  }
 
-  function Int16() {
-    (0, _classCallCheck2.default)(this, Int16);
-    return _super5.call(this, true, 16);
+  compareTo(other) {
+    return this === other;
   }
 
-  return Int16;
-}(Int);
+}
 
-exports.Int16 = Int16;
+exports.DataType = DataType;
 
-var Int32 = function (_Int3) {
-  (0, _inherits2.default)(Int32, _Int3);
+class Null extends DataType {
+  get typeId() {
+    return _enum.Type.Null;
+  }
 
-  var _super6 = _createSuper(Int32);
+  get [Symbol.toStringTag]() {
+    return 'Null';
+  }
 
-  function Int32() {
-    (0, _classCallCheck2.default)(this, Int32);
-    return _super6.call(this, true, 32);
+  toString() {
+    return 'Null';
   }
 
-  return Int32;
-}(Int);
+}
 
-exports.Int32 = Int32;
+exports.Null = Null;
 
-var Int64 = function (_Int4) {
-  (0, _inherits2.default)(Int64, _Int4);
+class Bool extends DataType {
+  get typeId() {
+    return _enum.Type.Bool;
+  }
 
-  var _super7 = _createSuper(Int64);
+  get [Symbol.toStringTag]() {
+    return 'Bool';
+  }
 
-  function Int64() {
-    (0, _classCallCheck2.default)(this, Int64);
-    return _super7.call(this, true, 64);
+  toString() {
+    return 'Bool';
   }
 
-  return Int64;
-}(Int);
+}
 
-exports.Int64 = Int64;
+exports.Bool = Bool;
+_Symbol$toStringTag = Symbol.toStringTag;
+
+class Int extends DataType {
+  constructor(isSigned, bitWidth) {
+    super();
+    (0, _defineProperty2.default)(this, "isSigned", void 0);
+    (0, _defineProperty2.default)(this, "bitWidth", void 0);
+    this.isSigned = isSigned;
+    this.bitWidth = bitWidth;
+  }
 
-var Uint8 = function (_Int5) {
-  (0, _inherits2.default)(Uint8, _Int5);
+  get typeId() {
+    return _enum.Type.Int;
+  }
 
-  var _super8 = _createSuper(Uint8);
+  get [_Symbol$toStringTag]() {
+    return 'Int';
+  }
 
-  function Uint8() {
-    (0, _classCallCheck2.default)(this, Uint8);
-    return _super8.call(this, false, 8);
+  toString() {
+    return "".concat(this.isSigned ? 'I' : 'Ui', "nt").concat(this.bitWidth);
   }
 
-  return Uint8;
-}(Int);
+}
 
-exports.Uint8 = Uint8;
+exports.Int = Int;
 
-var Uint16 = function (_Int6) {
-  (0, _inherits2.default)(Uint16, _Int6);
+class Int8 extends Int {
+  constructor() {
+    super(true, 8);
+  }
+
+}
 
-  var _super9 = _createSuper(Uint16);
+exports.Int8 = Int8;
 
-  function Uint16() {
-    (0, _classCallCheck2.default)(this, Uint16);
-    return _super9.call(this, false, 16);
+class Int16 extends Int {
+  constructor() {
+    super(true, 16);
   }
 
-  return Uint16;
-}(Int);
+}
 
-exports.Uint16 = Uint16;
+exports.Int16 = Int16;
 
-var Uint32 = function (_Int7) {
-  (0, _inherits2.default)(Uint32, _Int7);
+class Int32 extends Int {
+  constructor() {
+    super(true, 32);
+  }
+
+}
 
-  var _super10 = _createSuper(Uint32);
+exports.Int32 = Int32;
 
-  function Uint32() {
-    (0, _classCallCheck2.default)(this, Uint32);
-    return _super10.call(this, false, 32);
+class Int64 extends Int {
+  constructor() {
+    super(true, 64);
   }
 
-  return Uint32;
-}(Int);
+}
 
-exports.Uint32 = Uint32;
+exports.Int64 = Int64;
 
-var Uint64 = function (_Int8) {
-  (0, _inherits2.default)(Uint64, _Int8);
+class Uint8 extends Int {
+  constructor() {
+    super(false, 8);
+  }
+
+}
 
-  var _super11 = _createSuper(Uint64);
+exports.Uint8 = Uint8;
 
-  function Uint64() {
-    (0, _classCallCheck2.default)(this, Uint64);
-    return _super11.call(this, false, 64);
+class Uint16 extends Int {
+  constructor() {
+    super(false, 16);
   }
 
-  return Uint64;
-}(Int);
+}
+
+exports.Uint16 = Uint16;
+
+class Uint32 extends Int {
+  constructor() {
+    super(false, 32);
+  }
+
+}
+
+exports.Uint32 = Uint32;
+
+class Uint64 extends Int {
+  constructor() {
+    super(false, 64);
+  }
+
+}
 
 exports.Uint64 = Uint64;
-var Precision = {
+const Precision = {
   HALF: 16,
   SINGLE: 32,
   DOUBLE: 64
 };
 _Symbol$toStringTag2 = Symbol.toStringTag;
 
-var Float = function (_DataType4) {
-  (0, _inherits2.default)(Float, _DataType4);
-
-  var _super12 = _createSuper(Float);
-
-  function Float(precision) {
-    var _this2;
-
-    (0, _classCallCheck2.default)(this, Float);
-    _this2 = _super12.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "precision", void 0);
-    _this2.precision = precision;
-    return _this2;
-  }
-
-  (0, _createClass2.default)(Float, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Float;
-    }
-  }, {
-    key: _Symbol$toStringTag2,
-    get: function get() {
-      return 'Float';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "Float".concat(this.precision);
-    }
-  }]);
-  return Float;
-}(DataType);
-
-exports.Float = Float;
+class Float extends DataType {
+  constructor(precision) {
+    super();
+    (0, _defineProperty2.default)(this, "precision", void 0);
+    this.precision = precision;
+  }
 
-var Float16 = function (_Float) {
-  (0, _inherits2.default)(Float16, _Float);
+  get typeId() {
+    return _enum.Type.Float;
+  }
 
-  var _super13 = _createSuper(Float16);
+  get [_Symbol$toStringTag2]() {
+    return 'Float';
+  }
 
-  function Float16() {
-    (0, _classCallCheck2.default)(this, Float16);
-    return _super13.call(this, Precision.HALF);
+  toString() {
+    return "Float".concat(this.precision);
   }
 
-  return Float16;
-}(Float);
+}
 
-exports.Float16 = Float16;
+exports.Float = Float;
 
-var Float32 = function (_Float2) {
-  (0, _inherits2.default)(Float32, _Float2);
+class Float16 extends Float {
+  constructor() {
+    super(Precision.HALF);
+  }
+
+}
 
-  var _super14 = _createSuper(Float32);
+exports.Float16 = Float16;
 
-  function Float32() {
-    (0, _classCallCheck2.default)(this, Float32);
-    return _super14.call(this, Precision.SINGLE);
+class Float32 extends Float {
+  constructor() {
+    super(Precision.SINGLE);
   }
 
-  return Float32;
-}(Float);
+}
 
 exports.Float32 = Float32;
 
-var Float64 = function (_Float3) {
-  (0, _inherits2.default)(Float64, _Float3);
+class Float64 extends Float {
+  constructor() {
+    super(Precision.DOUBLE);
+  }
 
-  var _super15 = _createSuper(Float64);
+}
 
-  function Float64() {
-    (0, _classCallCheck2.default)(this, Float64);
-    return _super15.call(this, Precision.DOUBLE);
+exports.Float64 = Float64;
+
+class Binary extends DataType {
+  constructor() {
+    super();
   }
 
-  return Float64;
-}(Float);
+  get typeId() {
+    return _enum.Type.Binary;
+  }
 
-exports.Float64 = Float64;
+  toString() {
+    return 'Binary';
+  }
 
-var Binary = function (_DataType5) {
-  (0, _inherits2.default)(Binary, _DataType5);
-
-  var _super16 = _createSuper(Binary);
-
-  function Binary() {
-    (0, _classCallCheck2.default)(this, Binary);
-    return _super16.call(this);
-  }
-
-  (0, _createClass2.default)(Binary, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Binary;
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return 'Binary';
-    }
-  }, {
-    key: Symbol.toStringTag,
-    get: function get() {
-      return 'Binary';
-    }
-  }]);
-  return Binary;
-}(DataType);
+  get [Symbol.toStringTag]() {
+    return 'Binary';
+  }
+
+}
 
 exports.Binary = Binary;
 
-var Utf8 = function (_DataType6) {
-  (0, _inherits2.default)(Utf8, _DataType6);
-
-  var _super17 = _createSuper(Utf8);
-
-  function Utf8() {
-    (0, _classCallCheck2.default)(this, Utf8);
-    return _super17.apply(this, arguments);
-  }
-
-  (0, _createClass2.default)(Utf8, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Utf8;
-    }
-  }, {
-    key: Symbol.toStringTag,
-    get: function get() {
-      return 'Utf8';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return 'Utf8';
-    }
-  }]);
-  return Utf8;
-}(DataType);
+class Utf8 extends DataType {
+  get typeId() {
+    return _enum.Type.Utf8;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Utf8';
+  }
+
+  toString() {
+    return 'Utf8';
+  }
+
+}
 
 exports.Utf8 = Utf8;
-var DateUnit = {
+const DateUnit = {
   DAY: 0,
   MILLISECOND: 1
 };
 _Symbol$toStringTag3 = Symbol.toStringTag;
 
-var Date = function (_DataType7) {
-  (0, _inherits2.default)(Date, _DataType7);
-
-  var _super18 = _createSuper(Date);
-
-  function Date(unit) {
-    var _this3;
-
-    (0, _classCallCheck2.default)(this, Date);
-    _this3 = _super18.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this3), "unit", void 0);
-    _this3.unit = unit;
-    return _this3;
-  }
-
-  (0, _createClass2.default)(Date, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Date;
-    }
-  }, {
-    key: _Symbol$toStringTag3,
-    get: function get() {
-      return 'Date';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "Date".concat((this.unit + 1) * 32, "<").concat(DateUnit[this.unit], ">");
-    }
-  }]);
-  return Date;
-}(DataType);
-
-exports.Date = Date;
+class Date extends DataType {
+  constructor(unit) {
+    super();
+    (0, _defineProperty2.default)(this, "unit", void 0);
+    this.unit = unit;
+  }
 
-var DateDay = function (_Date) {
-  (0, _inherits2.default)(DateDay, _Date);
+  get typeId() {
+    return _enum.Type.Date;
+  }
 
-  var _super19 = _createSuper(DateDay);
+  get [_Symbol$toStringTag3]() {
+    return 'Date';
+  }
 
-  function DateDay() {
-    (0, _classCallCheck2.default)(this, DateDay);
-    return _super19.call(this, DateUnit.DAY);
+  toString() {
+    return "Date".concat((this.unit + 1) * 32, "<").concat(DateUnit[this.unit], ">");
   }
 
-  return DateDay;
-}(Date);
+}
 
-exports.DateDay = DateDay;
+exports.Date = Date;
 
-var DateMillisecond = function (_Date2) {
-  (0, _inherits2.default)(DateMillisecond, _Date2);
+class DateDay extends Date {
+  constructor() {
+    super(DateUnit.DAY);
+  }
+
+}
 
-  var _super20 = _createSuper(DateMillisecond);
+exports.DateDay = DateDay;
 
-  function DateMillisecond() {
-    (0, _classCallCheck2.default)(this, DateMillisecond);
-    return _super20.call(this, DateUnit.MILLISECOND);
+class DateMillisecond extends Date {
+  constructor() {
+    super(DateUnit.MILLISECOND);
   }
 
-  return DateMillisecond;
-}(Date);
+}
 
 exports.DateMillisecond = DateMillisecond;
-var TimeUnit = {
+const TimeUnit = {
   SECOND: 1,
   MILLISECOND: 1e3,
   MICROSECOND: 1e6,
@@ -594,334 +383,212 @@ var TimeUnit = {
 };
 _Symbol$toStringTag4 = Symbol.toStringTag;
 
-var Time = function (_DataType8) {
-  (0, _inherits2.default)(Time, _DataType8);
-
-  var _super21 = _createSuper(Time);
-
-  function Time(unit, bitWidth) {
-    var _this4;
-
-    (0, _classCallCheck2.default)(this, Time);
-    _this4 = _super21.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this4), "unit", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this4), "bitWidth", void 0);
-    _this4.unit = unit;
-    _this4.bitWidth = bitWidth;
-    return _this4;
-  }
-
-  (0, _createClass2.default)(Time, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Time;
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "Time".concat(this.bitWidth, "<").concat(TimeUnit[this.unit], ">");
-    }
-  }, {
-    key: _Symbol$toStringTag4,
-    get: function get() {
-      return 'Time';
-    }
-  }]);
-  return Time;
-}(DataType);
-
-exports.Time = Time;
+class Time extends DataType {
+  constructor(unit, bitWidth) {
+    super();
+    (0, _defineProperty2.default)(this, "unit", void 0);
+    (0, _defineProperty2.default)(this, "bitWidth", void 0);
+    this.unit = unit;
+    this.bitWidth = bitWidth;
+  }
 
-var TimeSecond = function (_Time) {
-  (0, _inherits2.default)(TimeSecond, _Time);
+  get typeId() {
+    return _enum.Type.Time;
+  }
 
-  var _super22 = _createSuper(TimeSecond);
+  toString() {
+    return "Time".concat(this.bitWidth, "<").concat(TimeUnit[this.unit], ">");
+  }
 
-  function TimeSecond() {
-    (0, _classCallCheck2.default)(this, TimeSecond);
-    return _super22.call(this, TimeUnit.SECOND, 32);
+  get [_Symbol$toStringTag4]() {
+    return 'Time';
   }
 
-  return TimeSecond;
-}(Time);
+}
 
-exports.TimeSecond = TimeSecond;
+exports.Time = Time;
 
-var TimeMillisecond = function (_Time2) {
-  (0, _inherits2.default)(TimeMillisecond, _Time2);
+class TimeSecond extends Time {
+  constructor() {
+    super(TimeUnit.SECOND, 32);
+  }
+
+}
 
-  var _super23 = _createSuper(TimeMillisecond);
+exports.TimeSecond = TimeSecond;
 
-  function TimeMillisecond() {
-    (0, _classCallCheck2.default)(this, TimeMillisecond);
-    return _super23.call(this, TimeUnit.MILLISECOND, 32);
+class TimeMillisecond extends Time {
+  constructor() {
+    super(TimeUnit.MILLISECOND, 32);
   }
 
-  return TimeMillisecond;
-}(Time);
+}
 
 exports.TimeMillisecond = TimeMillisecond;
 _Symbol$toStringTag5 = Symbol.toStringTag;
 
-var Timestamp = function (_DataType9) {
-  (0, _inherits2.default)(Timestamp, _DataType9);
-
-  var _super24 = _createSuper(Timestamp);
-
-  function Timestamp(unit) {
-    var _this5;
-
-    var timezone = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    (0, _classCallCheck2.default)(this, Timestamp);
-    _this5 = _super24.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this5), "unit", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this5), "timezone", void 0);
-    _this5.unit = unit;
-    _this5.timezone = timezone;
-    return _this5;
-  }
-
-  (0, _createClass2.default)(Timestamp, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Timestamp;
-    }
-  }, {
-    key: _Symbol$toStringTag5,
-    get: function get() {
-      return 'Timestamp';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "Timestamp<".concat(TimeUnit[this.unit]).concat(this.timezone ? ", ".concat(this.timezone) : '', ">");
-    }
-  }]);
-  return Timestamp;
-}(DataType);
-
-exports.Timestamp = Timestamp;
+class Timestamp extends DataType {
+  constructor(unit, timezone = null) {
+    super();
+    (0, _defineProperty2.default)(this, "unit", void 0);
+    (0, _defineProperty2.default)(this, "timezone", void 0);
+    this.unit = unit;
+    this.timezone = timezone;
+  }
 
-var TimestampSecond = function (_Timestamp) {
-  (0, _inherits2.default)(TimestampSecond, _Timestamp);
+  get typeId() {
+    return _enum.Type.Timestamp;
+  }
 
-  var _super25 = _createSuper(TimestampSecond);
+  get [_Symbol$toStringTag5]() {
+    return 'Timestamp';
+  }
 
-  function TimestampSecond() {
-    var timezone = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-    (0, _classCallCheck2.default)(this, TimestampSecond);
-    return _super25.call(this, TimeUnit.SECOND, timezone);
+  toString() {
+    return "Timestamp<".concat(TimeUnit[this.unit]).concat(this.timezone ? ", ".concat(this.timezone) : '', ">");
   }
 
-  return TimestampSecond;
-}(Timestamp);
+}
 
-exports.TimestampSecond = TimestampSecond;
+exports.Timestamp = Timestamp;
 
-var TimestampMillisecond = function (_Timestamp2) {
-  (0, _inherits2.default)(TimestampMillisecond, _Timestamp2);
+class TimestampSecond extends Timestamp {
+  constructor(timezone = null) {
+    super(TimeUnit.SECOND, timezone);
+  }
 
-  var _super26 = _createSuper(TimestampMillisecond);
+}
 
-  function TimestampMillisecond() {
-    var timezone = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-    (0, _classCallCheck2.default)(this, TimestampMillisecond);
-    return _super26.call(this, TimeUnit.MILLISECOND, timezone);
+exports.TimestampSecond = TimestampSecond;
+
+class TimestampMillisecond extends Timestamp {
+  constructor(timezone = null) {
+    super(TimeUnit.MILLISECOND, timezone);
   }
 
-  return TimestampMillisecond;
-}(Timestamp);
+}
 
 exports.TimestampMillisecond = TimestampMillisecond;
 
-var TimestampMicrosecond = function (_Timestamp3) {
-  (0, _inherits2.default)(TimestampMicrosecond, _Timestamp3);
-
-  var _super27 = _createSuper(TimestampMicrosecond);
-
-  function TimestampMicrosecond() {
-    var timezone = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-    (0, _classCallCheck2.default)(this, TimestampMicrosecond);
-    return _super27.call(this, TimeUnit.MICROSECOND, timezone);
+class TimestampMicrosecond extends Timestamp {
+  constructor(timezone = null) {
+    super(TimeUnit.MICROSECOND, timezone);
   }
 
-  return TimestampMicrosecond;
-}(Timestamp);
+}
 
 exports.TimestampMicrosecond = TimestampMicrosecond;
 
-var TimestampNanosecond = function (_Timestamp4) {
-  (0, _inherits2.default)(TimestampNanosecond, _Timestamp4);
-
-  var _super28 = _createSuper(TimestampNanosecond);
-
-  function TimestampNanosecond() {
-    var timezone = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-    (0, _classCallCheck2.default)(this, TimestampNanosecond);
-    return _super28.call(this, TimeUnit.NANOSECOND, timezone);
+class TimestampNanosecond extends Timestamp {
+  constructor(timezone = null) {
+    super(TimeUnit.NANOSECOND, timezone);
   }
 
-  return TimestampNanosecond;
-}(Timestamp);
+}
 
 exports.TimestampNanosecond = TimestampNanosecond;
-var IntervalUnit = {
+const IntervalUnit = {
   DAY_TIME: 0,
   YEAR_MONTH: 1
 };
 _Symbol$toStringTag6 = Symbol.toStringTag;
 
-var Interval = function (_DataType10) {
-  (0, _inherits2.default)(Interval, _DataType10);
-
-  var _super29 = _createSuper(Interval);
-
-  function Interval(unit) {
-    var _this6;
-
-    (0, _classCallCheck2.default)(this, Interval);
-    _this6 = _super29.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this6), "unit", void 0);
-    _this6.unit = unit;
-    return _this6;
-  }
-
-  (0, _createClass2.default)(Interval, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Interval;
-    }
-  }, {
-    key: _Symbol$toStringTag6,
-    get: function get() {
-      return 'Interval';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "Interval<".concat(IntervalUnit[this.unit], ">");
-    }
-  }]);
-  return Interval;
-}(DataType);
-
-exports.Interval = Interval;
+class Interval extends DataType {
+  constructor(unit) {
+    super();
+    (0, _defineProperty2.default)(this, "unit", void 0);
+    this.unit = unit;
+  }
 
-var IntervalDayTime = function (_Interval) {
-  (0, _inherits2.default)(IntervalDayTime, _Interval);
+  get typeId() {
+    return _enum.Type.Interval;
+  }
 
-  var _super30 = _createSuper(IntervalDayTime);
+  get [_Symbol$toStringTag6]() {
+    return 'Interval';
+  }
 
-  function IntervalDayTime() {
-    (0, _classCallCheck2.default)(this, IntervalDayTime);
-    return _super30.call(this, IntervalUnit.DAY_TIME);
+  toString() {
+    return "Interval<".concat(IntervalUnit[this.unit], ">");
   }
 
-  return IntervalDayTime;
-}(Interval);
+}
 
-exports.IntervalDayTime = IntervalDayTime;
+exports.Interval = Interval;
 
-var IntervalYearMonth = function (_Interval2) {
-  (0, _inherits2.default)(IntervalYearMonth, _Interval2);
+class IntervalDayTime extends Interval {
+  constructor() {
+    super(IntervalUnit.DAY_TIME);
+  }
+
+}
 
-  var _super31 = _createSuper(IntervalYearMonth);
+exports.IntervalDayTime = IntervalDayTime;
 
-  function IntervalYearMonth() {
-    (0, _classCallCheck2.default)(this, IntervalYearMonth);
-    return _super31.call(this, IntervalUnit.YEAR_MONTH);
+class IntervalYearMonth extends Interval {
+  constructor() {
+    super(IntervalUnit.YEAR_MONTH);
   }
 
-  return IntervalYearMonth;
-}(Interval);
+}
 
 exports.IntervalYearMonth = IntervalYearMonth;
 _Symbol$toStringTag7 = Symbol.toStringTag;
 
-var FixedSizeList = function (_DataType11) {
-  (0, _inherits2.default)(FixedSizeList, _DataType11);
-
-  var _super32 = _createSuper(FixedSizeList);
-
-  function FixedSizeList(listSize, child) {
-    var _this7;
-
-    (0, _classCallCheck2.default)(this, FixedSizeList);
-    _this7 = _super32.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this7), "listSize", void 0);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this7), "children", void 0);
-    _this7.listSize = listSize;
-    _this7.children = [child];
-    return _this7;
-  }
-
-  (0, _createClass2.default)(FixedSizeList, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.FixedSizeList;
-    }
-  }, {
-    key: "valueType",
-    get: function get() {
-      return this.children[0].type;
-    }
-  }, {
-    key: "valueField",
-    get: function get() {
-      return this.children[0];
-    }
-  }, {
-    key: _Symbol$toStringTag7,
-    get: function get() {
-      return 'FixedSizeList';
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "FixedSizeList[".concat(this.listSize, "]<").concat(this.valueType, ">");
-    }
-  }]);
-  return FixedSizeList;
-}(DataType);
+class FixedSizeList extends DataType {
+  constructor(listSize, child) {
+    super();
+    (0, _defineProperty2.default)(this, "listSize", void 0);
+    (0, _defineProperty2.default)(this, "children", void 0);
+    this.listSize = listSize;
+    this.children = [child];
+  }
+
+  get typeId() {
+    return _enum.Type.FixedSizeList;
+  }
+
+  get valueType() {
+    return this.children[0].type;
+  }
+
+  get valueField() {
+    return this.children[0];
+  }
+
+  get [_Symbol$toStringTag7]() {
+    return 'FixedSizeList';
+  }
+
+  toString() {
+    return "FixedSizeList[".concat(this.listSize, "]<").concat(this.valueType, ">");
+  }
+
+}
 
 exports.FixedSizeList = FixedSizeList;
 _Symbol$toStringTag8 = Symbol.toStringTag;
 
-var Struct = function (_DataType12) {
-  (0, _inherits2.default)(Struct, _DataType12);
-
-  var _super33 = _createSuper(Struct);
-
-  function Struct(children) {
-    var _this8;
-
-    (0, _classCallCheck2.default)(this, Struct);
-    _this8 = _super33.call(this);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this8), "children", void 0);
-    _this8.children = children;
-    return _this8;
-  }
-
-  (0, _createClass2.default)(Struct, [{
-    key: "typeId",
-    get: function get() {
-      return _enum.Type.Struct;
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return "Struct<{".concat(this.children.map(function (f) {
-        return "".concat(f.name, ":").concat(f.type);
-      }).join(', '), "}>");
-    }
-  }, {
-    key: _Symbol$toStringTag8,
-    get: function get() {
-      return 'Struct';
-    }
-  }]);
-  return Struct;
-}(DataType);
+class Struct extends DataType {
+  constructor(children) {
+    super();
+    (0, _defineProperty2.default)(this, "children", void 0);
+    this.children = children;
+  }
+
+  get typeId() {
+    return _enum.Type.Struct;
+  }
+
+  toString() {
+    return "Struct<{".concat(this.children.map(f => "".concat(f.name, ":").concat(f.type)).join(', '), "}>");
+  }
+
+  get [_Symbol$toStringTag8]() {
+    return 'Struct';
+  }
+
+}
 
 exports.Struct = Struct;
 //# sourceMappingURL=type.js.map