bireader 3.1.2 → 3.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  /// <reference types="node" />
2
2
  type endian = "little" | "big";
3
+ type BigValue = number | bigint;
3
4
  type BiOptions = {
4
5
  /**
5
6
  * Byte offset to start writer, default is 0
@@ -479,11 +480,11 @@ declare class BiBase {
479
480
  *
480
481
  * Does not change current read position.
481
482
  *
482
- * @param {number} value - Number to search for.
483
+ * @param {BigValue} value - Number to search for.
483
484
  * @param {boolean} unsigned - If the number is unsigned (default true)
484
485
  * @param {endian} endian - endianness of value (default set endian).
485
486
  */
486
- findInt64(value: number, unsigned?: boolean, endian?: endian): number;
487
+ findInt64(value: BigValue, unsigned?: boolean, endian?: endian): number;
487
488
  /**
488
489
  * Searches for half float value position from current read position.
489
490
  *
@@ -1275,76 +1276,76 @@ declare class BiBase {
1275
1276
  *
1276
1277
  * @param {boolean} unsigned - if value is unsigned or not
1277
1278
  * @param {endian?} endian - ``big`` or ``little``
1278
- * @returns {number}
1279
+ * @returns {bigint}
1279
1280
  */
1280
1281
  readInt64(unsigned?: boolean, endian?: endian): bigint;
1281
1282
  /**
1282
1283
  * Write 64 bit integer.
1283
1284
  *
1284
- * @param {number} value - value as int
1285
+ * @param {BigValue} value - value as int
1285
1286
  * @param {boolean} unsigned - if the value is unsigned
1286
1287
  * @param {endian} endian - ``big`` or ``little``
1287
1288
  */
1288
- writeInt64(value: number, unsigned?: boolean, endian?: endian): void;
1289
+ writeInt64(value: BigValue, unsigned?: boolean, endian?: endian): void;
1289
1290
  /**
1290
1291
  * Write unsigned 64 bit integer.
1291
1292
  *
1292
- * @param {number} value - value as int
1293
+ * @param {BigValue} value - value as int
1293
1294
  * @param {endian} endian - ``big`` or ``little``
1294
1295
  */
1295
- writeUInt64(value: number, endian?: endian): void;
1296
+ writeUInt64(value: BigValue, endian?: endian): void;
1296
1297
  /**
1297
1298
  * Write signed 64 bit integer.
1298
1299
  *
1299
- * @param {number} value - value as int
1300
+ * @param {BigValue} value - value as int
1300
1301
  */
1301
- writeInt64LE(value: number): void;
1302
+ writeInt64LE(value: BigValue): void;
1302
1303
  /**
1303
1304
  * Write unsigned 64 bit integer.
1304
1305
  *
1305
- * @param {number} value - value as int
1306
+ * @param {BigValue} value - value as int
1306
1307
  */
1307
- writeUInt64LE(value: number): void;
1308
+ writeUInt64LE(value: BigValue): void;
1308
1309
  /**
1309
1310
  * Write signed 64 bit integer.
1310
1311
  *
1311
- * @param {number} value - value as int
1312
+ * @param {BigValue} value - value as int
1312
1313
  */
1313
- writeInt64BE(value: number): void;
1314
+ writeInt64BE(value: BigValue): void;
1314
1315
  /**
1315
1316
  * Write unsigned 64 bit integer.
1316
1317
  *
1317
- * @param {number} value - value as int
1318
+ * @param {BigValue} value - value as int
1318
1319
  */
1319
- writeUInt64BE(value: number): void;
1320
+ writeUInt64BE(value: BigValue): void;
1320
1321
  /**
1321
1322
  * Read unsigned 64 bit integer.
1322
1323
  *
1323
- * @returns {number}
1324
+ * @returns {bigint}
1324
1325
  */
1325
1326
  readUInt64(): bigint;
1326
1327
  /**
1327
1328
  * Read signed 64 bit integer.
1328
1329
  *
1329
- * @returns {number}
1330
+ * @returns {bigint}
1330
1331
  */
1331
1332
  readInt64BE(): bigint;
1332
1333
  /**
1333
1334
  * Read unsigned 64 bit integer.
1334
1335
  *
1335
- * @returns {number}
1336
+ * @returns {bigint}
1336
1337
  */
1337
1338
  readUInt64BE(): bigint;
1338
1339
  /**
1339
1340
  * Read signed 64 bit integer.
1340
1341
  *
1341
- * @returns {number}
1342
+ * @returns {bigint}
1342
1343
  */
1343
1344
  readInt64LE(): bigint;
1344
1345
  /**
1345
1346
  * Read unsigned 64 bit integer.
1346
1347
  *
1347
- * @returns {number}
1348
+ * @returns {bigint}
1348
1349
  */
1349
1350
  readUInt64LE(): bigint;
1350
1351
  /**
@@ -1840,11 +1841,11 @@ declare class BiBaseStreamer {
1840
1841
  *
1841
1842
  * Does not change current read position.
1842
1843
  *
1843
- * @param {number} value - Number to search for.
1844
+ * @param {BigValue} value - Number to search for.
1844
1845
  * @param {boolean} unsigned - If the number is unsigned (default true)
1845
1846
  * @param {endian} endian - endianness of value (default set endian).
1846
1847
  */
1847
- findInt64(value: number, unsigned?: boolean, endian?: endian): number;
1848
+ findInt64(value: BigValue, unsigned?: boolean, endian?: endian): number;
1848
1849
  /**
1849
1850
  * Searches for half float value position from current read position.
1850
1851
  *
@@ -2636,76 +2637,76 @@ declare class BiBaseStreamer {
2636
2637
  *
2637
2638
  * @param {boolean} unsigned - if value is unsigned or not
2638
2639
  * @param {endian?} endian - ``big`` or ``little``
2639
- * @returns {number}
2640
+ * @returns {bigint}
2640
2641
  */
2641
2642
  readInt64(unsigned?: boolean, endian?: endian): bigint;
2642
2643
  /**
2643
2644
  * Write 64 bit integer.
2644
2645
  *
2645
- * @param {number} value - value as int
2646
+ * @param {BigValue} value - value as int
2646
2647
  * @param {boolean} unsigned - if the value is unsigned
2647
2648
  * @param {endian} endian - ``big`` or ``little``
2648
2649
  */
2649
- writeInt64(value: number, unsigned?: boolean, endian?: endian): void;
2650
+ writeInt64(value: BigValue, unsigned?: boolean, endian?: endian): void;
2650
2651
  /**
2651
2652
  * Write unsigned 64 bit integer.
2652
2653
  *
2653
- * @param {number} value - value as int
2654
+ * @param {BigValue} value - value as int
2654
2655
  * @param {endian} endian - ``big`` or ``little``
2655
2656
  */
2656
- writeUInt64(value: number, endian?: endian): void;
2657
+ writeUInt64(value: BigValue, endian?: endian): void;
2657
2658
  /**
2658
2659
  * Write signed 64 bit integer.
2659
2660
  *
2660
- * @param {number} value - value as int
2661
+ * @param {BigValue} value - value as int
2661
2662
  */
2662
- writeInt64LE(value: number): void;
2663
+ writeInt64LE(value: BigValue): void;
2663
2664
  /**
2664
2665
  * Write unsigned 64 bit integer.
2665
2666
  *
2666
- * @param {number} value - value as int
2667
+ * @param {BigValue} value - value as int
2667
2668
  */
2668
- writeUInt64LE(value: number): void;
2669
+ writeUInt64LE(value: BigValue): void;
2669
2670
  /**
2670
2671
  * Write signed 64 bit integer.
2671
2672
  *
2672
- * @param {number} value - value as int
2673
+ * @param {BigValue} value - value as int
2673
2674
  */
2674
- writeInt64BE(value: number): void;
2675
+ writeInt64BE(value: BigValue): void;
2675
2676
  /**
2676
2677
  * Write unsigned 64 bit integer.
2677
2678
  *
2678
- * @param {number} value - value as int
2679
+ * @param {BigValue} value - value as int
2679
2680
  */
2680
- writeUInt64BE(value: number): void;
2681
+ writeUInt64BE(value: BigValue): void;
2681
2682
  /**
2682
2683
  * Read unsigned 64 bit integer.
2683
2684
  *
2684
- * @returns {number}
2685
+ * @returns {bigint}
2685
2686
  */
2686
2687
  readUInt64(): bigint;
2687
2688
  /**
2688
2689
  * Read signed 64 bit integer.
2689
2690
  *
2690
- * @returns {number}
2691
+ * @returns {bigint}
2691
2692
  */
2692
2693
  readInt64BE(): bigint;
2693
2694
  /**
2694
2695
  * Read unsigned 64 bit integer.
2695
2696
  *
2696
- * @returns {number}
2697
+ * @returns {bigint}
2697
2698
  */
2698
2699
  readUInt64BE(): bigint;
2699
2700
  /**
2700
2701
  * Read signed 64 bit integer.
2701
2702
  *
2702
- * @returns {number}
2703
+ * @returns {bigint}
2703
2704
  */
2704
2705
  readInt64LE(): bigint;
2705
2706
  /**
2706
2707
  * Read unsigned 64 bit integer.
2707
2708
  *
2708
- * @returns {number}
2709
+ * @returns {bigint}
2709
2710
  */
2710
2711
  readUInt64LE(): bigint;
2711
2712
  /**
@@ -4703,109 +4704,109 @@ interface BinaryAliasReader extends BiBase {
4703
4704
  /**
4704
4705
  * Read signed 64 bit integer
4705
4706
  *
4706
- * @returns {number}
4707
+ * @returns {bigint}
4707
4708
  */
4708
4709
  get int64(): bigint;
4709
4710
  /**
4710
4711
  * Read signed 64 bit integer.
4711
4712
  *
4712
- * @returns {number}
4713
+ * @returns {bigint}
4713
4714
  */
4714
4715
  get bigint(): bigint;
4715
4716
  /**
4716
4717
  * Read signed 64 bit integer.
4717
4718
  *
4718
- * @returns {number}
4719
+ * @returns {bigint}
4719
4720
  */
4720
4721
  get quad(): bigint;
4721
4722
  /**
4722
4723
  * Read unsigned 64 bit integer.
4723
4724
  *
4724
- * @returns {number}
4725
+ * @returns {bigint}
4725
4726
  */
4726
4727
  get uint64(): bigint;
4727
4728
  /**
4728
4729
  * Read unsigned 64 bit integer.
4729
4730
  *
4730
- * @returns {number}
4731
+ * @returns {bigint}
4731
4732
  */
4732
4733
  get ubigint(): bigint;
4733
4734
  /**
4734
4735
  * Read unsigned 64 bit integer.
4735
4736
  *
4736
- * @returns {number}
4737
+ * @returns {bigint}
4737
4738
  */
4738
4739
  get uquad(): bigint;
4739
4740
  /**
4740
4741
  * Read signed 64 bit integer.
4741
4742
  *
4742
- * @returns {number}
4743
+ * @returns {bigint}
4743
4744
  */
4744
4745
  get int64be(): bigint;
4745
4746
  /**
4746
4747
  * Read signed 64 bit integer.
4747
4748
  *
4748
- * @returns {number}
4749
+ * @returns {bigint}
4749
4750
  */
4750
4751
  get bigintbe(): bigint;
4751
4752
  /**
4752
4753
  * Read signed 64 bit integer.
4753
4754
  *
4754
- * @returns {number}
4755
+ * @returns {bigint}
4755
4756
  */
4756
4757
  get quadbe(): bigint;
4757
4758
  /**
4758
4759
  * Read unsigned 64 bit integer.
4759
4760
  *
4760
- * @returns {number}
4761
+ * @returns {bigint}
4761
4762
  */
4762
4763
  get uint64be(): bigint;
4763
4764
  /**
4764
4765
  * Read unsigned 64 bit integer.
4765
4766
  *
4766
- * @returns {number}
4767
+ * @returns {bigint}
4767
4768
  */
4768
4769
  get ubigintbe(): bigint;
4769
4770
  /**
4770
4771
  * Read unsigned 64 bit integer.
4771
4772
  *
4772
- * @returns {number}
4773
+ * @returns {bigint}
4773
4774
  */
4774
4775
  get uquadbe(): bigint;
4775
4776
  /**
4776
4777
  * Read signed 64 bit integer.
4777
4778
  *
4778
- * @returns {number}
4779
+ * @returns {bigint}
4779
4780
  */
4780
4781
  get int64le(): bigint;
4781
4782
  /**
4782
4783
  * Read signed 64 bit integer.
4783
4784
  *
4784
- * @returns {number}
4785
+ * @returns {bigint}
4785
4786
  */
4786
4787
  get bigintle(): bigint;
4787
4788
  /**
4788
4789
  * Read signed 64 bit integer.
4789
4790
  *
4790
- * @returns {number}
4791
+ * @returns {bigint}
4791
4792
  */
4792
4793
  get quadle(): bigint;
4793
4794
  /**
4794
4795
  * Read unsigned 64 bit integer.
4795
4796
  *
4796
- * @returns {number}
4797
+ * @returns {bigint}
4797
4798
  */
4798
4799
  get uint64le(): bigint;
4799
4800
  /**
4800
4801
  * Read unsigned 64 bit integer.
4801
4802
  *
4802
- * @returns {number}
4803
+ * @returns {bigint}
4803
4804
  */
4804
4805
  get ubigintle(): bigint;
4805
4806
  /**
4806
4807
  * Read unsigned 64 bit integer.
4807
4808
  *
4808
- * @returns {number}
4809
+ * @returns {bigint}
4809
4810
  */
4810
4811
  get uquadle(): bigint;
4811
4812
  /**
@@ -7040,109 +7041,109 @@ interface BinaryAliasReaderStreamer extends BiBaseStreamer {
7040
7041
  /**
7041
7042
  * Read signed 64 bit integer
7042
7043
  *
7043
- * @returns {number}
7044
+ * @returns {bigint}
7044
7045
  */
7045
7046
  get int64(): bigint;
7046
7047
  /**
7047
7048
  * Read signed 64 bit integer.
7048
7049
  *
7049
- * @returns {number}
7050
+ * @returns {bigint}
7050
7051
  */
7051
7052
  get bigint(): bigint;
7052
7053
  /**
7053
7054
  * Read signed 64 bit integer.
7054
7055
  *
7055
- * @returns {number}
7056
+ * @returns {bigint}
7056
7057
  */
7057
7058
  get quad(): bigint;
7058
7059
  /**
7059
7060
  * Read unsigned 64 bit integer.
7060
7061
  *
7061
- * @returns {number}
7062
+ * @returns {bigint}
7062
7063
  */
7063
7064
  get uint64(): bigint;
7064
7065
  /**
7065
7066
  * Read unsigned 64 bit integer.
7066
7067
  *
7067
- * @returns {number}
7068
+ * @returns {bigint}
7068
7069
  */
7069
7070
  get ubigint(): bigint;
7070
7071
  /**
7071
7072
  * Read unsigned 64 bit integer.
7072
7073
  *
7073
- * @returns {number}
7074
+ * @returns {bigint}
7074
7075
  */
7075
7076
  get uquad(): bigint;
7076
7077
  /**
7077
7078
  * Read signed 64 bit integer.
7078
7079
  *
7079
- * @returns {number}
7080
+ * @returns {bigint}
7080
7081
  */
7081
7082
  get int64be(): bigint;
7082
7083
  /**
7083
7084
  * Read signed 64 bit integer.
7084
7085
  *
7085
- * @returns {number}
7086
+ * @returns {bigint}
7086
7087
  */
7087
7088
  get bigintbe(): bigint;
7088
7089
  /**
7089
7090
  * Read signed 64 bit integer.
7090
7091
  *
7091
- * @returns {number}
7092
+ * @returns {bigint}
7092
7093
  */
7093
7094
  get quadbe(): bigint;
7094
7095
  /**
7095
7096
  * Read unsigned 64 bit integer.
7096
7097
  *
7097
- * @returns {number}
7098
+ * @returns {bigint}
7098
7099
  */
7099
7100
  get uint64be(): bigint;
7100
7101
  /**
7101
7102
  * Read unsigned 64 bit integer.
7102
7103
  *
7103
- * @returns {number}
7104
+ * @returns {bigint}
7104
7105
  */
7105
7106
  get ubigintbe(): bigint;
7106
7107
  /**
7107
7108
  * Read unsigned 64 bit integer.
7108
7109
  *
7109
- * @returns {number}
7110
+ * @returns {bigint}
7110
7111
  */
7111
7112
  get uquadbe(): bigint;
7112
7113
  /**
7113
7114
  * Read signed 64 bit integer.
7114
7115
  *
7115
- * @returns {number}
7116
+ * @returns {bigint}
7116
7117
  */
7117
7118
  get int64le(): bigint;
7118
7119
  /**
7119
7120
  * Read signed 64 bit integer.
7120
7121
  *
7121
- * @returns {number}
7122
+ * @returns {bigint}
7122
7123
  */
7123
7124
  get bigintle(): bigint;
7124
7125
  /**
7125
7126
  * Read signed 64 bit integer.
7126
7127
  *
7127
- * @returns {number}
7128
+ * @returns {bigint}
7128
7129
  */
7129
7130
  get quadle(): bigint;
7130
7131
  /**
7131
7132
  * Read unsigned 64 bit integer.
7132
7133
  *
7133
- * @returns {number}
7134
+ * @returns {bigint}
7134
7135
  */
7135
7136
  get uint64le(): bigint;
7136
7137
  /**
7137
7138
  * Read unsigned 64 bit integer.
7138
7139
  *
7139
- * @returns {number}
7140
+ * @returns {bigint}
7140
7141
  */
7141
7142
  get ubigintle(): bigint;
7142
7143
  /**
7143
7144
  * Read unsigned 64 bit integer.
7144
7145
  *
7145
- * @returns {number}
7146
+ * @returns {bigint}
7146
7147
  */
7147
7148
  get uquadle(): bigint;
7148
7149
  /**
@@ -9725,111 +9726,111 @@ interface BinaryAliasWriter extends BiBase {
9725
9726
  /**
9726
9727
  * Write 64 bit integer.
9727
9728
  *
9728
- * @param {number} value - value as int
9729
+ * @param {number|bigint} value - value as int
9729
9730
  */
9730
- set int64(value: number);
9731
+ set int64(value: number | bigint);
9731
9732
  /**
9732
9733
  * Write 64 bit integer.
9733
9734
  *
9734
- * @param {number} value - value as int
9735
+ * @param {number|bigint} value - value as int
9735
9736
  */
9736
- set quad(value: number);
9737
+ set quad(value: number | bigint);
9737
9738
  /**
9738
9739
  * Write 64 bit integer.
9739
9740
  *
9740
- * @param {number} value - value as int
9741
+ * @param {number|bigint} value - value as int
9741
9742
  */
9742
- set bigint(value: number);
9743
+ set bigint(value: number | bigint);
9743
9744
  /**
9744
9745
  * Write unsigned 64 bit integer.
9745
9746
  *
9746
- * @param {number} value - value as int
9747
+ * @param {number|bigint} value - value as int
9747
9748
  */
9748
- set uint64(value: number);
9749
+ set uint64(value: number | bigint);
9749
9750
  /**
9750
9751
  * Write unsigned 64 bit integer.
9751
9752
  *
9752
- * @param {number} value - value as int
9753
+ * @param {number|bigint} value - value as int
9753
9754
  */
9754
- set ubigint(value: number);
9755
+ set ubigint(value: number | bigint);
9755
9756
  /**
9756
9757
  * Write unsigned 64 bit integer.
9757
9758
  *
9758
- * @param {number} value - value as int
9759
+ * @param {number|bigint} value - value as int
9759
9760
  */
9760
- set uquad(value: number);
9761
+ set uquad(value: number | bigint);
9761
9762
  /**
9762
9763
  * Write signed 64 bit integer.
9763
9764
  *
9764
- * @param {number} value - value as int
9765
+ * @param {number|bigint} value - value as int
9765
9766
  */
9766
- set int64le(value: number);
9767
+ set int64le(value: number | bigint);
9767
9768
  /**
9768
9769
  * Write signed 64 bit integer.
9769
9770
  *
9770
- * @param {number} value - value as int
9771
+ * @param {number|bigint} value - value as int
9771
9772
  */
9772
- set bigintle(value: number);
9773
+ set bigintle(value: number | bigint);
9773
9774
  /**
9774
9775
  * Write signed 64 bit integer.
9775
9776
  *
9776
- * @param {number} value - value as int
9777
+ * @param {number|bigint} value - value as int
9777
9778
  */
9778
- set quadle(value: number);
9779
+ set quadle(value: number | bigint);
9779
9780
  /**
9780
9781
  * Write unsigned 64 bit integer.
9781
9782
  *
9782
- * @param {number} value - value as int
9783
+ * @param {number|bigint} value - value as int
9783
9784
  */
9784
- set uint64le(value: number);
9785
+ set uint64le(value: number | bigint);
9785
9786
  /**
9786
9787
  * Write unsigned 64 bit integer.
9787
9788
  *
9788
- * @param {number} value - value as int
9789
+ * @param {number|bigint} value - value as int
9789
9790
  */
9790
- set ubigintle(value: number);
9791
+ set ubigintle(value: number | bigint);
9791
9792
  /**
9792
9793
  * Write unsigned 64 bit integer.
9793
9794
  *
9794
- * @param {number} value - value as int
9795
+ * @param {number|bigint} value - value as int
9795
9796
  */
9796
- set uquadle(value: number);
9797
+ set uquadle(value: number | bigint);
9797
9798
  /**
9798
9799
  * Write signed 64 bit integer.
9799
9800
  *
9800
- * @param {number} value - value as int
9801
+ * @param {number|bigint} value - value as int
9801
9802
  */
9802
- set int64be(value: number);
9803
+ set int64be(value: number | bigint);
9803
9804
  /**
9804
9805
  * Write signed 64 bit integer.
9805
9806
  *
9806
- * @param {number} value - value as int
9807
+ * @param {number|bigint} value - value as int
9807
9808
  */
9808
- set bigintbe(value: number);
9809
+ set bigintbe(value: number | bigint);
9809
9810
  /**
9810
9811
  * Write signed 64 bit integer.
9811
9812
  *
9812
- * @param {number} value - value as int
9813
+ * @param {number|bigint} value - value as int
9813
9814
  */
9814
- set quadbe(value: number);
9815
+ set quadbe(value: number | bigint);
9815
9816
  /**
9816
9817
  * Write unsigned 64 bit integer.
9817
9818
  *
9818
- * @param {number} value - value as int
9819
+ * @param {number|bigint} value - value as int
9819
9820
  */
9820
- set uint64be(value: number);
9821
+ set uint64be(value: number | bigint);
9821
9822
  /**
9822
9823
  * Write unsigned 64 bit integer.
9823
9824
  *
9824
- * @param {number} value - value as int
9825
+ * @param {number|bigint} value - value as int
9825
9826
  */
9826
- set ubigintbe(value: number);
9827
+ set ubigintbe(value: number | bigint);
9827
9828
  /**
9828
9829
  * Write unsigned 64 bit integer.
9829
9830
  *
9830
- * @param {number} value - value as int
9831
+ * @param {number|bigint} value - value as int
9831
9832
  */
9832
- set uquadbe(value: number);
9833
+ set uquadbe(value: number | bigint);
9833
9834
  /**
9834
9835
  * Writes double float.
9835
9836
  *
@@ -12047,111 +12048,111 @@ interface BinaryAliasWriterStreamer extends BiBaseStreamer {
12047
12048
  /**
12048
12049
  * Write 64 bit integer.
12049
12050
  *
12050
- * @param {number} value - value as int
12051
+ * @param {number|bigint} value - value as int
12051
12052
  */
12052
- set int64(value: number);
12053
+ set int64(value: number | bigint);
12053
12054
  /**
12054
12055
  * Write 64 bit integer.
12055
12056
  *
12056
- * @param {number} value - value as int
12057
+ * @param {number|bigint} value - value as int
12057
12058
  */
12058
- set quad(value: number);
12059
+ set quad(value: number | bigint);
12059
12060
  /**
12060
12061
  * Write 64 bit integer.
12061
12062
  *
12062
- * @param {number} value - value as int
12063
+ * @param {number|bigint} value - value as int
12063
12064
  */
12064
- set bigint(value: number);
12065
+ set bigint(value: number | bigint);
12065
12066
  /**
12066
12067
  * Write unsigned 64 bit integer.
12067
12068
  *
12068
- * @param {number} value - value as int
12069
+ * @param {number|bigint} value - value as int
12069
12070
  */
12070
- set uint64(value: number);
12071
+ set uint64(value: number | bigint);
12071
12072
  /**
12072
12073
  * Write unsigned 64 bit integer.
12073
12074
  *
12074
- * @param {number} value - value as int
12075
+ * @param {number|bigint} value - value as int
12075
12076
  */
12076
- set ubigint(value: number);
12077
+ set ubigint(value: number | bigint);
12077
12078
  /**
12078
12079
  * Write unsigned 64 bit integer.
12079
12080
  *
12080
- * @param {number} value - value as int
12081
+ * @param {number|bigint} value - value as int
12081
12082
  */
12082
- set uquad(value: number);
12083
+ set uquad(value: number | bigint);
12083
12084
  /**
12084
12085
  * Write signed 64 bit integer.
12085
12086
  *
12086
- * @param {number} value - value as int
12087
+ * @param {number|bigint} value - value as int
12087
12088
  */
12088
- set int64le(value: number);
12089
+ set int64le(value: number | bigint);
12089
12090
  /**
12090
12091
  * Write signed 64 bit integer.
12091
12092
  *
12092
- * @param {number} value - value as int
12093
+ * @param {number|bigint} value - value as int
12093
12094
  */
12094
- set bigintle(value: number);
12095
+ set bigintle(value: number | bigint);
12095
12096
  /**
12096
12097
  * Write signed 64 bit integer.
12097
12098
  *
12098
- * @param {number} value - value as int
12099
+ * @param {number|bigint} value - value as int
12099
12100
  */
12100
- set quadle(value: number);
12101
+ set quadle(value: number | bigint);
12101
12102
  /**
12102
12103
  * Write unsigned 64 bit integer.
12103
12104
  *
12104
- * @param {number} value - value as int
12105
+ * @param {number|bigint} value - value as int
12105
12106
  */
12106
- set uint64le(value: number);
12107
+ set uint64le(value: number | bigint);
12107
12108
  /**
12108
12109
  * Write unsigned 64 bit integer.
12109
12110
  *
12110
- * @param {number} value - value as int
12111
+ * @param {number|bigint} value - value as int
12111
12112
  */
12112
- set ubigintle(value: number);
12113
+ set ubigintle(value: number | bigint);
12113
12114
  /**
12114
12115
  * Write unsigned 64 bit integer.
12115
12116
  *
12116
- * @param {number} value - value as int
12117
+ * @param {number|bigint} value - value as int
12117
12118
  */
12118
- set uquadle(value: number);
12119
+ set uquadle(value: number | bigint);
12119
12120
  /**
12120
12121
  * Write signed 64 bit integer.
12121
12122
  *
12122
- * @param {number} value - value as int
12123
+ * @param {number|bigint} value - value as int
12123
12124
  */
12124
- set int64be(value: number);
12125
+ set int64be(value: number | bigint);
12125
12126
  /**
12126
12127
  * Write signed 64 bit integer.
12127
12128
  *
12128
- * @param {number} value - value as int
12129
+ * @param {number|bigint} value - value as int
12129
12130
  */
12130
- set bigintbe(value: number);
12131
+ set bigintbe(value: number | bigint);
12131
12132
  /**
12132
12133
  * Write signed 64 bit integer.
12133
12134
  *
12134
- * @param {number} value - value as int
12135
+ * @param {number|bigint} value - value as int
12135
12136
  */
12136
- set quadbe(value: number);
12137
+ set quadbe(value: number | bigint);
12137
12138
  /**
12138
12139
  * Write unsigned 64 bit integer.
12139
12140
  *
12140
- * @param {number} value - value as int
12141
+ * @param {number|bigint} value - value as int
12141
12142
  */
12142
- set uint64be(value: number);
12143
+ set uint64be(value: number | bigint);
12143
12144
  /**
12144
12145
  * Write unsigned 64 bit integer.
12145
12146
  *
12146
- * @param {number} value - value as int
12147
+ * @param {number|bigint} value - value as int
12147
12148
  */
12148
- set ubigintbe(value: number);
12149
+ set ubigintbe(value: number | bigint);
12149
12150
  /**
12150
12151
  * Write unsigned 64 bit integer.
12151
12152
  *
12152
- * @param {number} value - value as int
12153
+ * @param {number|bigint} value - value as int
12153
12154
  */
12154
- set uquadbe(value: number);
12155
+ set uquadbe(value: number | bigint);
12155
12156
  /**
12156
12157
  * Writes double float.
12157
12158
  *
@@ -12710,24 +12711,24 @@ declare class BiWriter extends BiWriterBase implements BinaryAliasWriter {
12710
12711
  set float(value: number);
12711
12712
  set floatle(value: number);
12712
12713
  set floatbe(value: number);
12713
- set int64(value: number);
12714
- set quad(value: number);
12715
- set bigint(value: number);
12716
- set uint64(value: number);
12717
- set ubigint(value: number);
12718
- set uquad(value: number);
12719
- set int64le(value: number);
12720
- set bigintle(value: number);
12721
- set quadle(value: number);
12722
- set uint64le(value: number);
12723
- set ubigintle(value: number);
12724
- set uquadle(value: number);
12725
- set int64be(value: number);
12726
- set bigintbe(value: number);
12727
- set quadbe(value: number);
12728
- set uint64be(value: number);
12729
- set ubigintbe(value: number);
12730
- set uquadbe(value: number);
12714
+ set int64(value: BigValue);
12715
+ set quad(value: BigValue);
12716
+ set bigint(value: BigValue);
12717
+ set uint64(value: BigValue);
12718
+ set ubigint(value: BigValue);
12719
+ set uquad(value: BigValue);
12720
+ set int64le(value: BigValue);
12721
+ set bigintle(value: BigValue);
12722
+ set quadle(value: BigValue);
12723
+ set uint64le(value: BigValue);
12724
+ set ubigintle(value: BigValue);
12725
+ set uquadle(value: BigValue);
12726
+ set int64be(value: BigValue);
12727
+ set bigintbe(value: BigValue);
12728
+ set quadbe(value: BigValue);
12729
+ set uint64be(value: BigValue);
12730
+ set ubigintbe(value: BigValue);
12731
+ set uquadbe(value: BigValue);
12731
12732
  set doublefloat(value: number);
12732
12733
  set dfloat(value: number);
12733
12734
  set dfloatbe(value: number);
@@ -13391,24 +13392,24 @@ declare class BiWriterStream extends BiWriterStreamer implements BinaryAliasWrit
13391
13392
  set float(value: number);
13392
13393
  set floatle(value: number);
13393
13394
  set floatbe(value: number);
13394
- set int64(value: number);
13395
- set quad(value: number);
13396
- set bigint(value: number);
13397
- set uint64(value: number);
13398
- set ubigint(value: number);
13399
- set uquad(value: number);
13400
- set int64le(value: number);
13401
- set bigintle(value: number);
13402
- set quadle(value: number);
13403
- set uint64le(value: number);
13404
- set ubigintle(value: number);
13405
- set uquadle(value: number);
13406
- set int64be(value: number);
13407
- set bigintbe(value: number);
13408
- set quadbe(value: number);
13409
- set uint64be(value: number);
13410
- set ubigintbe(value: number);
13411
- set uquadbe(value: number);
13395
+ set int64(value: BigValue);
13396
+ set quad(value: BigValue);
13397
+ set bigint(value: BigValue);
13398
+ set uint64(value: BigValue);
13399
+ set ubigint(value: BigValue);
13400
+ set uquad(value: BigValue);
13401
+ set int64le(value: BigValue);
13402
+ set bigintle(value: BigValue);
13403
+ set quadle(value: BigValue);
13404
+ set uint64le(value: BigValue);
13405
+ set ubigintle(value: BigValue);
13406
+ set uquadle(value: BigValue);
13407
+ set int64be(value: BigValue);
13408
+ set bigintbe(value: BigValue);
13409
+ set quadbe(value: BigValue);
13410
+ set uint64be(value: BigValue);
13411
+ set ubigintbe(value: BigValue);
13412
+ set uquadbe(value: BigValue);
13412
13413
  set doublefloat(value: number);
13413
13414
  set dfloat(value: number);
13414
13415
  set dfloatbe(value: number);