* Start downloading a new torrent. Aliased as `client.download`. * @param {string|Buffer|Object} torrentId * @param {import('./lib/torrent.js').

* Start seeding a new file/folder. * @param {string|File|FileList|Buffer|Array.<string|File|Buffer>} input * @param {Object=} opts * @param

@param {number} index

* Remove a torrent from the client. * @param {string|Buffer|Torrent} torrentId * @param {function} cb

* Creates an http server to serve the contents of this torrent, * dynamically fetching the needed torrent pieces to satisfy http requests. * Ran

* Destroy the client, including all torrents and connections to peers. * @param {function} cb

* Get the index of the rarest piece. Optionally, pass a filter function to exclude * certain pieces (for instance, those that we already have).

* Heartbeat to update all peers and their requests.

* @param {SelectionItem & NotificationItem} newItem

* Recalculates piece availability across all peers in the torrent.

* Converts a selection or an array of selections to a human-readable string * @param {{from: number, to: number} | Array<{from: number, to: number}>}

* Attempts to request a block from the given wire.

* Called once the peer is connected (i.e. fired 'connect' event) * @param {Socket} conn

* Called on selection changes.

* Verifies the pieces of the torrent using hashing ( it can be very slow ) * @param {Array<number>} pieces * @param {callbackWithError} cb *

@param {(a: SelectionItem, b: SelectionItem) => number} sortFn

* Pop a peer off the FIFO queue and connect to it. When _drain() gets called, * the queue will usually have only one peer in it, except when there

* Mark the entire torrent as verified ( i.e. fully downloaded ) * @private

* Mark one piece as verified * @param {number} index * @private

* Called when the full torrent metadata is received.

* Called when the metadata, listening server, and underlying chunk store is initialized.

* @param {Peer} newPeer

* Asserts that the given arrays of selections have the same from-to pairs, regardless of order * @param {import('tape').Test} t * @param {Array<Sele

* Destroy this Conn pool. * @param {function} cb

* @param {MinimalSelectionItem & {isStreamSelection?: boolean}} item Interval to be removed from the selection

* @returns {Promise<IteratorResult<Uint8Array>>}

* Called whenever a new incoming TCP peer connects to this torrent swarm. Called with a * peer that has already sent a handshake.

* Garbage collect selections with respect to the store's current state.

* Return `true` if string is a valid IPv4 address. * @param {string} addr * @return {boolean}

* On incoming connections, we expect the remote peer to send a handshake first. Based * on the infoHash in that handshake, route the peer to the ri

* Parse a torrent from its magnet/torrent file/remote url and kickstart downloading it * @param {string|ArrayBufferView|Object} torrentId * @ret

* @param {import('bittorrent-protocol').default} wire

* Update interested status for all peers.