diff --git a/README.md b/README.md
index 13c4980..f033009 100644
--- a/README.md
+++ b/README.md
@@ -20,8 +20,6 @@ Benchmark (Mean time for 500 Kb payload, 2000 cycles, 1000 cycle warmup):
 | busboy                | 0.3.1   | `340114`                                  |
 | @fastify/busboy       | 1.0.0   | `270984`                                  |
 
-[Changelog](https://github.com/fastify/busboy/blob/main/CHANGELOG.md) since busboy 0.31.
-
 Requirements
 ============
 
diff --git a/benchmarks/busboy/contestants/fastify-busboy.js b/benchmarks/busboy/contestants/fastify-busboy.js
index 6750f77..a829003 100644
--- a/benchmarks/busboy/contestants/fastify-busboy.js
+++ b/benchmarks/busboy/contestants/fastify-busboy.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const Busboy = require('../../../lib/main')
+const Busboy = require('../../../index')
 const { buffer, boundary } = require('../data')
 
 function process () {
diff --git a/lib/main.js b/index.js
similarity index 89%
rename from lib/main.js
rename to index.js
index 8794beb..73efe8d 100644
--- a/lib/main.js
+++ b/index.js
@@ -2,11 +2,11 @@
 
 const WritableStream = require('node:stream').Writable
 const { inherits } = require('node:util')
-const Dicer = require('../deps/dicer/lib/Dicer')
+const Dicer = require('./deps/dicer/lib/Dicer')
 
-const MultipartParser = require('./types/multipart')
-const UrlencodedParser = require('./types/urlencoded')
-const parseParams = require('./utils/parseParams')
+const MultipartParser = require('./lib/types/multipart')
+const UrlencodedParser = require('./lib/types/urlencoded')
+const parseParams = require('./lib/utils/parseParams')
 
 function Busboy (opts) {
   if (!(this instanceof Busboy)) { return new Busboy(opts) }
diff --git a/package.json b/package.json
index 1078b44..3cb7ecf 100644
--- a/package.json
+++ b/package.json
@@ -16,9 +16,9 @@
     }
   ],
   "description": "A streaming parser for HTML form data for node.js",
-  "main": "lib/main",
+  "main": "index.js",
   "type": "commonjs",
-  "types": "lib/main.d.ts",
+  "types": "types/index.d.ts",
   "scripts": {
     "bench:busboy": "cd benchmarks && npm install && npm run benchmark-fastify",
     "bench:dicer": "node bench/dicer/dicer-bench-multipart-parser.js",
@@ -26,7 +26,7 @@
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test:unit": "c8 --statements 98 --branches 97 --functions 96 --lines 98 node --test",
-    "test:types": "tsd",
+    "test:types": "tstyche",
     "test": "npm run test:unit && npm run test:types"
   },
   "devDependencies": {
@@ -38,7 +38,7 @@
     "eslint": "^9.39.0",
     "neostandard": "^0.12.0",
     "tinybench": "^6.0.0",
-    "tsd": "^0.33.0",
+    "tstyche": "^7.0.0",
     "tslib": "^2.8.1",
     "typescript": "~6.0.2"
   },
@@ -57,9 +57,6 @@
     "url": "https://github.com/fastify/busboy/issues"
   },
   "homepage": "https://github.com/fastify/busboy#readme",
-  "tsd": {
-    "directory": "test-types"
-  },
   "standard": {
     "globals": [
       "describe",
@@ -72,10 +69,12 @@
   "files": [
     "README.md",
     "LICENSE",
+    "index.js",
     "lib/*",
+    "types/*",
     "deps/encoding/*",
     "deps/dicer/lib",
     "deps/streamsearch/",
     "deps/dicer/LICENSE"
   ]
-}
+}
\ No newline at end of file
diff --git a/test-types/main.test-d.ts b/test-types/main.test-d.ts
deleted file mode 100644
index c705220..0000000
--- a/test-types/main.test-d.ts
+++ /dev/null
@@ -1,236 +0,0 @@
-/* eslint-disable import-x/no-duplicates */
-/* eslint-disable no-new */
-import BusboyDefault, { Busboy, BusboyFileStream } from '..'
-import { expectError, expectType } from 'tsd'
-import BusboyESM from '..'
-
-expectType<InstanceType<typeof Busboy>>(new BusboyESM({ headers: { 'content-type': 'foo' } }))
-expectType<InstanceType<typeof Busboy>>(new Busboy({ headers: { 'content-type': 'foo' } }))
-
-expectError(new BusboyDefault({}))
-const busboy = BusboyDefault({ headers: { 'content-type': 'foo' } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, highWaterMark: 1000 }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, fileHwm: 1000 }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, defCharset: 'utf8' }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, preservePath: true }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, limits: { fieldNameSize: 200 } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, limits: { fieldSize: 200 } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, limits: { fields: 200 } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, limits: { fileSize: 200 } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, limits: { files: 200 } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, limits: { parts: 200 } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, limits: { headerPairs: 200 } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, limits: { headerSize: 200 } }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, isPartAFile: (fieldName, contentType, fileName) => fieldName === 'my-special-field' || fileName !== 'not-so-special.txt' }) // $ExpectType Busboy
-new BusboyDefault({ headers: { 'content-type': 'foo' }, isPartAFile: (fieldName, contentType, fileName) => fileName !== undefined }) // $ExpectType Busboy
-
-busboy.addListener('file', (fieldname, file, filename, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<BusboyFileStream>(file)
-  expectType<string>(filename)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.addListener('field', (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<string>(val)
-  expectType<boolean>(fieldnameTruncated)
-  expectType<boolean>(valTruncated)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.addListener('partsLimit', () => {})
-busboy.addListener('filesLimit', () => {})
-busboy.addListener('fieldsLimit', () => {})
-busboy.addListener('error', e => {
-  expectType<unknown>(e)
-})
-busboy.addListener('finish', () => {})
-// test fallback
-busboy.on('foo', foo => {
-  expectType<any>(foo)
-})
-busboy.on(Symbol('foo'), foo => {
-  expectType<any>(foo)
-})
-
-busboy.on('file', (fieldname, file, filename, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<BusboyFileStream>(file)
-  expectType<string>(filename)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.on('field', (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<string>(val)
-  expectType<boolean>(fieldnameTruncated)
-  expectType<boolean>(valTruncated)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.on('partsLimit', () => {})
-busboy.on('filesLimit', () => {})
-busboy.on('fieldsLimit', () => {})
-busboy.on('error', e => {
-  expectType<unknown>(e)
-})
-busboy.on('finish', () => {})
-// test fallback
-busboy.on('foo', foo => {
-  expectType<any>(foo)
-})
-busboy.on(Symbol('foo'), foo => {
-  expectType<any>(foo)
-})
-
-busboy.once('file', (fieldname, file, filename, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<BusboyFileStream>(file)
-  expectType<string>(filename)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.once('field', (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<string>(val)
-  expectType<boolean>(fieldnameTruncated)
-  expectType<boolean>(valTruncated)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.once('partsLimit', () => {})
-busboy.once('filesLimit', () => {})
-busboy.once('fieldsLimit', () => {})
-busboy.once('error', e => {
-  expectType<unknown>(e)
-})
-busboy.once('finish', () => {})
-// test fallback
-busboy.once('foo', foo => {
-  expectType<any>(foo)
-})
-busboy.once(Symbol('foo'), foo => {
-  expectType<any>(foo)
-})
-
-busboy.removeListener('file', (fieldname, file, filename, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<BusboyFileStream>(file)
-  expectType<string>(filename)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.removeListener('field', (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<string>(val)
-  expectType<boolean>(fieldnameTruncated)
-  expectType<boolean>(valTruncated)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.removeListener('partsLimit', () => {})
-busboy.removeListener('filesLimit', () => {})
-busboy.removeListener('fieldsLimit', () => {})
-busboy.removeListener('error', e => {
-  expectType<unknown>(e)
-})
-busboy.removeListener('finish', () => {})
-// test fallback
-busboy.removeListener('foo', foo => {
-  expectType<any>(foo)
-})
-busboy.removeListener(Symbol('foo'), foo => {
-  expectType<any>(foo)
-})
-
-busboy.off('file', (fieldname, file, filename, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<BusboyFileStream>(file)
-  expectType<string>(filename)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.off('field', (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<string>(val)
-  expectType<boolean>(fieldnameTruncated)
-  expectType<boolean>(valTruncated)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.off('partsLimit', () => {})
-busboy.off('filesLimit', () => {})
-busboy.off('fieldsLimit', () => {})
-busboy.off('error', e => {
-  expectType<unknown>(e)
-})
-busboy.off('finish', () => {})
-// test fallback
-busboy.off('foo', foo => {
-  expectType<any>(foo)
-})
-busboy.off(Symbol('foo'), foo => {
-  expectType<any>(foo)
-})
-
-busboy.prependListener('file', (fieldname, file, filename, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<BusboyFileStream>(file)
-  expectType<string>(filename)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.prependListener('field', (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<string>(val)
-  expectType<boolean>(fieldnameTruncated)
-  expectType<boolean>(valTruncated)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.prependListener('partsLimit', () => {})
-busboy.prependListener('filesLimit', () => {})
-busboy.prependListener('fieldsLimit', () => {})
-busboy.prependListener('error', e => {
-  expectType<unknown>(e)
-})
-busboy.prependListener('finish', () => {})
-// test fallback
-busboy.prependListener('foo', foo => {
-  expectType<any>(foo)
-})
-busboy.prependListener(Symbol('foo'), foo => {
-  expectType<any>(foo)
-})
-
-busboy.prependOnceListener('file', (fieldname, file, filename, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<BusboyFileStream>(file)
-  expectType<string>(filename)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.prependOnceListener('field', (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
-  expectType<string>(fieldname)
-  expectType<string>(val)
-  expectType<boolean>(fieldnameTruncated)
-  expectType<boolean>(valTruncated)
-  expectType<string>(encoding)
-  expectType<string>(mimetype)
-})
-busboy.prependOnceListener('partsLimit', () => {})
-busboy.prependOnceListener('filesLimit', () => {})
-busboy.prependOnceListener('fieldsLimit', () => {})
-busboy.prependOnceListener('error', e => {
-  expectType<unknown>(e)
-})
-busboy.prependOnceListener('finish', () => {})
-// test fallback
-busboy.prependOnceListener('foo', foo => {
-  expectType<any>(foo)
-})
-busboy.prependOnceListener(Symbol('foo'), foo => {
-  expectType<any>(foo)
-})
diff --git a/test/busboy-constructor.test.js b/test/busboy-constructor.test.js
index fb4e5dc..bf70af1 100644
--- a/test/busboy-constructor.test.js
+++ b/test/busboy-constructor.test.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const Busboy = require('../lib/main')
+const Busboy = require('..')
 const { test } = require('node:test')
 
 test('busboy-constructor - should throw an Error if no options are provided', t => {
diff --git a/test/busboy-emit.test.js b/test/busboy-emit.test.js
index bfa1736..dcc4a98 100644
--- a/test/busboy-emit.test.js
+++ b/test/busboy-emit.test.js
@@ -1,6 +1,6 @@
 'use strict'
 
-const Busboy = require('../lib/main')
+const Busboy = require('..')
 const { test } = require('node:test')
 
 test('busboy, emit', t => {
diff --git a/test/dicer-export.test.js b/test/dicer-export.test.js
index a1a8bd2..9ab3360 100644
--- a/test/dicer-export.test.js
+++ b/test/dicer-export.test.js
@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('node:test')
-const { Dicer } = require('../lib/main')
+const { Dicer } = require('..')
 
 test('dicer-export', async t => {
   t.plan(2)
diff --git a/test/dicer-write.test.js b/test/dicer-write.test.js
index dd74493..448a7d4 100644
--- a/test/dicer-write.test.js
+++ b/test/dicer-write.test.js
@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('node:test')
-const { Dicer } = require('../lib/main')
+const { Dicer } = require('..')
 
 test('dicer _write method', t => {
   t.plan(1)
diff --git a/test/multipart-constructor.test.js b/test/multipart-constructor.test.js
index 671ebf5..56592b2 100644
--- a/test/multipart-constructor.test.js
+++ b/test/multipart-constructor.test.js
@@ -1,7 +1,7 @@
 'use strict'
 
 const Multipart = require('../lib/types/multipart')
-const Busboy = require('../lib/main')
+const Busboy = require('..')
 const { test } = require('node:test')
 
 test('multipart constructor', t => {
diff --git a/tsconfig.json b/tsconfig.json
index 4cc6e43..83748d8 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,6 +1,7 @@
 {
   "compilerOptions": {
     "outDir": "dist",
+    "rootDir": ".",
     "module": "Node16",
     "target": "es2022",
     "sourceMap": false,
@@ -17,7 +18,6 @@
     "noImplicitThis": true,
     "strictNullChecks": true,
     "importHelpers": true,
-    "baseUrl": ".",
     "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true
diff --git a/test-types/dicer.test-d.ts b/types/dicer.tst.ts
similarity index 98%
rename from test-types/dicer.test-d.ts
rename to types/dicer.tst.ts
index b7f2005..c6ff777 100644
--- a/test-types/dicer.test-d.ts
+++ b/types/dicer.tst.ts
@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { Dicer } from '../lib/main'
+import { Dicer } from '.'
 import * as fs from 'fs'
 import * as stream from 'stream'
 
@@ -17,6 +17,7 @@ function testDicerSyntax () {
     headerFirst: false,
     maxHeaderPairs: 8,
   }
+
   dicer.setBoundary('new-testing-boundary')
   dicer.on('part', handleDicerPartStream)
   dicer.on('finish', () => {
diff --git a/lib/main.d.ts b/types/index.d.ts
similarity index 100%
rename from lib/main.d.ts
rename to types/index.d.ts
diff --git a/types/index.tst.ts b/types/index.tst.ts
new file mode 100644
index 0000000..634d619
--- /dev/null
+++ b/types/index.tst.ts
@@ -0,0 +1,301 @@
+/* eslint-disable import-x/no-duplicates */
+/* eslint-disable no-new */
+import BusboyDefault, { Busboy, BusboyFileStream } from '.'
+import { expect } from 'tstyche'
+import BusboyESM from '.'
+
+expect(new BusboyESM({ headers: { 'content-type': 'foo' } })).type.toBe<
+  InstanceType<typeof Busboy>
+>()
+expect(new Busboy({ headers: { 'content-type': 'foo' } })).type.toBe<
+  InstanceType<typeof Busboy>
+>()
+
+expect(BusboyDefault).type.not.toBeConstructableWith({})
+const busboy = BusboyDefault({ headers: { 'content-type': 'foo' } })
+new BusboyDefault({ headers: { 'content-type': 'foo' } })
+new BusboyDefault({ headers: { 'content-type': 'foo' }, highWaterMark: 1000 })
+new BusboyDefault({ headers: { 'content-type': 'foo' }, fileHwm: 1000 })
+new BusboyDefault({ headers: { 'content-type': 'foo' }, defCharset: 'utf8' })
+new BusboyDefault({ headers: { 'content-type': 'foo' }, preservePath: true })
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  limits: { fieldNameSize: 200 }
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  limits: { fieldSize: 200 }
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  limits: { fields: 200 }
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  limits: { fileSize: 200 }
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  limits: { files: 200 }
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  limits: { parts: 200 }
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  limits: { headerPairs: 200 }
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  limits: { headerSize: 200 }
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  isPartAFile: (fieldName, contentType, fileName) =>
+    fieldName === 'my-special-field' || fileName !== 'not-so-special.txt'
+})
+new BusboyDefault({
+  headers: { 'content-type': 'foo' },
+  isPartAFile: (fieldName, contentType, fileName) => fileName !== undefined
+})
+
+busboy.addListener('file', (fieldname, file, filename, encoding, mimetype) => {
+  expect(fieldname).type.toBe<string>()
+  expect(file).type.toBe<BusboyFileStream>()
+  expect(filename).type.toBe<string>()
+  expect(encoding).type.toBe<string>()
+  expect(mimetype).type.toBe<string>()
+})
+busboy.addListener(
+  'field',
+  (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(val).type.toBe<string>()
+    expect(fieldnameTruncated).type.toBe<boolean>()
+    expect(valTruncated).type.toBe<boolean>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.addListener('partsLimit', () => {})
+busboy.addListener('filesLimit', () => {})
+busboy.addListener('fieldsLimit', () => {})
+busboy.addListener('error', (e) => {
+  expect(e).type.toBe<unknown>()
+})
+busboy.addListener('finish', () => {})
+// test fallback
+busboy.on('foo', (foo) => {
+  expect(foo).type.toBe<any>()
+})
+busboy.on(Symbol('foo'), (foo) => {
+  expect(foo).type.toBe<any>()
+})
+
+busboy.on('file', (fieldname, file, filename, encoding, mimetype) => {
+  expect(fieldname).type.toBe<string>()
+  expect(file).type.toBe<BusboyFileStream>()
+  expect(filename).type.toBe<string>()
+  expect(encoding).type.toBe<string>()
+  expect(mimetype).type.toBe<string>()
+})
+busboy.on(
+  'field',
+  (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(val).type.toBe<string>()
+    expect(fieldnameTruncated).type.toBe<boolean>()
+    expect(valTruncated).type.toBe<boolean>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.on('partsLimit', () => {})
+busboy.on('filesLimit', () => {})
+busboy.on('fieldsLimit', () => {})
+busboy.on('error', (e) => {
+  expect(e).type.toBe<unknown>()
+})
+busboy.on('finish', () => {})
+// test fallback
+busboy.on('foo', (foo) => {
+  expect(foo).type.toBe<any>()
+})
+busboy.on(Symbol('foo'), (foo) => {
+  expect(foo).type.toBe<any>()
+})
+
+busboy.once('file', (fieldname, file, filename, encoding, mimetype) => {
+  expect(fieldname).type.toBe<string>()
+  expect(file).type.toBe<BusboyFileStream>()
+  expect(filename).type.toBe<string>()
+  expect(encoding).type.toBe<string>()
+  expect(mimetype).type.toBe<string>()
+})
+busboy.once(
+  'field',
+  (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(val).type.toBe<string>()
+    expect(fieldnameTruncated).type.toBe<boolean>()
+    expect(valTruncated).type.toBe<boolean>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.once('partsLimit', () => {})
+busboy.once('filesLimit', () => {})
+busboy.once('fieldsLimit', () => {})
+busboy.once('error', (e) => {
+  expect(e).type.toBe<unknown>()
+})
+busboy.once('finish', () => {})
+// test fallback
+busboy.once('foo', (foo) => {
+  expect(foo).type.toBe<any>()
+})
+busboy.once(Symbol('foo'), (foo) => {
+  expect(foo).type.toBe<any>()
+})
+
+busboy.removeListener(
+  'file',
+  (fieldname, file, filename, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(file).type.toBe<BusboyFileStream>()
+    expect(filename).type.toBe<string>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.removeListener(
+  'field',
+  (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(val).type.toBe<string>()
+    expect(fieldnameTruncated).type.toBe<boolean>()
+    expect(valTruncated).type.toBe<boolean>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.removeListener('partsLimit', () => {})
+busboy.removeListener('filesLimit', () => {})
+busboy.removeListener('fieldsLimit', () => {})
+busboy.removeListener('error', (e) => {
+  expect(e).type.toBe<unknown>()
+})
+busboy.removeListener('finish', () => {})
+// test fallback
+busboy.removeListener('foo', (foo) => {
+  expect(foo).type.toBe<any>()
+})
+busboy.removeListener(Symbol('foo'), (foo) => {
+  expect(foo).type.toBe<any>()
+})
+
+busboy.off('file', (fieldname, file, filename, encoding, mimetype) => {
+  expect(fieldname).type.toBe<string>()
+  expect(file).type.toBe<BusboyFileStream>()
+  expect(filename).type.toBe<string>()
+  expect(encoding).type.toBe<string>()
+  expect(mimetype).type.toBe<string>()
+})
+busboy.off(
+  'field',
+  (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(val).type.toBe<string>()
+    expect(fieldnameTruncated).type.toBe<boolean>()
+    expect(valTruncated).type.toBe<boolean>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.off('partsLimit', () => {})
+busboy.off('filesLimit', () => {})
+busboy.off('fieldsLimit', () => {})
+busboy.off('error', (e) => {
+  expect(e).type.toBe<unknown>()
+})
+busboy.off('finish', () => {})
+// test fallback
+busboy.off('foo', (foo) => {
+  expect(foo).type.toBe<any>()
+})
+busboy.off(Symbol('foo'), (foo) => {
+  expect(foo).type.toBe<any>()
+})
+
+busboy.prependListener(
+  'file',
+  (fieldname, file, filename, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(file).type.toBe<BusboyFileStream>()
+    expect(filename).type.toBe<string>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.prependListener(
+  'field',
+  (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(val).type.toBe<string>()
+    expect(fieldnameTruncated).type.toBe<boolean>()
+    expect(valTruncated).type.toBe<boolean>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.prependListener('partsLimit', () => {})
+busboy.prependListener('filesLimit', () => {})
+busboy.prependListener('fieldsLimit', () => {})
+busboy.prependListener('error', (e) => {
+  expect(e).type.toBe<unknown>()
+})
+busboy.prependListener('finish', () => {})
+// test fallback
+busboy.prependListener('foo', (foo) => {
+  expect(foo).type.toBe<any>()
+})
+busboy.prependListener(Symbol('foo'), (foo) => {
+  expect(foo).type.toBe<any>()
+})
+
+busboy.prependOnceListener(
+  'file',
+  (fieldname, file, filename, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(file).type.toBe<BusboyFileStream>()
+    expect(filename).type.toBe<string>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.prependOnceListener(
+  'field',
+  (fieldname, val, fieldnameTruncated, valTruncated, encoding, mimetype) => {
+    expect(fieldname).type.toBe<string>()
+    expect(val).type.toBe<string>()
+    expect(fieldnameTruncated).type.toBe<boolean>()
+    expect(valTruncated).type.toBe<boolean>()
+    expect(encoding).type.toBe<string>()
+    expect(mimetype).type.toBe<string>()
+  }
+)
+busboy.prependOnceListener('partsLimit', () => {})
+busboy.prependOnceListener('filesLimit', () => {})
+busboy.prependOnceListener('fieldsLimit', () => {})
+busboy.prependOnceListener('error', (e) => {
+  expect(e).type.toBe<unknown>()
+})
+busboy.prependOnceListener('finish', () => {})
+// test fallback
+busboy.prependOnceListener('foo', (foo) => {
+  expect(foo).type.toBe<any>()
+})
+busboy.prependOnceListener(Symbol('foo'), (foo) => {
+  expect(foo).type.toBe<any>()
+})