@jbrowse/plugin-alignments 1.6.7 → 1.7.0

package/dist/BamAdapter/MismatchParser.js

@@ -0,0 +1,384 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cigarToMismatches = cigarToMismatches;
+exports.getMismatches = getMismatches;
+exports.getModificationPositions = getModificationPositions;
+exports.getModificationTypes = getModificationTypes;
+exports.getNextRefPos = getNextRefPos;
+exports.mdToMismatches = mdToMismatches;
+exports.parseCigar = parseCigar;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _util = require("@jbrowse/core/util");
+
+var _marked = /*#__PURE__*/_regenerator["default"].mark(getNextRefPos);
+
+var mdRegex = new RegExp(/(\d+|\^[a-z]+|[a-z])/gi);
+
+function parseCigar(cigar) {
+  return (cigar || '').split(/([MIDNSHPX=])/);
+}
+
+function cigarToMismatches(ops, seq, ref, qual) {
+  var roffset = 0; // reference offset
+
+  var soffset = 0; // seq offset
+
+  var mismatches = [];
+  var hasRefAndSeq = ref && seq;
+
+  for (var i = 0; i < ops.length; i += 2) {
+    var len = +ops[i];
+    var op = ops[i + 1];
+
+    if (op === 'M' || op === '=' || op === 'E') {
+      if (hasRefAndSeq) {
+        for (var j = 0; j < len; j++) {
+          if ( // @ts-ignore in the full yarn build of the repo, this says that object is possibly undefined for some reason, ignored
+          seq[soffset + j].toUpperCase() !== ref[roffset + j].toUpperCase()) {
+            mismatches.push({
+              start: roffset + j,
+              type: 'mismatch',
+              base: seq[soffset + j],
+              length: 1
+            });
+          }
+        }
+      }
+
+      soffset += len;
+    }
+
+    if (op === 'I') {
+      mismatches.push({
+        start: roffset,
+        type: 'insertion',
+        base: "".concat(len),
+        length: 0
+      });
+      soffset += len;
+    } else if (op === 'D') {
+      mismatches.push({
+        start: roffset,
+        type: 'deletion',
+        base: '*',
+        length: len
+      });
+    } else if (op === 'N') {
+      mismatches.push({
+        start: roffset,
+        type: 'skip',
+        base: 'N',
+        length: len
+      });
+    } else if (op === 'X') {
+      var r = seq.slice(soffset, soffset + len);
+      var q = (qual === null || qual === void 0 ? void 0 : qual.slice(soffset, soffset + len)) || [];
+
+      for (var _j = 0; _j < len; _j++) {
+        mismatches.push({
+          start: roffset + _j,
+          type: 'mismatch',
+          base: r[_j],
+          qual: q[_j],
+          length: 1
+        });
+      }
+
+      soffset += len;
+    } else if (op === 'H') {
+      mismatches.push({
+        start: roffset,
+        type: 'hardclip',
+        base: "H".concat(len),
+        cliplen: len,
+        length: 1
+      });
+    } else if (op === 'S') {
+      mismatches.push({
+        start: roffset,
+        type: 'softclip',
+        base: "S".concat(len),
+        cliplen: len,
+        length: 1
+      });
+      soffset += len;
+    }
+
+    if (op !== 'I' && op !== 'S' && op !== 'H') {
+      roffset += len;
+    }
+  }
+
+  return mismatches;
+}
+/**
+ * parse a SAM MD tag to find mismatching bases of the template versus the reference
+ * @returns array of mismatches and their positions
+ */
+
+
+function mdToMismatches(mdstring, ops, cigarMismatches, seq, qual) {
+  var mismatchRecords = [];
+  var curr = {
+    start: 0,
+    base: '',
+    length: 0,
+    type: 'mismatch'
+  };
+  var skips = cigarMismatches.filter(function (cigar) {
+    return cigar.type === 'skip';
+  });
+  var lastCigar = 0;
+  var lastTemplateOffset = 0;
+  var lastRefOffset = 0;
+  var lastSkipPos = 0; // convert a position on the reference sequence to a position
+  // on the template sequence, taking into account hard and soft
+  // clipping of reads
+
+  function nextRecord() {
+    mismatchRecords.push(curr); // get a new mismatch record ready
+
+    curr = {
+      start: curr.start + curr.length,
+      length: 0,
+      base: '',
+      type: 'mismatch'
+    };
+  }
+
+  function getTemplateCoordLocal(refCoord) {
+    var templateOffset = lastTemplateOffset;
+    var refOffset = lastRefOffset;
+
+    for (var i = lastCigar; i < ops.length && refOffset <= refCoord; i += 2, lastCigar = i) {
+      var len = +ops[i];
+      var op = ops[i + 1];
+
+      if (op === 'S' || op === 'I') {
+        templateOffset += len;
+      } else if (op === 'D' || op === 'P' || op === 'N') {
+        refOffset += len;
+      } else if (op !== 'H') {
+        templateOffset += len;
+        refOffset += len;
+      }
+    }
+
+    lastTemplateOffset = templateOffset;
+    lastRefOffset = refOffset;
+    return templateOffset - (refOffset - refCoord);
+  } // now actually parse the MD string
+
+
+  var md = mdstring.match(mdRegex) || [];
+
+  for (var i = 0; i < md.length; i++) {
+    var token = md[i];
+    var num = +token;
+
+    if (!Number.isNaN(num)) {
+      curr.start += num;
+    } else if (token.startsWith('^')) {
+      curr.start += token.length - 1;
+    } else {
+      // mismatch
+      for (var j = 0; j < token.length; j += 1) {
+        curr.length = 1;
+
+        while (lastSkipPos < skips.length) {
+          var mismatch = skips[lastSkipPos];
+
+          if (curr.start >= mismatch.start) {
+            curr.start += mismatch.length;
+            lastSkipPos++;
+          } else {
+            break;
+          }
+        }
+
+        var s = getTemplateCoordLocal(curr.start);
+        curr.base = seq[s] || 'X';
+        var qualScore = qual === null || qual === void 0 ? void 0 : qual[s];
+
+        if (qualScore) {
+          curr.qual = qualScore;
+        }
+
+        curr.altbase = token;
+        nextRecord();
+      }
+    }
+  }
+
+  return mismatchRecords;
+}
+
+function getMismatches(cigar, md, seq, ref, qual) {
+  var mismatches = [];
+  var ops = parseCigar(cigar); // parse the CIGAR tag if it has one
+
+  if (cigar) {
+    mismatches = mismatches.concat(cigarToMismatches(ops, seq, ref, qual));
+  } // now let's look for CRAM or MD mismatches
+
+
+  if (md) {
+    mismatches = mismatches.concat(mdToMismatches(md, ops, mismatches, seq, qual));
+  }
+
+  return mismatches;
+} // get relative reference sequence positions for positions given relative to
+// the read sequence
+
+
+function getNextRefPos(cigarOps, positions) {
+  var cigarIdx, readPos, refPos, i, pos, len, op;
+  return _regenerator["default"].wrap(function getNextRefPos$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          cigarIdx = 0;
+          readPos = 0;
+          refPos = 0;
+          i = 0;
+
+        case 4:
+          if (!(i < positions.length)) {
+            _context.next = 12;
+            break;
+          }
+
+          pos = positions[i];
+
+          for (; cigarIdx < cigarOps.length && readPos < pos; cigarIdx += 2) {
+            len = +cigarOps[cigarIdx];
+            op = cigarOps[cigarIdx + 1];
+
+            if (op === 'S' || op === 'I') {
+              readPos += len;
+            } else if (op === 'D' || op === 'N') {
+              refPos += len;
+            } else if (op === 'M' || op === 'X' || op === '=') {
+              readPos += len;
+              refPos += len;
+            }
+          }
+
+          _context.next = 9;
+          return positions[i] - readPos + refPos;
+
+        case 9:
+          i++;
+          _context.next = 4;
+          break;
+
+        case 12:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked);
+}
+
+function getModificationPositions(mm, fseq, fstrand) {
+  var seq = fstrand === -1 ? (0, _util.revcom)(fseq) : fseq;
+  return mm.split(';').filter(function (mod) {
+    return !!mod;
+  }).map(function (mod) {
+    var _mod$split = mod.split(','),
+        _mod$split2 = (0, _toArray2["default"])(_mod$split),
+        basemod = _mod$split2[0],
+        skips = _mod$split2.slice(1); // regexes based on parse_mm.pl from hts-specs
+
+
+    var matches = basemod.match(/([A-Z])([-+])([^,.?]+)([.?])?/);
+
+    if (!matches) {
+      throw new Error('bad format for MM tag');
+    }
+
+    var _matches = (0, _slicedToArray2["default"])(matches, 4),
+        base = _matches[1],
+        strand = _matches[2],
+        typestr = _matches[3]; // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
+    // split, and they can also be chemical codes (ChEBI) e.g. C+16061
+
+
+    var types = typestr.split(/(\d+|.)/).filter(function (f) {
+      return !!f;
+    });
+
+    if (strand === '-') {
+      console.warn('unsupported negative strand modifications'); // make sure to return a somewhat matching type even in this case
+
+      return {
+        type: 'unsupported',
+        positions: []
+      };
+    } // this logic also based on parse_mm.pl from hts-specs is that in the
+    // sequence of the read, if we have a modification type e.g. C+m;2 and a
+    // sequence ACGTACGTAC we skip the two instances of C and go to the last
+    // C
+
+
+    return types.map(function (type) {
+      var i = 0;
+      return {
+        type: type,
+        positions: skips.map(function (score) {
+          return +score;
+        }).map(function (delta) {
+          do {
+            if (base === 'N' || base === seq[i]) {
+              delta--;
+            }
+
+            i++;
+          } while (delta >= 0 && i < seq.length);
+
+          var temp = i - 1;
+          return fstrand === -1 ? seq.length - 1 - temp : temp;
+        }).sort(function (a, b) {
+          return a - b;
+        })
+      };
+    });
+  }).flat();
+}
+
+function getModificationTypes(mm) {
+  var mods = mm.split(';');
+  return mods.filter(function (mod) {
+    return !!mod;
+  }).map(function (mod) {
+    var _mod$split3 = mod.split(','),
+        _mod$split4 = (0, _slicedToArray2["default"])(_mod$split3, 1),
+        basemod = _mod$split4[0];
+
+    var matches = basemod.match(/([A-Z])([-+])([^,]+)/);
+
+    if (!matches) {
+      throw new Error('bad format for MM tag');
+    }
+
+    var _matches2 = (0, _slicedToArray2["default"])(matches, 4),
+        typestr = _matches2[3]; // can be a multi e.g. C+mh for both meth (m) and hydroxymeth (h) so
+    // split, and they can also be chemical codes (ChEBI) e.g. C+16061
+
+
+    return typestr.split(/(\d+|.)/).filter(function (f) {
+      return !!f;
+    });
+  }).flat();
+}

package/dist/BamAdapter/MismatchParser.test.js

@@ -0,0 +1,259 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+
+var _MismatchParser = require("./MismatchParser");
+
+var seq = 'AAAAAAAAAACAAAAAAAAAAAAAACCCCCCCCCCCCCCCCCCCCCCCCCGGGGGGGGGGGGGGGGGGGGGGGGGTTTTTTTTTTTTTTTTTTTTTTTTT'; // examples come from https://github.com/vsbuffalo/devnotes/wiki/The-MD-Tag-in-BAM-Files
+// and http://seqanswers.com/forums/showthread.php?t=8978
+
+test('cigar to mismatches', function () {
+  expect((0, _MismatchParser.cigarToMismatches)((0, _MismatchParser.parseCigar)('56M1D45M'), seq)).toEqual([{
+    start: 56,
+    type: 'deletion',
+    base: '*',
+    length: 1
+  }]);
+});
+test('md to mismatches', function () {
+  var cigarMismatches = (0, _MismatchParser.cigarToMismatches)((0, _MismatchParser.parseCigar)('56M1D45M'), seq);
+  expect((0, _MismatchParser.mdToMismatches)('10A80', (0, _MismatchParser.parseCigar)('56M1D45M'), cigarMismatches, seq)).toEqual([{
+    start: 10,
+    type: 'mismatch',
+    base: 'C',
+    altbase: 'A',
+    length: 1
+  }]);
+});
+describe('get mismatches', function () {
+  it('simple deletion', function () {
+    // simple deletion
+    expect((0, _MismatchParser.getMismatches)('56M1D45M', '56^A45', seq)).toEqual([{
+      start: 56,
+      type: 'deletion',
+      base: '*',
+      length: 1
+    }]);
+  });
+  it('simple insertion', function () {
+    // simple insertion
+    expect((0, _MismatchParser.getMismatches)('89M1I11M', '100', 'AAAAAAAAAACAAAAAAAAAAAAAACCCCCCCCCCCCCCCCCCCCCCCCCGGGGGGGGGGGGGGGGGGGGGGGGGTTTTTTTTTTTTTTTTTTTTTTTTTA')).toEqual([{
+      start: 89,
+      type: 'insertion',
+      base: '1',
+      length: 0
+    }]);
+  });
+  it('deletion and a SNP', function () {
+    // contains a deletion and a SNP
+    // read GGGGG--ATTTTTT
+    //      |||||   ||||||
+    //      GGGGGACCTTTTTT
+    expect((0, _MismatchParser.getMismatches)('5M2D6M', '5^AC0C5', 'GGGGGATTTTTT')).toEqual([{
+      start: 5,
+      type: 'deletion',
+      base: '*',
+      length: 2
+    }, {
+      start: 7,
+      type: 'mismatch',
+      base: 'A',
+      altbase: 'C',
+      length: 1
+    }]);
+  });
+  it('0-length MD entries', function () {
+    // 0-length MD entries, which indicates two SNPs right next to each other
+    // "They generally occur between SNPs, or between a deletion then a SNP."
+    // http://seqanswers.com/forums/showthread.php?t=8978
+    //
+    // read GGGGGCATTTTT
+    //      |||||  |||||
+    // ref  GGGGGACTTTTT
+    expect((0, _MismatchParser.getMismatches)('12M', '5A0C5', 'GGGGGCATTTTT')).toEqual([{
+      altbase: 'A',
+      base: 'C',
+      length: 1,
+      start: 5,
+      type: 'mismatch'
+    }, {
+      altbase: 'C',
+      base: 'A',
+      length: 1,
+      start: 6,
+      type: 'mismatch'
+    }]);
+  });
+  it('non-0-length-MD string', function () {
+    // same as above but with the non-0-length MD string
+    // not sure if it is entirely legal, but may appear in the wild
+    expect((0, _MismatchParser.getMismatches)('12M', '5AC5', 'GGGGGCATTTTT')).toEqual([{
+      altbase: 'A',
+      base: 'C',
+      length: 1,
+      start: 5,
+      type: 'mismatch'
+    }, {
+      altbase: 'C',
+      base: 'A',
+      length: 1,
+      start: 6,
+      type: 'mismatch'
+    }]);
+  });
+});
+test('basic skip', function () {
+  expect((0, _MismatchParser.getMismatches)('6M200N6M', '5AC5', 'GGGGGCATTTTT')).toEqual([{
+    base: 'N',
+    length: 200,
+    start: 6,
+    type: 'skip'
+  }, {
+    altbase: 'A',
+    base: 'C',
+    length: 1,
+    start: 5,
+    type: 'mismatch'
+  }, {
+    altbase: 'C',
+    base: 'A',
+    length: 1,
+    start: 206,
+    type: 'mismatch'
+  }]);
+});
+test('vsbuffalo', function () {
+  // https://github.com/vsbuffalo/devnotes/wiki/The-MD-Tag-in-BAM-Files
+  // example 1
+  expect((0, _MismatchParser.getMismatches)('89M1I11M', '100', 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')).toEqual([{
+    base: '1',
+    length: 0,
+    start: 89,
+    type: 'insertion'
+  }]); // https://github.com/vsbuffalo/devnotes/wiki/The-MD-Tag-in-BAM-Files
+  // example 2
+
+  expect((0, _MismatchParser.getMismatches)('9M1I91M', '48T42G8', 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')).toEqual([{
+    base: '1',
+    length: 0,
+    start: 9,
+    type: 'insertion'
+  }, {
+    altbase: 'T',
+    base: 'A',
+    length: 1,
+    start: 48,
+    type: 'mismatch'
+  }, {
+    altbase: 'G',
+    base: 'A',
+    length: 1,
+    start: 91,
+    type: 'mismatch'
+  }]);
+});
+test('more skip', function () {
+  expect((0, _MismatchParser.getMismatches)('3M200N3M200N3M', '8A', 'GGGGGCATTTTT')).toEqual([{
+    base: 'N',
+    length: 200,
+    start: 3,
+    type: 'skip'
+  }, {
+    base: 'N',
+    length: 200,
+    start: 206,
+    type: 'skip'
+  }, {
+    altbase: 'A',
+    base: 'T',
+    length: 1,
+    start: 408,
+    type: 'mismatch'
+  }]);
+  expect((0, _MismatchParser.getMismatches)('31M1I17M1D37M', '6G4C20G1A5C5A1^C3A15G1G15', seq).sort(function (a, b) {
+    return a.start - b.start;
+  })).toMatchInlineSnapshot("\n    Array [\n      Object {\n        \"altbase\": \"G\",\n        \"base\": \"A\",\n        \"length\": 1,\n        \"start\": 6,\n        \"type\": \"mismatch\",\n      },\n      Object {\n        \"altbase\": \"C\",\n        \"base\": \"A\",\n        \"length\": 1,\n        \"start\": 11,\n        \"type\": \"mismatch\",\n      },\n      Object {\n        \"base\": \"1\",\n        \"length\": 0,\n        \"start\": 31,\n        \"type\": \"insertion\",\n      },\n      Object {\n        \"altbase\": \"G\",\n        \"base\": \"C\",\n        \"length\": 1,\n        \"start\": 32,\n        \"type\": \"mismatch\",\n      },\n      Object {\n        \"altbase\": \"A\",\n        \"base\": \"C\",\n        \"length\": 1,\n        \"start\": 34,\n        \"type\": \"mismatch\",\n      },\n      Object {\n        \"altbase\": \"C\",\n        \"base\": \"C\",\n        \"length\": 1,\n        \"start\": 40,\n        \"type\": \"mismatch\",\n      },\n      Object {\n        \"altbase\": \"A\",\n        \"base\": \"C\",\n        \"length\": 1,\n        \"start\": 46,\n        \"type\": \"mismatch\",\n      },\n      Object {\n        \"base\": \"*\",\n        \"length\": 1,\n        \"start\": 48,\n        \"type\": \"deletion\",\n      },\n      Object {\n        \"altbase\": \"A\",\n        \"base\": \"G\",\n        \"length\": 1,\n        \"start\": 52,\n        \"type\": \"mismatch\",\n      },\n      Object {\n        \"altbase\": \"G\",\n        \"base\": \"G\",\n        \"length\": 1,\n        \"start\": 68,\n        \"type\": \"mismatch\",\n      },\n      Object {\n        \"altbase\": \"G\",\n        \"base\": \"G\",\n        \"length\": 1,\n        \"start\": 70,\n        \"type\": \"mismatch\",\n      },\n    ]\n  ");
+});
+test('clipping', function () {
+  expect((0, _MismatchParser.getMismatches)('200H10M200H', '9A', 'AAAAAAAAAC')).toEqual([{
+    cliplen: 200,
+    base: 'H200',
+    length: 1,
+    start: 0,
+    type: 'hardclip'
+  }, {
+    cliplen: 200,
+    base: 'H200',
+    length: 1,
+    start: 10,
+    type: 'hardclip'
+  }, {
+    altbase: 'A',
+    base: 'C',
+    length: 1,
+    start: 9,
+    type: 'mismatch'
+  }]);
+  expect((0, _MismatchParser.getMismatches)('10S10M10S', '9A', 'AAAAAAAAAAGGGGGGGGGC')).toEqual([{
+    cliplen: 10,
+    base: 'S10',
+    length: 1,
+    start: 0,
+    type: 'softclip'
+  }, {
+    cliplen: 10,
+    base: 'S10',
+    length: 1,
+    start: 10,
+    type: 'softclip'
+  }, {
+    altbase: 'A',
+    base: 'C',
+    length: 1,
+    start: 9,
+    type: 'mismatch'
+  }]);
+});
+test('getNextRefPos basic', function () {
+  var cigar = (0, _MismatchParser.parseCigar)('10S10M1I4M1D15M');
+  var iter = (0, _MismatchParser.getNextRefPos)(cigar, [5, 10, 15, 20, 25, 30, 35]);
+
+  var _iter = (0, _toArray2["default"])(iter),
+      vals = _iter.slice(0);
+
+  expect(vals).toEqual([-5, 0, 5, 10, 14, 20, 25]);
+});
+test('getNextRefPos with many indels', function () {
+  var cigar = (0, _MismatchParser.parseCigar)('10S4M1D1IM10');
+  var iter = (0, _MismatchParser.getNextRefPos)(cigar, [5, 10, 15]);
+
+  var _iter2 = (0, _toArray2["default"])(iter),
+      vals = _iter2.slice(0);
+
+  expect(vals).toEqual([-5, 0, 5]);
+});
+test('getModificationPositions', function () {
+  var positions = (0, _MismatchParser.getModificationPositions)('C+m,2,2,1,4,1', 'AGCTCTCCAGAGTCGNACGCCATYCGCGCGCCACCA', 1);
+  expect(positions[0]).toEqual({
+    type: 'm',
+    positions: [6, 17, 20, 31, 34]
+  });
+}); // ? means "modification status of the skipped bases provided."
+
+test('getModificationPositions with unknown (?)', function () {
+  var positions = (0, _MismatchParser.getModificationPositions)('C+m?,2,2,1,4,1', 'AGCTCTCCAGAGTCGNACGCCATYCGCGCGCCACCA', 1);
+  expect(positions[0]).toEqual({
+    type: 'm',
+    positions: [6, 17, 20, 31, 34]
+  });
+}); // . means "modification status of the skipped bases is low probability"
+
+test('getModificationPositions with unknown (.)', function () {
+  var positions = (0, _MismatchParser.getModificationPositions)('C+m.,2,2,1,4,1', 'AGCTCTCCAGAGTCGNACGCCATYCGCGCGCCACCA', 1);
+  expect(positions[0]).toEqual({
+    type: 'm',
+    positions: [6, 17, 20, 31, 34]
+  });
+});

package/dist/BamAdapter/configSchema.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _configuration = require("@jbrowse/core/configuration");
+
+var _mobxStateTree = require("mobx-state-tree");
+
+var _default = _mobxStateTree.types.late(function () {
+  return (0, _configuration.ConfigurationSchema)('BamAdapter', {
+    bamLocation: {
+      type: 'fileLocation',
+      defaultValue: {
+        uri: '/path/to/my.bam',
+        locationType: 'UriLocation'
+      }
+    },
+    index: (0, _configuration.ConfigurationSchema)('BamIndex', {
+      indexType: {
+        model: _mobxStateTree.types.enumeration('IndexType', ['BAI', 'CSI']),
+        type: 'stringEnum',
+        defaultValue: 'BAI'
+      },
+      location: {
+        type: 'fileLocation',
+        defaultValue: {
+          uri: '/path/to/my.bam.bai',
+          locationType: 'UriLocation'
+        }
+      }
+    }),
+    fetchSizeLimit: {
+      type: 'number',
+      defaultValue: 5000000
+    },
+    sequenceAdapter: {
+      type: 'frozen',
+      defaultValue: null
+    }
+  }, {
+    explicitlyTyped: true
+  });
+});
+
+exports["default"] = _default;