@loaders.gl/schema 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/es5/lib/table/arrow-api/arrow-like-type.js

@@ -0,0 +1,740 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimestampSecond = exports.TimestampNanosecond = exports.TimestampMillisecond = exports.TimestampMicrosecond = exports.Timestamp = exports.TimeSecond = exports.TimeMillisecond = exports.Time = exports.Struct = exports.Null = exports.IntervalYearMonth = exports.IntervalDayTime = exports.Interval = exports.Int8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int = exports.Float64 = exports.Float32 = exports.Float16 = exports.Float = exports.FixedSizeList = exports.DateMillisecond = exports.DateDay = exports.Date = exports.DataType = exports.Bool = exports.Binary = void 0;
+Object.defineProperty(exports, "Type", {
+  enumerable: true,
+  get: function get() {
+    return _enum.Type;
+  }
+});
+exports.Utf8 = exports.Uint8 = exports.Uint64 = exports.Uint32 = exports.Uint16 = 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 _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _enum = require("./enum");
+var _Symbol$toStringTag3, _Symbol$toStringTag4, _Symbol$toStringTag7, _Symbol$toStringTag8, _Symbol$toStringTag9, _Symbol$toStringTag10, _Symbol$toStringTag11, _Symbol$toStringTag12;
+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;
+}();
+exports.DataType = DataType;
+var Null = function (_DataType, _Symbol$toStringTag) {
+  (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, Symbol.toStringTag);
+exports.Null = Null;
+var Bool = function (_DataType2, _Symbol$toStringTag2) {
+  (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$toStringTag2,
+    get: function get() {
+      return 'Bool';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return 'Bool';
+    }
+  }]);
+  return Bool;
+}(DataType, Symbol.toStringTag);
+exports.Bool = Bool;
+_Symbol$toStringTag3 = Symbol.toStringTag;
+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$toStringTag3,
+    get: function get() {
+      return 'Int';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "".concat(this.isSigned ? 'I' : 'Ui', "nt").concat(this.bitWidth);
+    }
+  }]);
+  return Int;
+}(DataType);
+exports.Int = Int;
+var Int8 = function (_Int) {
+  (0, _inherits2.default)(Int8, _Int);
+  var _super4 = _createSuper(Int8);
+  function Int8() {
+    (0, _classCallCheck2.default)(this, Int8);
+    return _super4.call(this, true, 8);
+  }
+  return (0, _createClass2.default)(Int8);
+}(Int);
+exports.Int8 = Int8;
+var Int16 = function (_Int2) {
+  (0, _inherits2.default)(Int16, _Int2);
+  var _super5 = _createSuper(Int16);
+  function Int16() {
+    (0, _classCallCheck2.default)(this, Int16);
+    return _super5.call(this, true, 16);
+  }
+  return (0, _createClass2.default)(Int16);
+}(Int);
+exports.Int16 = Int16;
+var Int32 = function (_Int3) {
+  (0, _inherits2.default)(Int32, _Int3);
+  var _super6 = _createSuper(Int32);
+  function Int32() {
+    (0, _classCallCheck2.default)(this, Int32);
+    return _super6.call(this, true, 32);
+  }
+  return (0, _createClass2.default)(Int32);
+}(Int);
+exports.Int32 = Int32;
+var Int64 = function (_Int4) {
+  (0, _inherits2.default)(Int64, _Int4);
+  var _super7 = _createSuper(Int64);
+  function Int64() {
+    (0, _classCallCheck2.default)(this, Int64);
+    return _super7.call(this, true, 64);
+  }
+  return (0, _createClass2.default)(Int64);
+}(Int);
+exports.Int64 = Int64;
+var Uint8 = function (_Int5) {
+  (0, _inherits2.default)(Uint8, _Int5);
+  var _super8 = _createSuper(Uint8);
+  function Uint8() {
+    (0, _classCallCheck2.default)(this, Uint8);
+    return _super8.call(this, false, 8);
+  }
+  return (0, _createClass2.default)(Uint8);
+}(Int);
+exports.Uint8 = Uint8;
+var Uint16 = function (_Int6) {
+  (0, _inherits2.default)(Uint16, _Int6);
+  var _super9 = _createSuper(Uint16);
+  function Uint16() {
+    (0, _classCallCheck2.default)(this, Uint16);
+    return _super9.call(this, false, 16);
+  }
+  return (0, _createClass2.default)(Uint16);
+}(Int);
+exports.Uint16 = Uint16;
+var Uint32 = function (_Int7) {
+  (0, _inherits2.default)(Uint32, _Int7);
+  var _super10 = _createSuper(Uint32);
+  function Uint32() {
+    (0, _classCallCheck2.default)(this, Uint32);
+    return _super10.call(this, false, 32);
+  }
+  return (0, _createClass2.default)(Uint32);
+}(Int);
+exports.Uint32 = Uint32;
+var Uint64 = function (_Int8) {
+  (0, _inherits2.default)(Uint64, _Int8);
+  var _super11 = _createSuper(Uint64);
+  function Uint64() {
+    (0, _classCallCheck2.default)(this, Uint64);
+    return _super11.call(this, false, 64);
+  }
+  return (0, _createClass2.default)(Uint64);
+}(Int);
+exports.Uint64 = Uint64;
+var Precision = {
+  HALF: 16,
+  SINGLE: 32,
+  DOUBLE: 64
+};
+_Symbol$toStringTag4 = 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$toStringTag4,
+    get: function get() {
+      return 'Float';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "Float".concat(this.precision);
+    }
+  }]);
+  return Float;
+}(DataType);
+exports.Float = Float;
+var Float16 = function (_Float) {
+  (0, _inherits2.default)(Float16, _Float);
+  var _super13 = _createSuper(Float16);
+  function Float16() {
+    (0, _classCallCheck2.default)(this, Float16);
+    return _super13.call(this, Precision.HALF);
+  }
+  return (0, _createClass2.default)(Float16);
+}(Float);
+exports.Float16 = Float16;
+var Float32 = function (_Float2) {
+  (0, _inherits2.default)(Float32, _Float2);
+  var _super14 = _createSuper(Float32);
+  function Float32() {
+    (0, _classCallCheck2.default)(this, Float32);
+    return _super14.call(this, Precision.SINGLE);
+  }
+  return (0, _createClass2.default)(Float32);
+}(Float);
+exports.Float32 = Float32;
+var Float64 = function (_Float3) {
+  (0, _inherits2.default)(Float64, _Float3);
+  var _super15 = _createSuper(Float64);
+  function Float64() {
+    (0, _classCallCheck2.default)(this, Float64);
+    return _super15.call(this, Precision.DOUBLE);
+  }
+  return (0, _createClass2.default)(Float64);
+}(Float);
+exports.Float64 = Float64;
+var Binary = function (_DataType5, _Symbol$toStringTag5) {
+  (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$toStringTag5,
+    get: function get() {
+      return 'Binary';
+    }
+  }]);
+  return Binary;
+}(DataType, Symbol.toStringTag);
+exports.Binary = Binary;
+var Utf8 = function (_DataType6, _Symbol$toStringTag6) {
+  (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$toStringTag6,
+    get: function get() {
+      return 'Utf8';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return 'Utf8';
+    }
+  }]);
+  return Utf8;
+}(DataType, Symbol.toStringTag);
+exports.Utf8 = Utf8;
+var DateUnit = {
+  DAY: 0,
+  MILLISECOND: 1
+};
+_Symbol$toStringTag7 = 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$toStringTag7,
+    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;
+var DateDay = function (_Date) {
+  (0, _inherits2.default)(DateDay, _Date);
+  var _super19 = _createSuper(DateDay);
+  function DateDay() {
+    (0, _classCallCheck2.default)(this, DateDay);
+    return _super19.call(this, DateUnit.DAY);
+  }
+  return (0, _createClass2.default)(DateDay);
+}(Date);
+exports.DateDay = DateDay;
+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 (0, _createClass2.default)(DateMillisecond);
+}(Date);
+exports.DateMillisecond = DateMillisecond;
+var TimeUnit = {
+  SECOND: 1,
+  MILLISECOND: 1e3,
+  MICROSECOND: 1e6,
+  NANOSECOND: 1e9
+};
+_Symbol$toStringTag8 = 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$toStringTag8,
+    get: function get() {
+      return 'Time';
+    }
+  }]);
+  return Time;
+}(DataType);
+exports.Time = Time;
+var TimeSecond = function (_Time) {
+  (0, _inherits2.default)(TimeSecond, _Time);
+  var _super22 = _createSuper(TimeSecond);
+  function TimeSecond() {
+    (0, _classCallCheck2.default)(this, TimeSecond);
+    return _super22.call(this, TimeUnit.SECOND, 32);
+  }
+  return (0, _createClass2.default)(TimeSecond);
+}(Time);
+exports.TimeSecond = TimeSecond;
+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 (0, _createClass2.default)(TimeMillisecond);
+}(Time);
+exports.TimeMillisecond = TimeMillisecond;
+_Symbol$toStringTag9 = 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$toStringTag9,
+    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;
+var TimestampSecond = function (_Timestamp) {
+  (0, _inherits2.default)(TimestampSecond, _Timestamp);
+  var _super25 = _createSuper(TimestampSecond);
+  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 (0, _createClass2.default)(TimestampSecond);
+}(Timestamp);
+exports.TimestampSecond = TimestampSecond;
+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 (0, _createClass2.default)(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);
+  }
+  return (0, _createClass2.default)(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);
+  }
+  return (0, _createClass2.default)(TimestampNanosecond);
+}(Timestamp);
+exports.TimestampNanosecond = TimestampNanosecond;
+var IntervalUnit = {
+  DAY_TIME: 0,
+  YEAR_MONTH: 1
+};
+_Symbol$toStringTag10 = 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$toStringTag10,
+    get: function get() {
+      return 'Interval';
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "Interval<".concat(IntervalUnit[this.unit], ">");
+    }
+  }]);
+  return Interval;
+}(DataType);
+exports.Interval = Interval;
+var IntervalDayTime = function (_Interval) {
+  (0, _inherits2.default)(IntervalDayTime, _Interval);
+  var _super30 = _createSuper(IntervalDayTime);
+  function IntervalDayTime() {
+    (0, _classCallCheck2.default)(this, IntervalDayTime);
+    return _super30.call(this, IntervalUnit.DAY_TIME);
+  }
+  return (0, _createClass2.default)(IntervalDayTime);
+}(Interval);
+exports.IntervalDayTime = IntervalDayTime;
+var IntervalYearMonth = function (_Interval2) {
+  (0, _inherits2.default)(IntervalYearMonth, _Interval2);
+  var _super31 = _createSuper(IntervalYearMonth);
+  function IntervalYearMonth() {
+    (0, _classCallCheck2.default)(this, IntervalYearMonth);
+    return _super31.call(this, IntervalUnit.YEAR_MONTH);
+  }
+  return (0, _createClass2.default)(IntervalYearMonth);
+}(Interval);
+exports.IntervalYearMonth = IntervalYearMonth;
+_Symbol$toStringTag11 = 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$toStringTag11,
+    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$toStringTag12 = 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$toStringTag12,
+    get: function get() {
+      return 'Struct';
+    }
+  }]);
+  return Struct;
+}(DataType);
+exports.Struct = Struct;
+//# sourceMappingURL=arrow-like-type.js.map