1/// <reference types="node" /> 2/** 3 * Object interface for constructing new SmartBuffer instances. 4 */ 5interface SmartBufferOptions { 6 encoding?: BufferEncoding; 7 size?: number; 8 buff?: Buffer; 9} 10declare class SmartBuffer { 11 length: number; 12 private _encoding; 13 private _buff; 14 private _writeOffset; 15 private _readOffset; 16 /** 17 * Creates a new SmartBuffer instance. 18 * 19 * @param options { SmartBufferOptions } The SmartBufferOptions to apply to this instance. 20 */ 21 constructor(options?: SmartBufferOptions); 22 /** 23 * Creates a new SmartBuffer instance with the provided internal Buffer size and optional encoding. 24 * 25 * @param size { Number } The size of the internal Buffer. 26 * @param encoding { String } The BufferEncoding to use for strings. 27 * 28 * @return { SmartBuffer } 29 */ 30 static fromSize(size: number, encoding?: BufferEncoding): SmartBuffer; 31 /** 32 * Creates a new SmartBuffer instance with the provided Buffer and optional encoding. 33 * 34 * @param buffer { Buffer } The Buffer to use as the internal Buffer value. 35 * @param encoding { String } The BufferEncoding to use for strings. 36 * 37 * @return { SmartBuffer } 38 */ 39 static fromBuffer(buff: Buffer, encoding?: BufferEncoding): SmartBuffer; 40 /** 41 * Creates a new SmartBuffer instance with the provided SmartBufferOptions options. 42 * 43 * @param options { SmartBufferOptions } The options to use when creating the SmartBuffer instance. 44 */ 45 static fromOptions(options: SmartBufferOptions): SmartBuffer; 46 /** 47 * Type checking function that determines if an object is a SmartBufferOptions object. 48 */ 49 static isSmartBufferOptions(options: SmartBufferOptions): options is SmartBufferOptions; 50 /** 51 * Reads an Int8 value from the current read position or an optionally provided offset. 52 * 53 * @param offset { Number } The offset to read data from (optional) 54 * @return { Number } 55 */ 56 readInt8(offset?: number): number; 57 /** 58 * Reads an Int16BE value from the current read position or an optionally provided offset. 59 * 60 * @param offset { Number } The offset to read data from (optional) 61 * @return { Number } 62 */ 63 readInt16BE(offset?: number): number; 64 /** 65 * Reads an Int16LE value from the current read position or an optionally provided offset. 66 * 67 * @param offset { Number } The offset to read data from (optional) 68 * @return { Number } 69 */ 70 readInt16LE(offset?: number): number; 71 /** 72 * Reads an Int32BE value from the current read position or an optionally provided offset. 73 * 74 * @param offset { Number } The offset to read data from (optional) 75 * @return { Number } 76 */ 77 readInt32BE(offset?: number): number; 78 /** 79 * Reads an Int32LE value from the current read position or an optionally provided offset. 80 * 81 * @param offset { Number } The offset to read data from (optional) 82 * @return { Number } 83 */ 84 readInt32LE(offset?: number): number; 85 /** 86 * Reads a BigInt64BE value from the current read position or an optionally provided offset. 87 * 88 * @param offset { Number } The offset to read data from (optional) 89 * @return { BigInt } 90 */ 91 readBigInt64BE(offset?: number): bigint; 92 /** 93 * Reads a BigInt64LE value from the current read position or an optionally provided offset. 94 * 95 * @param offset { Number } The offset to read data from (optional) 96 * @return { BigInt } 97 */ 98 readBigInt64LE(offset?: number): bigint; 99 /** 100 * Writes an Int8 value to the current write position (or at optional offset). 101 * 102 * @param value { Number } The value to write. 103 * @param offset { Number } The offset to write the value at. 104 * 105 * @return this 106 */ 107 writeInt8(value: number, offset?: number): SmartBuffer; 108 /** 109 * Inserts an Int8 value at the given offset value. 110 * 111 * @param value { Number } The value to insert. 112 * @param offset { Number } The offset to insert the value at. 113 * 114 * @return this 115 */ 116 insertInt8(value: number, offset: number): SmartBuffer; 117 /** 118 * Writes an Int16BE value to the current write position (or at optional offset). 119 * 120 * @param value { Number } The value to write. 121 * @param offset { Number } The offset to write the value at. 122 * 123 * @return this 124 */ 125 writeInt16BE(value: number, offset?: number): SmartBuffer; 126 /** 127 * Inserts an Int16BE value at the given offset value. 128 * 129 * @param value { Number } The value to insert. 130 * @param offset { Number } The offset to insert the value at. 131 * 132 * @return this 133 */ 134 insertInt16BE(value: number, offset: number): SmartBuffer; 135 /** 136 * Writes an Int16LE value to the current write position (or at optional offset). 137 * 138 * @param value { Number } The value to write. 139 * @param offset { Number } The offset to write the value at. 140 * 141 * @return this 142 */ 143 writeInt16LE(value: number, offset?: number): SmartBuffer; 144 /** 145 * Inserts an Int16LE value at the given offset value. 146 * 147 * @param value { Number } The value to insert. 148 * @param offset { Number } The offset to insert the value at. 149 * 150 * @return this 151 */ 152 insertInt16LE(value: number, offset: number): SmartBuffer; 153 /** 154 * Writes an Int32BE value to the current write position (or at optional offset). 155 * 156 * @param value { Number } The value to write. 157 * @param offset { Number } The offset to write the value at. 158 * 159 * @return this 160 */ 161 writeInt32BE(value: number, offset?: number): SmartBuffer; 162 /** 163 * Inserts an Int32BE value at the given offset value. 164 * 165 * @param value { Number } The value to insert. 166 * @param offset { Number } The offset to insert the value at. 167 * 168 * @return this 169 */ 170 insertInt32BE(value: number, offset: number): SmartBuffer; 171 /** 172 * Writes an Int32LE value to the current write position (or at optional offset). 173 * 174 * @param value { Number } The value to write. 175 * @param offset { Number } The offset to write the value at. 176 * 177 * @return this 178 */ 179 writeInt32LE(value: number, offset?: number): SmartBuffer; 180 /** 181 * Inserts an Int32LE value at the given offset value. 182 * 183 * @param value { Number } The value to insert. 184 * @param offset { Number } The offset to insert the value at. 185 * 186 * @return this 187 */ 188 insertInt32LE(value: number, offset: number): SmartBuffer; 189 /** 190 * Writes a BigInt64BE value to the current write position (or at optional offset). 191 * 192 * @param value { BigInt } The value to write. 193 * @param offset { Number } The offset to write the value at. 194 * 195 * @return this 196 */ 197 writeBigInt64BE(value: bigint, offset?: number): SmartBuffer; 198 /** 199 * Inserts a BigInt64BE value at the given offset value. 200 * 201 * @param value { BigInt } The value to insert. 202 * @param offset { Number } The offset to insert the value at. 203 * 204 * @return this 205 */ 206 insertBigInt64BE(value: bigint, offset: number): SmartBuffer; 207 /** 208 * Writes a BigInt64LE value to the current write position (or at optional offset). 209 * 210 * @param value { BigInt } The value to write. 211 * @param offset { Number } The offset to write the value at. 212 * 213 * @return this 214 */ 215 writeBigInt64LE(value: bigint, offset?: number): SmartBuffer; 216 /** 217 * Inserts a Int64LE value at the given offset value. 218 * 219 * @param value { BigInt } The value to insert. 220 * @param offset { Number } The offset to insert the value at. 221 * 222 * @return this 223 */ 224 insertBigInt64LE(value: bigint, offset: number): SmartBuffer; 225 /** 226 * Reads an UInt8 value from the current read position or an optionally provided offset. 227 * 228 * @param offset { Number } The offset to read data from (optional) 229 * @return { Number } 230 */ 231 readUInt8(offset?: number): number; 232 /** 233 * Reads an UInt16BE value from the current read position or an optionally provided offset. 234 * 235 * @param offset { Number } The offset to read data from (optional) 236 * @return { Number } 237 */ 238 readUInt16BE(offset?: number): number; 239 /** 240 * Reads an UInt16LE value from the current read position or an optionally provided offset. 241 * 242 * @param offset { Number } The offset to read data from (optional) 243 * @return { Number } 244 */ 245 readUInt16LE(offset?: number): number; 246 /** 247 * Reads an UInt32BE value from the current read position or an optionally provided offset. 248 * 249 * @param offset { Number } The offset to read data from (optional) 250 * @return { Number } 251 */ 252 readUInt32BE(offset?: number): number; 253 /** 254 * Reads an UInt32LE value from the current read position or an optionally provided offset. 255 * 256 * @param offset { Number } The offset to read data from (optional) 257 * @return { Number } 258 */ 259 readUInt32LE(offset?: number): number; 260 /** 261 * Reads a BigUInt64BE value from the current read position or an optionally provided offset. 262 * 263 * @param offset { Number } The offset to read data from (optional) 264 * @return { BigInt } 265 */ 266 readBigUInt64BE(offset?: number): bigint; 267 /** 268 * Reads a BigUInt64LE value from the current read position or an optionally provided offset. 269 * 270 * @param offset { Number } The offset to read data from (optional) 271 * @return { BigInt } 272 */ 273 readBigUInt64LE(offset?: number): bigint; 274 /** 275 * Writes an UInt8 value to the current write position (or at optional offset). 276 * 277 * @param value { Number } The value to write. 278 * @param offset { Number } The offset to write the value at. 279 * 280 * @return this 281 */ 282 writeUInt8(value: number, offset?: number): SmartBuffer; 283 /** 284 * Inserts an UInt8 value at the given offset value. 285 * 286 * @param value { Number } The value to insert. 287 * @param offset { Number } The offset to insert the value at. 288 * 289 * @return this 290 */ 291 insertUInt8(value: number, offset: number): SmartBuffer; 292 /** 293 * Writes an UInt16BE value to the current write position (or at optional offset). 294 * 295 * @param value { Number } The value to write. 296 * @param offset { Number } The offset to write the value at. 297 * 298 * @return this 299 */ 300 writeUInt16BE(value: number, offset?: number): SmartBuffer; 301 /** 302 * Inserts an UInt16BE value at the given offset value. 303 * 304 * @param value { Number } The value to insert. 305 * @param offset { Number } The offset to insert the value at. 306 * 307 * @return this 308 */ 309 insertUInt16BE(value: number, offset: number): SmartBuffer; 310 /** 311 * Writes an UInt16LE value to the current write position (or at optional offset). 312 * 313 * @param value { Number } The value to write. 314 * @param offset { Number } The offset to write the value at. 315 * 316 * @return this 317 */ 318 writeUInt16LE(value: number, offset?: number): SmartBuffer; 319 /** 320 * Inserts an UInt16LE value at the given offset value. 321 * 322 * @param value { Number } The value to insert. 323 * @param offset { Number } The offset to insert the value at. 324 * 325 * @return this 326 */ 327 insertUInt16LE(value: number, offset: number): SmartBuffer; 328 /** 329 * Writes an UInt32BE value to the current write position (or at optional offset). 330 * 331 * @param value { Number } The value to write. 332 * @param offset { Number } The offset to write the value at. 333 * 334 * @return this 335 */ 336 writeUInt32BE(value: number, offset?: number): SmartBuffer; 337 /** 338 * Inserts an UInt32BE value at the given offset value. 339 * 340 * @param value { Number } The value to insert. 341 * @param offset { Number } The offset to insert the value at. 342 * 343 * @return this 344 */ 345 insertUInt32BE(value: number, offset: number): SmartBuffer; 346 /** 347 * Writes an UInt32LE value to the current write position (or at optional offset). 348 * 349 * @param value { Number } The value to write. 350 * @param offset { Number } The offset to write the value at. 351 * 352 * @return this 353 */ 354 writeUInt32LE(value: number, offset?: number): SmartBuffer; 355 /** 356 * Inserts an UInt32LE value at the given offset value. 357 * 358 * @param value { Number } The value to insert. 359 * @param offset { Number } The offset to insert the value at. 360 * 361 * @return this 362 */ 363 insertUInt32LE(value: number, offset: number): SmartBuffer; 364 /** 365 * Writes a BigUInt64BE value to the current write position (or at optional offset). 366 * 367 * @param value { Number } The value to write. 368 * @param offset { Number } The offset to write the value at. 369 * 370 * @return this 371 */ 372 writeBigUInt64BE(value: bigint, offset?: number): SmartBuffer; 373 /** 374 * Inserts a BigUInt64BE value at the given offset value. 375 * 376 * @param value { Number } The value to insert. 377 * @param offset { Number } The offset to insert the value at. 378 * 379 * @return this 380 */ 381 insertBigUInt64BE(value: bigint, offset: number): SmartBuffer; 382 /** 383 * Writes a BigUInt64LE value to the current write position (or at optional offset). 384 * 385 * @param value { Number } The value to write. 386 * @param offset { Number } The offset to write the value at. 387 * 388 * @return this 389 */ 390 writeBigUInt64LE(value: bigint, offset?: number): SmartBuffer; 391 /** 392 * Inserts a BigUInt64LE value at the given offset value. 393 * 394 * @param value { Number } The value to insert. 395 * @param offset { Number } The offset to insert the value at. 396 * 397 * @return this 398 */ 399 insertBigUInt64LE(value: bigint, offset: number): SmartBuffer; 400 /** 401 * Reads an FloatBE value from the current read position or an optionally provided offset. 402 * 403 * @param offset { Number } The offset to read data from (optional) 404 * @return { Number } 405 */ 406 readFloatBE(offset?: number): number; 407 /** 408 * Reads an FloatLE value from the current read position or an optionally provided offset. 409 * 410 * @param offset { Number } The offset to read data from (optional) 411 * @return { Number } 412 */ 413 readFloatLE(offset?: number): number; 414 /** 415 * Writes a FloatBE value to the current write position (or at optional offset). 416 * 417 * @param value { Number } The value to write. 418 * @param offset { Number } The offset to write the value at. 419 * 420 * @return this 421 */ 422 writeFloatBE(value: number, offset?: number): SmartBuffer; 423 /** 424 * Inserts a FloatBE value at the given offset value. 425 * 426 * @param value { Number } The value to insert. 427 * @param offset { Number } The offset to insert the value at. 428 * 429 * @return this 430 */ 431 insertFloatBE(value: number, offset: number): SmartBuffer; 432 /** 433 * Writes a FloatLE value to the current write position (or at optional offset). 434 * 435 * @param value { Number } The value to write. 436 * @param offset { Number } The offset to write the value at. 437 * 438 * @return this 439 */ 440 writeFloatLE(value: number, offset?: number): SmartBuffer; 441 /** 442 * Inserts a FloatLE value at the given offset value. 443 * 444 * @param value { Number } The value to insert. 445 * @param offset { Number } The offset to insert the value at. 446 * 447 * @return this 448 */ 449 insertFloatLE(value: number, offset: number): SmartBuffer; 450 /** 451 * Reads an DoublEBE value from the current read position or an optionally provided offset. 452 * 453 * @param offset { Number } The offset to read data from (optional) 454 * @return { Number } 455 */ 456 readDoubleBE(offset?: number): number; 457 /** 458 * Reads an DoubleLE value from the current read position or an optionally provided offset. 459 * 460 * @param offset { Number } The offset to read data from (optional) 461 * @return { Number } 462 */ 463 readDoubleLE(offset?: number): number; 464 /** 465 * Writes a DoubleBE value to the current write position (or at optional offset). 466 * 467 * @param value { Number } The value to write. 468 * @param offset { Number } The offset to write the value at. 469 * 470 * @return this 471 */ 472 writeDoubleBE(value: number, offset?: number): SmartBuffer; 473 /** 474 * Inserts a DoubleBE value at the given offset value. 475 * 476 * @param value { Number } The value to insert. 477 * @param offset { Number } The offset to insert the value at. 478 * 479 * @return this 480 */ 481 insertDoubleBE(value: number, offset: number): SmartBuffer; 482 /** 483 * Writes a DoubleLE value to the current write position (or at optional offset). 484 * 485 * @param value { Number } The value to write. 486 * @param offset { Number } The offset to write the value at. 487 * 488 * @return this 489 */ 490 writeDoubleLE(value: number, offset?: number): SmartBuffer; 491 /** 492 * Inserts a DoubleLE value at the given offset value. 493 * 494 * @param value { Number } The value to insert. 495 * @param offset { Number } The offset to insert the value at. 496 * 497 * @return this 498 */ 499 insertDoubleLE(value: number, offset: number): SmartBuffer; 500 /** 501 * Reads a String from the current read position. 502 * 503 * @param arg1 { Number | String } The number of bytes to read as a String, or the BufferEncoding to use for 504 * the string (Defaults to instance level encoding). 505 * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). 506 * 507 * @return { String } 508 */ 509 readString(arg1?: number | BufferEncoding, encoding?: BufferEncoding): string; 510 /** 511 * Inserts a String 512 * 513 * @param value { String } The String value to insert. 514 * @param offset { Number } The offset to insert the string at. 515 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). 516 * 517 * @return this 518 */ 519 insertString(value: string, offset: number, encoding?: BufferEncoding): SmartBuffer; 520 /** 521 * Writes a String 522 * 523 * @param value { String } The String value to write. 524 * @param arg2 { Number | String } The offset to write the string at, or the BufferEncoding to use. 525 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). 526 * 527 * @return this 528 */ 529 writeString(value: string, arg2?: number | BufferEncoding, encoding?: BufferEncoding): SmartBuffer; 530 /** 531 * Reads a null-terminated String from the current read position. 532 * 533 * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding). 534 * 535 * @return { String } 536 */ 537 readStringNT(encoding?: BufferEncoding): string; 538 /** 539 * Inserts a null-terminated String. 540 * 541 * @param value { String } The String value to write. 542 * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. 543 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). 544 * 545 * @return this 546 */ 547 insertStringNT(value: string, offset: number, encoding?: BufferEncoding): SmartBuffer; 548 /** 549 * Writes a null-terminated String. 550 * 551 * @param value { String } The String value to write. 552 * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use. 553 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). 554 * 555 * @return this 556 */ 557 writeStringNT(value: string, arg2?: number | BufferEncoding, encoding?: BufferEncoding): SmartBuffer; 558 /** 559 * Reads a Buffer from the internal read position. 560 * 561 * @param length { Number } The length of data to read as a Buffer. 562 * 563 * @return { Buffer } 564 */ 565 readBuffer(length?: number): Buffer; 566 /** 567 * Writes a Buffer to the current write position. 568 * 569 * @param value { Buffer } The Buffer to write. 570 * @param offset { Number } The offset to write the Buffer to. 571 * 572 * @return this 573 */ 574 insertBuffer(value: Buffer, offset: number): SmartBuffer; 575 /** 576 * Writes a Buffer to the current write position. 577 * 578 * @param value { Buffer } The Buffer to write. 579 * @param offset { Number } The offset to write the Buffer to. 580 * 581 * @return this 582 */ 583 writeBuffer(value: Buffer, offset?: number): SmartBuffer; 584 /** 585 * Reads a null-terminated Buffer from the current read poisiton. 586 * 587 * @return { Buffer } 588 */ 589 readBufferNT(): Buffer; 590 /** 591 * Inserts a null-terminated Buffer. 592 * 593 * @param value { Buffer } The Buffer to write. 594 * @param offset { Number } The offset to write the Buffer to. 595 * 596 * @return this 597 */ 598 insertBufferNT(value: Buffer, offset: number): SmartBuffer; 599 /** 600 * Writes a null-terminated Buffer. 601 * 602 * @param value { Buffer } The Buffer to write. 603 * @param offset { Number } The offset to write the Buffer to. 604 * 605 * @return this 606 */ 607 writeBufferNT(value: Buffer, offset?: number): SmartBuffer; 608 /** 609 * Clears the SmartBuffer instance to its original empty state. 610 */ 611 clear(): SmartBuffer; 612 /** 613 * Gets the remaining data left to be read from the SmartBuffer instance. 614 * 615 * @return { Number } 616 */ 617 remaining(): number; 618 /** 619 * Gets the current read offset value of the SmartBuffer instance. 620 * 621 * @return { Number } 622 */ 623 /** 624 * Sets the read offset value of the SmartBuffer instance. 625 * 626 * @param offset { Number } - The offset value to set. 627 */ 628 readOffset: number; 629 /** 630 * Gets the current write offset value of the SmartBuffer instance. 631 * 632 * @return { Number } 633 */ 634 /** 635 * Sets the write offset value of the SmartBuffer instance. 636 * 637 * @param offset { Number } - The offset value to set. 638 */ 639 writeOffset: number; 640 /** 641 * Gets the currently set string encoding of the SmartBuffer instance. 642 * 643 * @return { BufferEncoding } The string Buffer encoding currently set. 644 */ 645 /** 646 * Sets the string encoding of the SmartBuffer instance. 647 * 648 * @param encoding { BufferEncoding } The string Buffer encoding to set. 649 */ 650 encoding: BufferEncoding; 651 /** 652 * Gets the underlying internal Buffer. (This includes unmanaged data in the Buffer) 653 * 654 * @return { Buffer } The Buffer value. 655 */ 656 readonly internalBuffer: Buffer; 657 /** 658 * Gets the value of the internal managed Buffer (Includes managed data only) 659 * 660 * @param { Buffer } 661 */ 662 toBuffer(): Buffer; 663 /** 664 * Gets the String value of the internal managed Buffer 665 * 666 * @param encoding { String } The BufferEncoding to display the Buffer as (defaults to instance level encoding). 667 */ 668 toString(encoding?: BufferEncoding): string; 669 /** 670 * Destroys the SmartBuffer instance. 671 */ 672 destroy(): SmartBuffer; 673 /** 674 * Handles inserting and writing strings. 675 * 676 * @param value { String } The String value to insert. 677 * @param isInsert { Boolean } True if inserting a string, false if writing. 678 * @param arg2 { Number | String } The offset to insert the string at, or the BufferEncoding to use. 679 * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding). 680 */ 681 private _handleString; 682 /** 683 * Handles writing or insert of a Buffer. 684 * 685 * @param value { Buffer } The Buffer to write. 686 * @param offset { Number } The offset to write the Buffer to. 687 */ 688 private _handleBuffer; 689 /** 690 * Ensures that the internal Buffer is large enough to read data. 691 * 692 * @param length { Number } The length of the data that needs to be read. 693 * @param offset { Number } The offset of the data that needs to be read. 694 */ 695 private ensureReadable; 696 /** 697 * Ensures that the internal Buffer is large enough to insert data. 698 * 699 * @param dataLength { Number } The length of the data that needs to be written. 700 * @param offset { Number } The offset of the data to be written. 701 */ 702 private ensureInsertable; 703 /** 704 * Ensures that the internal Buffer is large enough to write data. 705 * 706 * @param dataLength { Number } The length of the data that needs to be written. 707 * @param offset { Number } The offset of the data to be written (defaults to writeOffset). 708 */ 709 private _ensureWriteable; 710 /** 711 * Ensures that the internal Buffer is large enough to write at least the given amount of data. 712 * 713 * @param minLength { Number } The minimum length of the data needs to be written. 714 */ 715 private _ensureCapacity; 716 /** 717 * Reads a numeric number value using the provided function. 718 * 719 * @typeparam T { number | bigint } The type of the value to be read 720 * 721 * @param func { Function(offset: number) => number } The function to read data on the internal Buffer with. 722 * @param byteSize { Number } The number of bytes read. 723 * @param offset { Number } The offset to read from (optional). When this is not provided, the managed readOffset is used instead. 724 * 725 * @returns { T } the number value 726 */ 727 private _readNumberValue; 728 /** 729 * Inserts a numeric number value based on the given offset and value. 730 * 731 * @typeparam T { number | bigint } The type of the value to be written 732 * 733 * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with. 734 * @param byteSize { Number } The number of bytes written. 735 * @param value { T } The number value to write. 736 * @param offset { Number } the offset to write the number at (REQUIRED). 737 * 738 * @returns SmartBuffer this buffer 739 */ 740 private _insertNumberValue; 741 /** 742 * Writes a numeric number value based on the given offset and value. 743 * 744 * @typeparam T { number | bigint } The type of the value to be written 745 * 746 * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with. 747 * @param byteSize { Number } The number of bytes written. 748 * @param value { T } The number value to write. 749 * @param offset { Number } the offset to write the number at (REQUIRED). 750 * 751 * @returns SmartBuffer this buffer 752 */ 753 private _writeNumberValue; 754} 755export { SmartBufferOptions, SmartBuffer }; 756