@loaders.gl/schema 3.1.0-beta.5 → 3.1.1

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

@@ -7,375 +7,586 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "Type", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _enum = require("./enum");
-
-let _Symbol$toStringTag, _Symbol$toStringTag2, _Symbol$toStringTag3, _Symbol$toStringTag4, _Symbol$toStringTag5, _Symbol$toStringTag6, _Symbol$toStringTag7, _Symbol$toStringTag8;
-
-class DataType {
-  static isNull(x) {
-    return x && x.typeId === _enum.Type.Null;
-  }
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
 
-  static isInt(x) {
-    return x && x.typeId === _enum.Type.Int;
-  }
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-  static isFloat(x) {
-    return x && x.typeId === _enum.Type.Float;
-  }
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
-  static isBinary(x) {
-    return x && x.typeId === _enum.Type.Binary;
-  }
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
-  static isUtf8(x) {
-    return x && x.typeId === _enum.Type.Utf8;
-  }
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-  static isBool(x) {
-    return x && x.typeId === _enum.Type.Bool;
-  }
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
-  static isDecimal(x) {
-    return x && x.typeId === _enum.Type.Decimal;
-  }
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-  static isDate(x) {
-    return x && x.typeId === _enum.Type.Date;
-  }
+var _enum = require("./enum");
 
-  static isTime(x) {
-    return x && x.typeId === _enum.Type.Time;
-  }
+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 isTimestamp(x) {
-    return x && x.typeId === _enum.Type.Timestamp;
-  }
+exports.DataType = DataType;
 
-  static isInterval(x) {
-    return x && x.typeId === _enum.Type.Interval;
-  }
+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 isList(x) {
-    return x && x.typeId === _enum.Type.List;
-  }
+exports.Null = Null;
 
-  static isStruct(x) {
-    return x && x.typeId === _enum.Type.Struct;
-  }
+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 isUnion(x) {
-    return x && x.typeId === _enum.Type.Union;
-  }
+exports.Bool = Bool;
+_Symbol$toStringTag = Symbol.toStringTag;
 
-  static isFixedSizeBinary(x) {
-    return x && x.typeId === _enum.Type.FixedSizeBinary;
-  }
+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 isFixedSizeList(x) {
-    return x && x.typeId === _enum.Type.FixedSizeList;
-  }
+exports.Int = Int;
 
-  static isMap(x) {
-    return x && x.typeId === _enum.Type.Map;
-  }
+var Int8 = function (_Int) {
+  (0, _inherits2.default)(Int8, _Int);
 
-  static isDictionary(x) {
-    return x && x.typeId === _enum.Type.Dictionary;
-  }
+  var _super4 = _createSuper(Int8);
 
-  get typeId() {
-    return _enum.Type.NONE;
+  function Int8() {
+    (0, _classCallCheck2.default)(this, Int8);
+    return _super4.call(this, true, 8);
   }
 
-  compareTo(other) {
-    return this === other;
-  }
+  return Int8;
+}(Int);
 
-}
+exports.Int8 = Int8;
 
-exports.DataType = DataType;
+var Int16 = function (_Int2) {
+  (0, _inherits2.default)(Int16, _Int2);
 
-class Null extends DataType {
-  get typeId() {
-    return _enum.Type.Null;
-  }
+  var _super5 = _createSuper(Int16);
 
-  get [Symbol.toStringTag]() {
-    return 'Null';
+  function Int16() {
+    (0, _classCallCheck2.default)(this, Int16);
+    return _super5.call(this, true, 16);
   }
 
-  toString() {
-    return 'Null';
-  }
+  return Int16;
+}(Int);
 
-}
-
-exports.Null = Null;
+exports.Int16 = Int16;
 
-class Bool extends DataType {
-  get typeId() {
-    return _enum.Type.Bool;
-  }
+var Int32 = function (_Int3) {
+  (0, _inherits2.default)(Int32, _Int3);
 
-  get [Symbol.toStringTag]() {
-    return 'Bool';
-  }
+  var _super6 = _createSuper(Int32);
 
-  toString() {
-    return 'Bool';
+  function Int32() {
+    (0, _classCallCheck2.default)(this, Int32);
+    return _super6.call(this, true, 32);
   }
 
-}
+  return Int32;
+}(Int);
 
-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;
-  }
+exports.Int32 = Int32;
 
-  get typeId() {
-    return _enum.Type.Int;
-  }
+var Int64 = function (_Int4) {
+  (0, _inherits2.default)(Int64, _Int4);
 
-  get [_Symbol$toStringTag]() {
-    return 'Int';
-  }
+  var _super7 = _createSuper(Int64);
 
-  toString() {
-    return "".concat(this.isSigned ? 'I' : 'Ui', "nt").concat(this.bitWidth);
+  function Int64() {
+    (0, _classCallCheck2.default)(this, Int64);
+    return _super7.call(this, true, 64);
   }
 
-}
-
-exports.Int = Int;
+  return Int64;
+}(Int);
 
-class Int8 extends Int {
-  constructor() {
-    super(true, 8);
-  }
+exports.Int64 = Int64;
 
-}
+var Uint8 = function (_Int5) {
+  (0, _inherits2.default)(Uint8, _Int5);
 
-exports.Int8 = Int8;
+  var _super8 = _createSuper(Uint8);
 
-class Int16 extends Int {
-  constructor() {
-    super(true, 16);
+  function Uint8() {
+    (0, _classCallCheck2.default)(this, Uint8);
+    return _super8.call(this, false, 8);
   }
 
-}
-
-exports.Int16 = Int16;
+  return Uint8;
+}(Int);
 
-class Int32 extends Int {
-  constructor() {
-    super(true, 32);
-  }
+exports.Uint8 = Uint8;
 
-}
+var Uint16 = function (_Int6) {
+  (0, _inherits2.default)(Uint16, _Int6);
 
-exports.Int32 = Int32;
+  var _super9 = _createSuper(Uint16);
 
-class Int64 extends Int {
-  constructor() {
-    super(true, 64);
+  function Uint16() {
+    (0, _classCallCheck2.default)(this, Uint16);
+    return _super9.call(this, false, 16);
   }
 
-}
-
-exports.Int64 = Int64;
+  return Uint16;
+}(Int);
 
-class Uint8 extends Int {
-  constructor() {
-    super(false, 8);
-  }
+exports.Uint16 = Uint16;
 
-}
+var Uint32 = function (_Int7) {
+  (0, _inherits2.default)(Uint32, _Int7);
 
-exports.Uint8 = Uint8;
+  var _super10 = _createSuper(Uint32);
 
-class Uint16 extends Int {
-  constructor() {
-    super(false, 16);
+  function Uint32() {
+    (0, _classCallCheck2.default)(this, Uint32);
+    return _super10.call(this, false, 32);
   }
 
-}
-
-exports.Uint16 = Uint16;
+  return Uint32;
+}(Int);
 
-class Uint32 extends Int {
-  constructor() {
-    super(false, 32);
-  }
+exports.Uint32 = Uint32;
 
-}
+var Uint64 = function (_Int8) {
+  (0, _inherits2.default)(Uint64, _Int8);
 
-exports.Uint32 = Uint32;
+  var _super11 = _createSuper(Uint64);
 
-class Uint64 extends Int {
-  constructor() {
-    super(false, 64);
+  function Uint64() {
+    (0, _classCallCheck2.default)(this, Uint64);
+    return _super11.call(this, false, 64);
   }
 
-}
+  return Uint64;
+}(Int);
 
 exports.Uint64 = Uint64;
-const Precision = {
+var Precision = {
   HALF: 16,
   SINGLE: 32,
   DOUBLE: 64
 };
 _Symbol$toStringTag2 = Symbol.toStringTag;
 
-class Float extends DataType {
-  constructor(precision) {
-    super();
-    (0, _defineProperty2.default)(this, "precision", void 0);
-    this.precision = precision;
-  }
+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);
 
-  get typeId() {
-    return _enum.Type.Float;
-  }
+exports.Float = Float;
 
-  get [_Symbol$toStringTag2]() {
-    return 'Float';
-  }
+var Float16 = function (_Float) {
+  (0, _inherits2.default)(Float16, _Float);
 
-  toString() {
-    return "Float".concat(this.precision);
-  }
+  var _super13 = _createSuper(Float16);
 
-}
-
-exports.Float = Float;
-
-class Float16 extends Float {
-  constructor() {
-    super(Precision.HALF);
+  function Float16() {
+    (0, _classCallCheck2.default)(this, Float16);
+    return _super13.call(this, Precision.HALF);
   }
 
-}
+  return Float16;
+}(Float);
 
 exports.Float16 = Float16;
 
-class Float32 extends Float {
-  constructor() {
-    super(Precision.SINGLE);
-  }
-
-}
+var Float32 = function (_Float2) {
+  (0, _inherits2.default)(Float32, _Float2);
 
-exports.Float32 = Float32;
+  var _super14 = _createSuper(Float32);
 
-class Float64 extends Float {
-  constructor() {
-    super(Precision.DOUBLE);
+  function Float32() {
+    (0, _classCallCheck2.default)(this, Float32);
+    return _super14.call(this, Precision.SINGLE);
   }
 
-}
+  return Float32;
+}(Float);
 
-exports.Float64 = Float64;
-
-class Binary extends DataType {
-  constructor() {
-    super();
-  }
+exports.Float32 = Float32;
 
-  get typeId() {
-    return _enum.Type.Binary;
-  }
+var Float64 = function (_Float3) {
+  (0, _inherits2.default)(Float64, _Float3);
 
-  toString() {
-    return 'Binary';
-  }
+  var _super15 = _createSuper(Float64);
 
-  get [Symbol.toStringTag]() {
-    return 'Binary';
+  function Float64() {
+    (0, _classCallCheck2.default)(this, Float64);
+    return _super15.call(this, Precision.DOUBLE);
   }
 
-}
-
-exports.Binary = Binary;
+  return Float64;
+}(Float);
 
-class Utf8 extends DataType {
-  get typeId() {
-    return _enum.Type.Utf8;
-  }
+exports.Float64 = Float64;
 
-  get [Symbol.toStringTag]() {
-    return 'Utf8';
-  }
+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);
 
-  toString() {
-    return 'Utf8';
-  }
+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);
 
 exports.Utf8 = Utf8;
-const DateUnit = {
+var DateUnit = {
   DAY: 0,
   MILLISECOND: 1
 };
 _Symbol$toStringTag3 = Symbol.toStringTag;
 
-class Date extends DataType {
-  constructor(unit) {
-    super();
-    (0, _defineProperty2.default)(this, "unit", void 0);
-    this.unit = unit;
-  }
-
-  get typeId() {
-    return _enum.Type.Date;
-  }
+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);
 
-  get [_Symbol$toStringTag3]() {
-    return 'Date';
-  }
+exports.Date = Date;
 
-  toString() {
-    return "Date".concat((this.unit + 1) * 32, "<").concat(DateUnit[this.unit], ">");
-  }
+var DateDay = function (_Date) {
+  (0, _inherits2.default)(DateDay, _Date);
 
-}
+  var _super19 = _createSuper(DateDay);
 
-exports.Date = Date;
-
-class DateDay extends Date {
-  constructor() {
-    super(DateUnit.DAY);
+  function DateDay() {
+    (0, _classCallCheck2.default)(this, DateDay);
+    return _super19.call(this, DateUnit.DAY);
   }
 
-}
+  return DateDay;
+}(Date);
 
 exports.DateDay = DateDay;
 
-class DateMillisecond extends Date {
-  constructor() {
-    super(DateUnit.MILLISECOND);
+var DateMillisecond = function (_Date2) {
+  (0, _inherits2.default)(DateMillisecond, _Date2);
+
+  var _super20 = _createSuper(DateMillisecond);
+
+  function DateMillisecond() {
+    (0, _classCallCheck2.default)(this, DateMillisecond);
+    return _super20.call(this, DateUnit.MILLISECOND);
   }
 
-}
+  return DateMillisecond;
+}(Date);
 
 exports.DateMillisecond = DateMillisecond;
-const TimeUnit = {
+var TimeUnit = {
   SECOND: 1,
   MILLISECOND: 1e3,
   MICROSECOND: 1e6,
@@ -383,212 +594,334 @@ const TimeUnit = {
 };
 _Symbol$toStringTag4 = Symbol.toStringTag;
 
-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;
-  }
-
-  get typeId() {
-    return _enum.Type.Time;
-  }
+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);
 
-  toString() {
-    return "Time".concat(this.bitWidth, "<").concat(TimeUnit[this.unit], ">");
-  }
+exports.Time = Time;
 
-  get [_Symbol$toStringTag4]() {
-    return 'Time';
-  }
+var TimeSecond = function (_Time) {
+  (0, _inherits2.default)(TimeSecond, _Time);
 
-}
+  var _super22 = _createSuper(TimeSecond);
 
-exports.Time = Time;
-
-class TimeSecond extends Time {
-  constructor() {
-    super(TimeUnit.SECOND, 32);
+  function TimeSecond() {
+    (0, _classCallCheck2.default)(this, TimeSecond);
+    return _super22.call(this, TimeUnit.SECOND, 32);
   }
 
-}
+  return TimeSecond;
+}(Time);
 
 exports.TimeSecond = TimeSecond;
 
-class TimeMillisecond extends Time {
-  constructor() {
-    super(TimeUnit.MILLISECOND, 32);
+var TimeMillisecond = function (_Time2) {
+  (0, _inherits2.default)(TimeMillisecond, _Time2);
+
+  var _super23 = _createSuper(TimeMillisecond);
+
+  function TimeMillisecond() {
+    (0, _classCallCheck2.default)(this, TimeMillisecond);
+    return _super23.call(this, TimeUnit.MILLISECOND, 32);
   }
 
-}
+  return TimeMillisecond;
+}(Time);
 
 exports.TimeMillisecond = TimeMillisecond;
 _Symbol$toStringTag5 = Symbol.toStringTag;
 
-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 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);
 
-  get typeId() {
-    return _enum.Type.Timestamp;
-  }
-
-  get [_Symbol$toStringTag5]() {
-    return 'Timestamp';
-  }
-
-  toString() {
-    return "Timestamp<".concat(TimeUnit[this.unit]).concat(this.timezone ? ", ".concat(this.timezone) : '', ">");
-  }
+exports.Timestamp = Timestamp;
 
-}
+var TimestampSecond = function (_Timestamp) {
+  (0, _inherits2.default)(TimestampSecond, _Timestamp);
 
-exports.Timestamp = Timestamp;
+  var _super25 = _createSuper(TimestampSecond);
 
-class TimestampSecond extends Timestamp {
-  constructor(timezone = null) {
-    super(TimeUnit.SECOND, timezone);
+  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);
   }
 
-}
+  return TimestampSecond;
+}(Timestamp);
 
 exports.TimestampSecond = TimestampSecond;
 
-class TimestampMillisecond extends Timestamp {
-  constructor(timezone = null) {
-    super(TimeUnit.MILLISECOND, timezone);
+var TimestampMillisecond = function (_Timestamp2) {
+  (0, _inherits2.default)(TimestampMillisecond, _Timestamp2);
+
+  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);
   }
 
-}
+  return TimestampMillisecond;
+}(Timestamp);
 
 exports.TimestampMillisecond = TimestampMillisecond;
 
-class TimestampMicrosecond extends Timestamp {
-  constructor(timezone = null) {
-    super(TimeUnit.MICROSECOND, timezone);
+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);
   }
 
-}
+  return TimestampMicrosecond;
+}(Timestamp);
 
 exports.TimestampMicrosecond = TimestampMicrosecond;
 
-class TimestampNanosecond extends Timestamp {
-  constructor(timezone = null) {
-    super(TimeUnit.NANOSECOND, timezone);
+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);
   }
 
-}
+  return TimestampNanosecond;
+}(Timestamp);
 
 exports.TimestampNanosecond = TimestampNanosecond;
-const IntervalUnit = {
+var IntervalUnit = {
   DAY_TIME: 0,
   YEAR_MONTH: 1
 };
 _Symbol$toStringTag6 = Symbol.toStringTag;
 
-class Interval extends DataType {
-  constructor(unit) {
-    super();
-    (0, _defineProperty2.default)(this, "unit", void 0);
-    this.unit = unit;
-  }
-
-  get typeId() {
-    return _enum.Type.Interval;
-  }
-
-  get [_Symbol$toStringTag6]() {
-    return 'Interval';
-  }
-
-  toString() {
-    return "Interval<".concat(IntervalUnit[this.unit], ">");
-  }
-
-}
+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 IntervalDayTime extends Interval {
-  constructor() {
-    super(IntervalUnit.DAY_TIME);
-  }
-
-}
+var IntervalDayTime = function (_Interval) {
+  (0, _inherits2.default)(IntervalDayTime, _Interval);
 
-exports.IntervalDayTime = IntervalDayTime;
+  var _super30 = _createSuper(IntervalDayTime);
 
-class IntervalYearMonth extends Interval {
-  constructor() {
-    super(IntervalUnit.YEAR_MONTH);
+  function IntervalDayTime() {
+    (0, _classCallCheck2.default)(this, IntervalDayTime);
+    return _super30.call(this, IntervalUnit.DAY_TIME);
   }
 
-}
+  return IntervalDayTime;
+}(Interval);
 
-exports.IntervalYearMonth = IntervalYearMonth;
-_Symbol$toStringTag7 = Symbol.toStringTag;
-
-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];
-  }
+exports.IntervalDayTime = IntervalDayTime;
 
-  get typeId() {
-    return _enum.Type.FixedSizeList;
-  }
+var IntervalYearMonth = function (_Interval2) {
+  (0, _inherits2.default)(IntervalYearMonth, _Interval2);
 
-  get valueType() {
-    return this.children[0].type;
-  }
+  var _super31 = _createSuper(IntervalYearMonth);
 
-  get valueField() {
-    return this.children[0];
+  function IntervalYearMonth() {
+    (0, _classCallCheck2.default)(this, IntervalYearMonth);
+    return _super31.call(this, IntervalUnit.YEAR_MONTH);
   }
 
-  get [_Symbol$toStringTag7]() {
-    return 'FixedSizeList';
-  }
+  return IntervalYearMonth;
+}(Interval);
 
-  toString() {
-    return "FixedSizeList[".concat(this.listSize, "]<").concat(this.valueType, ">");
-  }
+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);
 
 exports.FixedSizeList = FixedSizeList;
 _Symbol$toStringTag8 = Symbol.toStringTag;
 
-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';
-  }
-
-}
+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);
 
 exports.Struct = Struct;
 //# sourceMappingURL=type.js.map