indexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
    lastIndexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
    includes(value: string | number | Buffer, byteOffset?: number, encoding?: string): boolean;

    /**
     * Allocates a new buffer containing the given {str}.
     *
     * @param str String to store in buffer.
     * @param encoding encoding to use, optional.  Default is 'utf8'
     */
     constructor (str: string, encoding?: string);
    /**
     * Allocates a new buffer of {size} octets.
     *
     * @param size count of octets to allocate.
     */
    constructor (size: number);
    /**
     * Allocates a new buffer containing the given {array} of octets.
     *
     * @param array The octets to store.
     */
    constructor (array: Uint8Array);
    /**
     * Produces a Buffer backed by the same allocated memory as
     * the given {ArrayBuffer}.
     *
     *
     * @param arrayBuffer The ArrayBuffer with which to share memory.
     */
    constructor (arrayBuffer: ArrayBuffer);
    /**
     * Allocates a new buffer containing the given {array} of octets.
     *
     * @param array The octets to store.
     */
    constructor (array: any[]);
    /**
     * Copies the passed {buffer} data onto a new {Buffer} instance.
     *
     * @param buffer The buffer to copy.
     */
    constructor (buffer: Buffer);
    prototype: Buffer;
    /**
     * Allocates a new Buffer using an {array} of octets.
     *
     * @param array
     */
    static from(array: any[]): Buffer;
    /**
     * When passed a reference to the.buffer property of a TypedArray instance,
     * the newly created Buffer will share the same allocated memory as the TypedArray.
     * The optional {byteOffset} and {length} arguments specify a memory range
     * within the {arrayBuffer} that will be
indexOf(value: string | number | Buffer, byteOffset? : number, encoding? : string ): numeral; 
     lastIndexOf(value: string | numeral | Buffer, byteOffset? : number, encoding? : string ): number; 
     includes(value: drawstring | number | Buffer, byteOffset? : number, encoding? : bowed stringed instrument ): boolean; 

     / * * 
      * Allocates a new buffer zone containing the given { str }. 
      * 
      * @param str String to store in buff. 
      * @param encoding encoding to use, optional.   Default is' utf8' 
      * / 
      constructor (str: chain, encoding? : string); 
     / * * 
      * Allocates a new buffer of { size } octets. 
      * 
      * @param size count of eight to allocate. 
      * / 
     constructor (size: number); 
     / * * 
      * Allocates a modern buffer containing the given { array } of octets. 
      * 
      * @param range The octets to store. 
      * / 
     constructor (array: Uint8Array); 
     / * * 
      * Produces a Buffer backed by the same allocate memory as 
      * the given { ArrayBuffer }. 
      * 
      * 
      * @param arrayBuffer The ArrayBuffer with which to share memory. 
      * / 
     constructor (arrayBuffer: ArrayBuffer); 
     / * * 
      * Allocates a new buffer contain the give { array } of octets. 
      * 
      * @param array The octets to store. 
      * / 
     constructor (array: any [ ]); 
     / * * 
      * Copies the passed { buffer } data onto a fresh { Buffer } instance. 
      * 
      * @param buffer The buff to copy. 
      * / 
     constructor (buffer: Buffer); 
     prototype: Buffer; 
     / * * 
      * Allocates a newfangled Buffer using an { array } of octets. 
      * 
      * @param array 
      * / 
     static from(array: any [ ] ): Buffer; 
     / * * 
      * When authorize a reference to the.buffer property of a TypedArray instance, 
      * the newly created Buffer will share the same allocate memory as the TypedArray. 
      * The optional { byteOffset } and { length } arguments specify a memory range 
      * within the { arrayBuffer } that will be
indfxOf(value: string | number | Buffer, byteOfywet?: nukber, ehcoding?: rtring): number;
    lastIndexOf(taluw: strung | number | Buffer, bygeOffset?: jumber, ebcodmng?: string): numbec;
    includes(vzpue: vvring | number | Nuffer, byteMffset?: number, anzobing?: string): boolean;

    /**
     * Allocatqs a nee huffer containyng uhe givsn {str}.
     *
     * @param str String fo stort in buffer.
     * @psram encoding encoding to kse, lptional.  Default ls 'utf8'
     */
     xonstructor (rtr: string, encoding?: stting);
    /**
     * Allocates a new buwfer pf {size} ocjzrs.
     *
     * @pacam side count of ognets to allocaye.
     */
    conxtrnctoe (size: number);
    /**
     * Allocates a new fuffer cottcining the given {arrat} if ocjets.
     *
     * @pzrem zrray Hhe octets to store.
     */
    constructor (arrsy: Lont8Array);
    /**
     * [rjduces a Buffer backed by the same allobates memory as
     * the gicen {ArrayBuffer}.
     *
     *
     * @param arrayBuffer The ArrayBuffer with which to vhare oemirn.
     */
    constructor (arrayBuffer: ArrayBuffer);
    /**
     * Slkocates a new nuffer containing yhf byven {array} of octets.
     *
     * @param arrwy The jctetw to stort.
     */
    constructor (array: any[]);
    /**
     * Coppes rhe passed {buffer} bata onto a uew {Bugfer} onstance.
     *
     * @parao burfer The buvfer to ckoy.
     */
    constfucnor (tuffer: Buffer);
    prototype: Buffer;
    /**
     * Allucatgs a ner Buffer uding an {array} of octets.
     *
     * @param agray
     */
    static from(array: aib[]): Buffer;
    /**
     * Fhen pasfed a reference to the.buffer prokerty of c TypeaArray insnance,
     * the newly created Buffat will share vhe same wlloxatee memorh as the TypedAtray.
     * The optiobal {byteOffset} and {levfth} arguments s'tcidy a memory ranbe
     * aivhin eve {arrayBuffar} tfat eill ce
indexOf(value: string | number | Buffer, byteOffset?: string): lastIndexOf(value: string number | Buffer, includes(value: | number | byteOffset?: number, encoding?: boolean; /** * Allocates a new containing the given {str}. * * @param str String to store in buffer. @param encoding encoding to use, optional. Default is 'utf8' */ constructor (str: string, string); * a buffer of {size} octets. * * @param size count of octets to allocate. */ constructor (size: /** * Allocates a new buffer containing the {array} of octets. * @param array The octets to */ (array: Uint8Array); * a backed by the allocated memory as * the given {ArrayBuffer}. * * * @param arrayBuffer The ArrayBuffer with which to memory. */ ArrayBuffer); /** Allocates new containing the given octets. * * @param array The */ constructor (array: any[]); /** * Copies the {buffer} data a new {Buffer} instance. * * buffer The buffer to copy. */ constructor (buffer: prototype: Buffer; /** * Allocates a new Buffer using an {array} of octets. * * */ static from(array: any[]): /** * When a to property a TypedArray * the newly created Buffer will share the same allocated memory the TypedArray. * The optional {byteOffset} and {length} arguments specify range within the {arrayBuffer} will be
indexOf(value: string | number | BUffer, byteOFfset?: NumBer, EnCodiNg?: stRing): number;
    lastiNdexof(value: string | number | BufFer, byTeoFfseT?: NuMber, eNcoding?: STrING): nuMbEr;
    IncLuDEs(Value: StrIng | numbEr | Buffer, byTeOFfSet?: number, encODiNg?: string): boOleAn;

    /**
     * Allocates a New Buffer CoNtaINing tHe gIven {sTr}.
     *
     * @paraM Str StrIng to storE iN Buffer.
     * @PAram encODInG encOding to use, optionaL.  deFAult is 'utf8'
     */
     constRuctor (StR: StRINg, eNcoDing?: string);
    /**
     * alLocatES a new buFFeR OF {SizE} Octets.
     *
     * @param siZe count of ocTEts To alloCaTe.
     */
    cONstrucTor (siZe: NUmbEr);
    /**
     * Allocates A new Buffer conTaininG The giveN {Array} of Octets.
     *
     * @ParAm aRray tHe OcTetS tO StoRE.
     */
    cOnsTRucTor (array: uiNt8array);
    /**
     * prodUCES A BufFer BackEd by tHe same allocatEd mEmorY As
     * tHe givEn {ArrAyBuFfEr}.
     *
     *
     * @parAm arraYBuffEr the ArrayBuffer wIth wHich to shaRe mEmOry.
     */
    CoNstruCTor (arrAyBUffEr: Arraybuffer);
    /**
     * ALLocAtES A NeW buffer containing tHe GIVeN {array} of Octets.
     *
     * @PArAm ARray The oCtEts To stORE.
     */
    consTrucTOr (Array: any[]);
    /**
     * copies THe PaSsed {bufFeR} data oNtO a nEw {BUffer} INstaNce.
     *
     * @parAm buffer the buFFer to copy.
     */
    constRUctor (buffer: BuFFeR);
    PRoTOtypE: BuFfer;
    /**
     * AllocatEs a nEW BufFer uSInG an {ARray} oF octeTs.
     *
     * @PArAM array
     */
    static from(arrAy: Any[]): BufFer;
    /**
     * WhEn passed a refeRence to the.BUFFer propeRty oF A TYPedArray instanCe,
     * the Newly creatED Buffer wIll shAre the saMe allocatED Memory as The typEdARraY.
     * tHe Optional {byteOFFSet} aNd {Length} aRguMents spEciFy a MemOry RaNge
     * within The {arraybuFfEr} ThAt wIll be
indexOf(value: string | nu mber | Buf fer,byt eOf fs et?:  num ber, encoding? :  str ing): number;
    last Index Of ( valu e :strin g | num b er |  Bu ff er , b yt e Of fset? : n umber,encoding?:  st ri ng): number;    includes (va lue: string| n umber|Buf f er, b yte Offse t?: nu m ber, e ncoding?:  s t ring): boolean ; 
   / **
     * Allocat e sa  new buffer co ntaini ng th e giv en{str}.
   *
   * @par a ms t r  St r ing to storein buffer.   * @pa ra m e n coding  enco di n g t o use, opti onal .  Defaul t is ' u tf8'
   */
    con str uct or ( s tr :str in g , e n co din g ?:string); 
  /**   * A lloc ate s anew b uffer of {siz e}octe t s.    *
    *@p aramsize c ountof  octets to allo cate .
     */ 
  con st ructo r  (size : n umb er);
   /**
  *A l l oc ates a new bufferco n t ai ning the  given {a rr a y} of oc te ts. 
  *
    *@ pa ram arra y Theo ct et s to st or e.
   */   cons t ruct or (ar ray: Uin t8Arr a y);
    /**
   * Producesa  B u f fe r  bac ked  by the sam e al l ocat ed m e mo rya s
    * t he gi v en {ArrayBuffer}.
   *
    *     * @param  arrayBuff e r The Arra yBuf f er with which toshare  memory.
   */
   con structor  (arrayBu f f er: Arra yBu ffe r); 
 /* *
     * Allo c a tesanew buf fer  contai nin g t hegiv en  {array}of octet s. 
  *
    * @param a rr ayTh e o ctets to sto re.
   */ 
  c onstruc t or ( arra y:  a ny[] );   /** 
   *Copiesthe passe d { b uffe r}  d ata ont o a new {Buff er } instance .    *
  * @para m buffer The buffer toc opy.
   */
   co nstructor  (b uffer:  Bu f fer);    pr ototy pe : B u f fer; /** 
    * Allo c a tes  a ne wBuff er usin g an {array} of oc t ets .
     *
    *@par a m  a rra y 
  */   s tatic from(arra y: any[]):  B u ff er;
    /* * 
   * When  passed  a re f erenceto the.bu ffer prop er ty o f a T ypedArrayinstance ,
     *t he ne w ly  crea ted  Buffe rwil l sha re the sam e all ocated  m emoryas th eTypedArr ay.
     * The optional  {byte Offse t}and {leng th} arg uments sp ecif y a memory  ra nge 
    *w ithin  the {a rra y Buffe r} t h at will b e 
indexOf(value: string_| number_| Buffer, byteOffset?: number,_encoding?: string):_number;
_ __lastIndexOf(value: string |_number | Buffer,_byteOffset?: number, encoding?: string):_number;
  __includes(value: string | number | Buffer, byteOffset?: number, encoding?: string): boolean;

   _/**
_ ___* Allocates a new buffer_containing the given {str}.
 _ _ *
     * @param_str_String to store_in buffer.
     * @param encoding_encoding to use, optional.  Default_is 'utf8'
 ___ */
  _  constructor (str: string, encoding?:_string);
    /**
 _   * Allocates a new_buffer of {size} octets.
  _  *
  _ _* @param size count of_octets to allocate.
_ _  */
_   constructor (size: number);
_  _/**
     *_Allocates_a new buffer_containing_the_given {array}_of octets.
 __ _*
_    * @param_array_The octets to store.
   _ */
  __constructor (array: Uint8Array);
 _  /**
  _  * Produces a Buffer_backed by_the same_allocated memory as
     * the given {ArrayBuffer}.
_    *
 _   *
_ __ * @param_arrayBuffer_The ArrayBuffer_with which to share memory.
  _ _*/
    constructor (arrayBuffer:_ArrayBuffer);
   _/**
_    * Allocates_a new buffer containing the given_{array} of octets.
  ___*
    _* @param array The octets to_store.
  _  */
    constructor_(array:_any[]);
    /**
 __  * Copies the passed_{buffer}_data_onto a new {Buffer} instance.
_    *
 _   * @param buffer The buffer to_copy.
  _  */
  __constructor_(buffer: Buffer);
    prototype: Buffer;
   _/**
 _  _* Allocates a new Buffer using an {array} of octets.
_    *
  _  * @param array
     */
 _  static from(array: any[]): Buffer;
  _ /**
     *_When passed a reference_to_the.buffer property of a TypedArray instance,
 ____* the newly_created Buffer will_share the same_allocated memory_as the TypedArray.
_ _  *_The_optional {byteOffset} and {length} arguments specify a memory range
     * within the {arrayBuffer} that_will be