source: trip-planner-front/node_modules/smart-buffer/typings/smartbuffer.d.ts@ b738035

Last change on this file since b738035 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 26.2 KB
Line 
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 };
Note: See TracBrowser for help on using the repository browser.