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.
@@ -1,5 +1,5 @@
1
1
  /// <reference types="node" />
2
- import { endian, hexdumpOptions, stringOptions } from '../common.js';
2
+ import { BigValue, endian, hexdumpOptions, stringOptions } from '../common.js';
3
3
  export declare class BiBase {
4
4
  /**
5
5
  * Endianness of default read.
@@ -393,11 +393,11 @@ export declare class BiBase {
393
393
  *
394
394
  * Does not change current read position.
395
395
  *
396
- * @param {number} value - Number to search for.
396
+ * @param {BigValue} value - Number to search for.
397
397
  * @param {boolean} unsigned - If the number is unsigned (default true)
398
398
  * @param {endian} endian - endianness of value (default set endian).
399
399
  */
400
- findInt64(value: number, unsigned?: boolean, endian?: endian): number;
400
+ findInt64(value: BigValue, unsigned?: boolean, endian?: endian): number;
401
401
  /**
402
402
  * Searches for half float value position from current read position.
403
403
  *
@@ -1189,76 +1189,76 @@ export declare class BiBase {
1189
1189
  *
1190
1190
  * @param {boolean} unsigned - if value is unsigned or not
1191
1191
  * @param {endian?} endian - ``big`` or ``little``
1192
- * @returns {number}
1192
+ * @returns {bigint}
1193
1193
  */
1194
1194
  readInt64(unsigned?: boolean, endian?: endian): bigint;
1195
1195
  /**
1196
1196
  * Write 64 bit integer.
1197
1197
  *
1198
- * @param {number} value - value as int
1198
+ * @param {BigValue} value - value as int
1199
1199
  * @param {boolean} unsigned - if the value is unsigned
1200
1200
  * @param {endian} endian - ``big`` or ``little``
1201
1201
  */
1202
- writeInt64(value: number, unsigned?: boolean, endian?: endian): void;
1202
+ writeInt64(value: BigValue, unsigned?: boolean, endian?: endian): void;
1203
1203
  /**
1204
1204
  * Write unsigned 64 bit integer.
1205
1205
  *
1206
- * @param {number} value - value as int
1206
+ * @param {BigValue} value - value as int
1207
1207
  * @param {endian} endian - ``big`` or ``little``
1208
1208
  */
1209
- writeUInt64(value: number, endian?: endian): void;
1209
+ writeUInt64(value: BigValue, endian?: endian): void;
1210
1210
  /**
1211
1211
  * Write signed 64 bit integer.
1212
1212
  *
1213
- * @param {number} value - value as int
1213
+ * @param {BigValue} value - value as int
1214
1214
  */
1215
- writeInt64LE(value: number): void;
1215
+ writeInt64LE(value: BigValue): void;
1216
1216
  /**
1217
1217
  * Write unsigned 64 bit integer.
1218
1218
  *
1219
- * @param {number} value - value as int
1219
+ * @param {BigValue} value - value as int
1220
1220
  */
1221
- writeUInt64LE(value: number): void;
1221
+ writeUInt64LE(value: BigValue): void;
1222
1222
  /**
1223
1223
  * Write signed 64 bit integer.
1224
1224
  *
1225
- * @param {number} value - value as int
1225
+ * @param {BigValue} value - value as int
1226
1226
  */
1227
- writeInt64BE(value: number): void;
1227
+ writeInt64BE(value: BigValue): void;
1228
1228
  /**
1229
1229
  * Write unsigned 64 bit integer.
1230
1230
  *
1231
- * @param {number} value - value as int
1231
+ * @param {BigValue} value - value as int
1232
1232
  */
1233
- writeUInt64BE(value: number): void;
1233
+ writeUInt64BE(value: BigValue): void;
1234
1234
  /**
1235
1235
  * Read unsigned 64 bit integer.
1236
1236
  *
1237
- * @returns {number}
1237
+ * @returns {bigint}
1238
1238
  */
1239
1239
  readUInt64(): bigint;
1240
1240
  /**
1241
1241
  * Read signed 64 bit integer.
1242
1242
  *
1243
- * @returns {number}
1243
+ * @returns {bigint}
1244
1244
  */
1245
1245
  readInt64BE(): bigint;
1246
1246
  /**
1247
1247
  * Read unsigned 64 bit integer.
1248
1248
  *
1249
- * @returns {number}
1249
+ * @returns {bigint}
1250
1250
  */
1251
1251
  readUInt64BE(): bigint;
1252
1252
  /**
1253
1253
  * Read signed 64 bit integer.
1254
1254
  *
1255
- * @returns {number}
1255
+ * @returns {bigint}
1256
1256
  */
1257
1257
  readInt64LE(): bigint;
1258
1258
  /**
1259
1259
  * Read unsigned 64 bit integer.
1260
1260
  *
1261
- * @returns {number}
1261
+ * @returns {bigint}
1262
1262
  */
1263
1263
  readUInt64LE(): bigint;
1264
1264
  /**
@@ -1,5 +1,5 @@
1
1
  /// <reference types="node" />
2
- import { endian, hexdumpOptions, stringOptions } from '../common.js';
2
+ import { BigValue, endian, hexdumpOptions, stringOptions } from '../common.js';
3
3
  /**
4
4
  * For file system in Node
5
5
  */
@@ -427,11 +427,11 @@ export declare class BiBaseStreamer {
427
427
  *
428
428
  * Does not change current read position.
429
429
  *
430
- * @param {number} value - Number to search for.
430
+ * @param {BigValue} value - Number to search for.
431
431
  * @param {boolean} unsigned - If the number is unsigned (default true)
432
432
  * @param {endian} endian - endianness of value (default set endian).
433
433
  */
434
- findInt64(value: number, unsigned?: boolean, endian?: endian): number;
434
+ findInt64(value: BigValue, unsigned?: boolean, endian?: endian): number;
435
435
  /**
436
436
  * Searches for half float value position from current read position.
437
437
  *
@@ -1223,76 +1223,76 @@ export declare class BiBaseStreamer {
1223
1223
  *
1224
1224
  * @param {boolean} unsigned - if value is unsigned or not
1225
1225
  * @param {endian?} endian - ``big`` or ``little``
1226
- * @returns {number}
1226
+ * @returns {bigint}
1227
1227
  */
1228
1228
  readInt64(unsigned?: boolean, endian?: endian): bigint;
1229
1229
  /**
1230
1230
  * Write 64 bit integer.
1231
1231
  *
1232
- * @param {number} value - value as int
1232
+ * @param {BigValue} value - value as int
1233
1233
  * @param {boolean} unsigned - if the value is unsigned
1234
1234
  * @param {endian} endian - ``big`` or ``little``
1235
1235
  */
1236
- writeInt64(value: number, unsigned?: boolean, endian?: endian): void;
1236
+ writeInt64(value: BigValue, unsigned?: boolean, endian?: endian): void;
1237
1237
  /**
1238
1238
  * Write unsigned 64 bit integer.
1239
1239
  *
1240
- * @param {number} value - value as int
1240
+ * @param {BigValue} value - value as int
1241
1241
  * @param {endian} endian - ``big`` or ``little``
1242
1242
  */
1243
- writeUInt64(value: number, endian?: endian): void;
1243
+ writeUInt64(value: BigValue, endian?: endian): void;
1244
1244
  /**
1245
1245
  * Write signed 64 bit integer.
1246
1246
  *
1247
- * @param {number} value - value as int
1247
+ * @param {BigValue} value - value as int
1248
1248
  */
1249
- writeInt64LE(value: number): void;
1249
+ writeInt64LE(value: BigValue): void;
1250
1250
  /**
1251
1251
  * Write unsigned 64 bit integer.
1252
1252
  *
1253
- * @param {number} value - value as int
1253
+ * @param {BigValue} value - value as int
1254
1254
  */
1255
- writeUInt64LE(value: number): void;
1255
+ writeUInt64LE(value: BigValue): void;
1256
1256
  /**
1257
1257
  * Write signed 64 bit integer.
1258
1258
  *
1259
- * @param {number} value - value as int
1259
+ * @param {BigValue} value - value as int
1260
1260
  */
1261
- writeInt64BE(value: number): void;
1261
+ writeInt64BE(value: BigValue): void;
1262
1262
  /**
1263
1263
  * Write unsigned 64 bit integer.
1264
1264
  *
1265
- * @param {number} value - value as int
1265
+ * @param {BigValue} value - value as int
1266
1266
  */
1267
- writeUInt64BE(value: number): void;
1267
+ writeUInt64BE(value: BigValue): void;
1268
1268
  /**
1269
1269
  * Read unsigned 64 bit integer.
1270
1270
  *
1271
- * @returns {number}
1271
+ * @returns {bigint}
1272
1272
  */
1273
1273
  readUInt64(): bigint;
1274
1274
  /**
1275
1275
  * Read signed 64 bit integer.
1276
1276
  *
1277
- * @returns {number}
1277
+ * @returns {bigint}
1278
1278
  */
1279
1279
  readInt64BE(): bigint;
1280
1280
  /**
1281
1281
  * Read unsigned 64 bit integer.
1282
1282
  *
1283
- * @returns {number}
1283
+ * @returns {bigint}
1284
1284
  */
1285
1285
  readUInt64BE(): bigint;
1286
1286
  /**
1287
1287
  * Read signed 64 bit integer.
1288
1288
  *
1289
- * @returns {number}
1289
+ * @returns {bigint}
1290
1290
  */
1291
1291
  readInt64LE(): bigint;
1292
1292
  /**
1293
1293
  * Read unsigned 64 bit integer.
1294
1294
  *
1295
- * @returns {number}
1295
+ * @returns {bigint}
1296
1296
  */
1297
1297
  readUInt64LE(): bigint;
1298
1298
  /**
@@ -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
  /**
@@ -3342,109 +3343,109 @@ interface BinaryAliasReader extends BiBase {
3342
3343
  /**
3343
3344
  * Read signed 64 bit integer
3344
3345
  *
3345
- * @returns {number}
3346
+ * @returns {bigint}
3346
3347
  */
3347
3348
  get int64(): bigint;
3348
3349
  /**
3349
3350
  * Read signed 64 bit integer.
3350
3351
  *
3351
- * @returns {number}
3352
+ * @returns {bigint}
3352
3353
  */
3353
3354
  get bigint(): bigint;
3354
3355
  /**
3355
3356
  * Read signed 64 bit integer.
3356
3357
  *
3357
- * @returns {number}
3358
+ * @returns {bigint}
3358
3359
  */
3359
3360
  get quad(): bigint;
3360
3361
  /**
3361
3362
  * Read unsigned 64 bit integer.
3362
3363
  *
3363
- * @returns {number}
3364
+ * @returns {bigint}
3364
3365
  */
3365
3366
  get uint64(): bigint;
3366
3367
  /**
3367
3368
  * Read unsigned 64 bit integer.
3368
3369
  *
3369
- * @returns {number}
3370
+ * @returns {bigint}
3370
3371
  */
3371
3372
  get ubigint(): bigint;
3372
3373
  /**
3373
3374
  * Read unsigned 64 bit integer.
3374
3375
  *
3375
- * @returns {number}
3376
+ * @returns {bigint}
3376
3377
  */
3377
3378
  get uquad(): bigint;
3378
3379
  /**
3379
3380
  * Read signed 64 bit integer.
3380
3381
  *
3381
- * @returns {number}
3382
+ * @returns {bigint}
3382
3383
  */
3383
3384
  get int64be(): bigint;
3384
3385
  /**
3385
3386
  * Read signed 64 bit integer.
3386
3387
  *
3387
- * @returns {number}
3388
+ * @returns {bigint}
3388
3389
  */
3389
3390
  get bigintbe(): bigint;
3390
3391
  /**
3391
3392
  * Read signed 64 bit integer.
3392
3393
  *
3393
- * @returns {number}
3394
+ * @returns {bigint}
3394
3395
  */
3395
3396
  get quadbe(): bigint;
3396
3397
  /**
3397
3398
  * Read unsigned 64 bit integer.
3398
3399
  *
3399
- * @returns {number}
3400
+ * @returns {bigint}
3400
3401
  */
3401
3402
  get uint64be(): bigint;
3402
3403
  /**
3403
3404
  * Read unsigned 64 bit integer.
3404
3405
  *
3405
- * @returns {number}
3406
+ * @returns {bigint}
3406
3407
  */
3407
3408
  get ubigintbe(): bigint;
3408
3409
  /**
3409
3410
  * Read unsigned 64 bit integer.
3410
3411
  *
3411
- * @returns {number}
3412
+ * @returns {bigint}
3412
3413
  */
3413
3414
  get uquadbe(): bigint;
3414
3415
  /**
3415
3416
  * Read signed 64 bit integer.
3416
3417
  *
3417
- * @returns {number}
3418
+ * @returns {bigint}
3418
3419
  */
3419
3420
  get int64le(): bigint;
3420
3421
  /**
3421
3422
  * Read signed 64 bit integer.
3422
3423
  *
3423
- * @returns {number}
3424
+ * @returns {bigint}
3424
3425
  */
3425
3426
  get bigintle(): bigint;
3426
3427
  /**
3427
3428
  * Read signed 64 bit integer.
3428
3429
  *
3429
- * @returns {number}
3430
+ * @returns {bigint}
3430
3431
  */
3431
3432
  get quadle(): bigint;
3432
3433
  /**
3433
3434
  * Read unsigned 64 bit integer.
3434
3435
  *
3435
- * @returns {number}
3436
+ * @returns {bigint}
3436
3437
  */
3437
3438
  get uint64le(): bigint;
3438
3439
  /**
3439
3440
  * Read unsigned 64 bit integer.
3440
3441
  *
3441
- * @returns {number}
3442
+ * @returns {bigint}
3442
3443
  */
3443
3444
  get ubigintle(): bigint;
3444
3445
  /**
3445
3446
  * Read unsigned 64 bit integer.
3446
3447
  *
3447
- * @returns {number}
3448
+ * @returns {bigint}
3448
3449
  */
3449
3450
  get uquadle(): bigint;
3450
3451
  /**
@@ -6027,111 +6028,111 @@ interface BinaryAliasWriter extends BiBase {
6027
6028
  /**
6028
6029
  * Write 64 bit integer.
6029
6030
  *
6030
- * @param {number} value - value as int
6031
+ * @param {number|bigint} value - value as int
6031
6032
  */
6032
- set int64(value: number);
6033
+ set int64(value: number | bigint);
6033
6034
  /**
6034
6035
  * Write 64 bit integer.
6035
6036
  *
6036
- * @param {number} value - value as int
6037
+ * @param {number|bigint} value - value as int
6037
6038
  */
6038
- set quad(value: number);
6039
+ set quad(value: number | bigint);
6039
6040
  /**
6040
6041
  * Write 64 bit integer.
6041
6042
  *
6042
- * @param {number} value - value as int
6043
+ * @param {number|bigint} value - value as int
6043
6044
  */
6044
- set bigint(value: number);
6045
+ set bigint(value: number | bigint);
6045
6046
  /**
6046
6047
  * Write unsigned 64 bit integer.
6047
6048
  *
6048
- * @param {number} value - value as int
6049
+ * @param {number|bigint} value - value as int
6049
6050
  */
6050
- set uint64(value: number);
6051
+ set uint64(value: number | bigint);
6051
6052
  /**
6052
6053
  * Write unsigned 64 bit integer.
6053
6054
  *
6054
- * @param {number} value - value as int
6055
+ * @param {number|bigint} value - value as int
6055
6056
  */
6056
- set ubigint(value: number);
6057
+ set ubigint(value: number | bigint);
6057
6058
  /**
6058
6059
  * Write unsigned 64 bit integer.
6059
6060
  *
6060
- * @param {number} value - value as int
6061
+ * @param {number|bigint} value - value as int
6061
6062
  */
6062
- set uquad(value: number);
6063
+ set uquad(value: number | bigint);
6063
6064
  /**
6064
6065
  * Write signed 64 bit integer.
6065
6066
  *
6066
- * @param {number} value - value as int
6067
+ * @param {number|bigint} value - value as int
6067
6068
  */
6068
- set int64le(value: number);
6069
+ set int64le(value: number | bigint);
6069
6070
  /**
6070
6071
  * Write signed 64 bit integer.
6071
6072
  *
6072
- * @param {number} value - value as int
6073
+ * @param {number|bigint} value - value as int
6073
6074
  */
6074
- set bigintle(value: number);
6075
+ set bigintle(value: number | bigint);
6075
6076
  /**
6076
6077
  * Write signed 64 bit integer.
6077
6078
  *
6078
- * @param {number} value - value as int
6079
+ * @param {number|bigint} value - value as int
6079
6080
  */
6080
- set quadle(value: number);
6081
+ set quadle(value: number | bigint);
6081
6082
  /**
6082
6083
  * Write unsigned 64 bit integer.
6083
6084
  *
6084
- * @param {number} value - value as int
6085
+ * @param {number|bigint} value - value as int
6085
6086
  */
6086
- set uint64le(value: number);
6087
+ set uint64le(value: number | bigint);
6087
6088
  /**
6088
6089
  * Write unsigned 64 bit integer.
6089
6090
  *
6090
- * @param {number} value - value as int
6091
+ * @param {number|bigint} value - value as int
6091
6092
  */
6092
- set ubigintle(value: number);
6093
+ set ubigintle(value: number | bigint);
6093
6094
  /**
6094
6095
  * Write unsigned 64 bit integer.
6095
6096
  *
6096
- * @param {number} value - value as int
6097
+ * @param {number|bigint} value - value as int
6097
6098
  */
6098
- set uquadle(value: number);
6099
+ set uquadle(value: number | bigint);
6099
6100
  /**
6100
6101
  * Write signed 64 bit integer.
6101
6102
  *
6102
- * @param {number} value - value as int
6103
+ * @param {number|bigint} value - value as int
6103
6104
  */
6104
- set int64be(value: number);
6105
+ set int64be(value: number | bigint);
6105
6106
  /**
6106
6107
  * Write signed 64 bit integer.
6107
6108
  *
6108
- * @param {number} value - value as int
6109
+ * @param {number|bigint} value - value as int
6109
6110
  */
6110
- set bigintbe(value: number);
6111
+ set bigintbe(value: number | bigint);
6111
6112
  /**
6112
6113
  * Write signed 64 bit integer.
6113
6114
  *
6114
- * @param {number} value - value as int
6115
+ * @param {number|bigint} value - value as int
6115
6116
  */
6116
- set quadbe(value: number);
6117
+ set quadbe(value: number | bigint);
6117
6118
  /**
6118
6119
  * Write unsigned 64 bit integer.
6119
6120
  *
6120
- * @param {number} value - value as int
6121
+ * @param {number|bigint} value - value as int
6121
6122
  */
6122
- set uint64be(value: number);
6123
+ set uint64be(value: number | bigint);
6123
6124
  /**
6124
6125
  * Write unsigned 64 bit integer.
6125
6126
  *
6126
- * @param {number} value - value as int
6127
+ * @param {number|bigint} value - value as int
6127
6128
  */
6128
- set ubigintbe(value: number);
6129
+ set ubigintbe(value: number | bigint);
6129
6130
  /**
6130
6131
  * Write unsigned 64 bit integer.
6131
6132
  *
6132
- * @param {number} value - value as int
6133
+ * @param {number|bigint} value - value as int
6133
6134
  */
6134
- set uquadbe(value: number);
6135
+ set uquadbe(value: number | bigint);
6135
6136
  /**
6136
6137
  * Writes double float.
6137
6138
  *
@@ -6690,24 +6691,24 @@ declare class BiWriter extends BiWriterBase implements BinaryAliasWriter {
6690
6691
  set float(value: number);
6691
6692
  set floatle(value: number);
6692
6693
  set floatbe(value: number);
6693
- set int64(value: number);
6694
- set quad(value: number);
6695
- set bigint(value: number);
6696
- set uint64(value: number);
6697
- set ubigint(value: number);
6698
- set uquad(value: number);
6699
- set int64le(value: number);
6700
- set bigintle(value: number);
6701
- set quadle(value: number);
6702
- set uint64le(value: number);
6703
- set ubigintle(value: number);
6704
- set uquadle(value: number);
6705
- set int64be(value: number);
6706
- set bigintbe(value: number);
6707
- set quadbe(value: number);
6708
- set uint64be(value: number);
6709
- set ubigintbe(value: number);
6710
- set uquadbe(value: number);
6694
+ set int64(value: BigValue);
6695
+ set quad(value: BigValue);
6696
+ set bigint(value: BigValue);
6697
+ set uint64(value: BigValue);
6698
+ set ubigint(value: BigValue);
6699
+ set uquad(value: BigValue);
6700
+ set int64le(value: BigValue);
6701
+ set bigintle(value: BigValue);
6702
+ set quadle(value: BigValue);
6703
+ set uint64le(value: BigValue);
6704
+ set ubigintle(value: BigValue);
6705
+ set uquadle(value: BigValue);
6706
+ set int64be(value: BigValue);
6707
+ set bigintbe(value: BigValue);
6708
+ set quadbe(value: BigValue);
6709
+ set uint64be(value: BigValue);
6710
+ set ubigintbe(value: BigValue);
6711
+ set uquadbe(value: BigValue);
6711
6712
  set doublefloat(value: number);
6712
6713
  set dfloat(value: number);
6713
6714
  set dfloatbe(value: number);