Module cannot be found , npm I —dev-save @types/coinselect about coinselect HOT 2 OPEN

const data = await btcFunctions.getBalance(publicKeyFrom, network);
if (!data) {
  return;
}

var balance = data.balance;  // + data.unconfirmed_balance, should not be able to spend from uncomfirmed balance

if (balance > amoutTosend) {
  const unspentOutputs = await btcFunctions.getUnspentOutputs(publicKeyFrom, network);
  if (!unspentOutputs) {
    return;
  }



  const keyPair = ECPair.fromWIF(privateKeyFrom, btcNetwork)
  const p2wpkh = bitcoin.payments.p2wpkh({ pubkey: keyPair.publicKey, network: btcNetwork })
  var scriptPubkey = p2wpkh.output.toString('hex');
  console.log("////////////////////////////////////////////////////////////");
  //const redeemScript = p2wpkh.redeem.output; 
  //var scriptPubkey2 = keyPair.publicKey;
  //console.log(scriptPubkey);
  //console.log(p2wpkh.pubkey.toString('hex'));
  //console.log(p2wpkh.address);



  //fee
  var feePerByte = await btcFunctions.getFeePerByte();
  var feeRate = feePerByte.regular * 100000000;  //fee by byte on regular mode, APi provider blockchain.info

  var txRef = await btcFunctions.getTxRef(unspentOutputs);
  //var rawHex = await btcFunctions.getRawHex(txRef[0].tx_hash, network);

  //console.log(balance);

  //console.log(txRef);

  //console.log(feePerByte);


  console.log("////////////////////////////////////////////////////////////");
  let utxoS = [];

  if (txRef && txRef.length > 0) {
    for (const tx of txRef) {
      utxoS.push({
        txHash: tx.tx_hash,
        txIndex: tx.tx_output_n,
        amount: tx.value * 100000000,
        witnessUtxo: { script: Buffer.from(p2wpkh.output, 'hex'), value: tx.value * 100000000 },
        // redeemScript: redeemScript

      });
    }
  }

  if (!utxoS.length) {
    return;
  }

  var utxos = [];
  var totalAmount = 0;
  for (const utxo of utxoS) {
    utxos.push({
      txId: utxo.txHash,
      vout: utxo.txIndex,
      value: utxo.amount,
      witnessUtxo: utxo.witnessUtxo,
    });
    //totalAmount += utxo.amount;
  }



  let targets = [
    {
      address: publicKeyTo,
      value: amoutTosend * 100000000 // value in satoshi (0.5 BTC)
    }
  ]

  //console.log(amoutTosend * 100000000);
  let { inputs, outputs, fee } = coinSelect(utxos, targets, feeRate)
  console.log(fee);
  if (!inputs || !outputs) return

  const psbt = new bitcoin.Psbt({ network: btcNetwork });

  inputs.forEach(input =>
    psbt.addInput({
      hash: input.txId,
      index: input.vout,
      witnessUtxo: input.witnessUtxo,
      //privateKeyFrom: input.privateKeyFrom
    })
  )

  outputs.forEach(output => {
    if (!output.address) {
      output.address = publicKeyFrom;
    }
    //console.log(output.value);
    psbt.addOutput({
      address: output.address,
      value: output.value
    });
  })

  psbt.signAllInputs(keyPair);
  psbt.finalizeAllInputs();
  const tx = psbt.extractTransaction(true);
  const Signedtx = tx.toHex();
  const txID = tx.getId();
  console.log(Signedtx)

} else {
  console.log("You do not have enough coin");
}