diff --git a/.gitignore b/.gitignore
index 0842e14..afa1bb1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,4 +11,5 @@ node_modules
 dist
 *.local
 
-docs/.vitepress/cache
\ No newline at end of file
+docs/.vitepress/cache
+tsconfig.vitest-temp.json
diff --git a/package.json b/package.json
index cd8f3b0..fa66384 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
   "homepage": "https://github.com/kitbagjs/events#readme",
   "scripts": {
     "build": "tsc && vite build",
-    "test": "vitest",
+    "test": "vitest --typecheck",
     "types": "tsc --noEmit",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
diff --git a/src/createEmitter.ts b/src/createEmitter.ts
new file mode 100644
index 0000000..b606740
--- /dev/null
+++ b/src/createEmitter.ts
@@ -0,0 +1,223 @@
+import { EmitterTimeoutError } from './errors'
+import { 
+  EmitterOptions,
+  EmitterEvents,
+  EventHandler,
+  GlobalEventHandler,
+  EmitterOnOptions,
+  EmitterOnceOptions,
+  EmitterNextOptions,
+  GlobalEventHandlerResponse,
+  EventPayload,
+} from './types'
+
+type EmitterState = {
+  channel?: BroadcastChannel | null
+}
+
+export function createEmitter<TEvents extends EmitterEvents>(options?: EmitterOptions) {
+  type TEvent = keyof TEvents
+
+  const handlers = new Map<TEvent, Set<EventHandler>>()
+  const globalHandlers = new Set<GlobalEventHandler<TEvents>>()
+  const state: EmitterState = {}
+
+  if(options) {
+    setOptions(options)
+  }
+
+  function setOptions(options: EmitterOptions): void {
+    const channel = getBroadcastChannel(options.broadcastChannel)
+
+    if(channel) {
+      channel.onmessage = onBroadcastChannelMessage
+    }
+    
+    state.channel = channel
+  }
+
+  function onBroadcastChannelMessage({data}: MessageEvent) {
+    const { event, payload } = data
+
+    onEvent(event, payload)
+  }
+
+  function on(globalEventHandler: GlobalEventHandler<TEvents>, options?: EmitterOnOptions): () => void
+  function on<E extends TEvent>(event: E, handler: EventHandler<EventPayload<TEvents, E>>, options?: EmitterOnOptions): () => void
+  function on<E extends TEvent>(globalHandlerOrEvent: E | GlobalEventHandler<TEvents>, handlerOrOptions?: EventHandler<EventPayload<TEvents, E>> | EmitterOnOptions, options?: EmitterOnOptions): () => void {
+    if (isGlobalEventHandler(globalHandlerOrEvent)) {
+      const globalHandlerOptions = typeof handlerOrOptions === 'object' ? handlerOrOptions : {}
+
+      return addGlobalHandler(globalHandlerOrEvent, globalHandlerOptions)
+    }
+
+    const handler = typeof handlerOrOptions === 'function' ? handlerOrOptions : undefined
+    const event = globalHandlerOrEvent
+    const handlerOptions = options ?? {}
+
+    if (!handler) {
+      throw new Error(`Handler must be given for ${String(event)} event`)
+    }
+
+    return addEventHandler(event, handler, handlerOptions)
+  }
+
+  function once(globalEventHandler: GlobalEventHandler<TEvents>, options?: EmitterOnceOptions): () => void
+  function once<E extends TEvent>(event: E, handler: EventHandler<EventPayload<TEvents, E>>, options?: EmitterOnceOptions): () => void
+  function once<E extends TEvent>(globalHandlerOrEvent: E | GlobalEventHandler<TEvents>, handlerOrOptions?: EventHandler<EventPayload<TEvents, E>> | EmitterOnceOptions, options?: EmitterOnceOptions): () => void {
+    if (isGlobalEventHandler(globalHandlerOrEvent)) {
+      const globalHandlerOptions = typeof handlerOrOptions === 'object' ? handlerOrOptions : {}
+
+      const callback: GlobalEventHandler<TEvents> = (args) => {
+        off(callback)
+        globalHandlerOrEvent(args)
+      }
+
+      return addGlobalHandler(callback, globalHandlerOptions)
+    }
+
+    const event = globalHandlerOrEvent
+    const handler = typeof handlerOrOptions === 'function' ? handlerOrOptions : undefined
+    const handlerOptions = options ?? {}
+
+    if (!handler) {
+      throw new Error(`Handler must be given for ${String(event)} event`)
+    }
+
+    const callback: EventHandler<EventPayload<TEvents, E>> = (args) => {
+      off(event, callback)
+      handler(args)
+    }
+
+    return addEventHandler(event, callback, handlerOptions)
+  }
+
+  function next(options?: EmitterNextOptions): Promise<GlobalEventHandlerResponse<TEvents>>
+  function next<E extends TEvent>(event: E, options?: EmitterNextOptions): Promise<EventPayload<TEvents, E>>
+  function next<E extends TEvent>(eventOrOptions?: E | EmitterNextOptions, options?: EmitterNextOptions): Promise<GlobalEventHandlerResponse<TEvents> |EventPayload<TEvents, E>> {
+    const event = typeof eventOrOptions === 'string' ? eventOrOptions : undefined
+    const { timeout } = typeof eventOrOptions === 'object' ? eventOrOptions : options ?? {}
+
+    if(event) {
+      return new Promise((resolve, reject) => {
+        once(event, resolve)
+
+        if(timeout) {
+          setTimeout(() => {
+            reject(new EmitterTimeoutError(event, timeout))
+          }, timeout)
+        }
+      })
+    }
+
+    return new Promise((resolve, reject) => {
+      once(resolve)
+
+      if(timeout) {
+        setTimeout(() => {
+          reject(new EmitterTimeoutError('global', timeout))
+        }, timeout)
+      }
+    })
+  }
+
+  function off(globalEventHandler: GlobalEventHandler<TEvents>): void
+  function off<E extends TEvent>(event: E): void
+  function off<E extends TEvent>(event: E, handler: EventHandler<EventPayload<TEvents, E>>): void
+  function off<E extends TEvent>(globalHandlerOrEvent: E, handler?: EventHandler<EventPayload<TEvents, E>>): void {
+    if (isGlobalEventHandler(globalHandlerOrEvent)) {
+      globalHandlers.delete(globalHandlerOrEvent)
+      return
+    }
+
+    const event = globalHandlerOrEvent
+    const eventHandlers = handlers.get(event)
+
+    if (handler) {
+      eventHandlers?.delete(handler)
+      return
+    }
+    
+    eventHandlers?.clear()
+  }
+
+  function emit<E extends TEvent>(event: undefined extends EventPayload<TEvents, E> ? E : never): void
+  function emit<E extends TEvent>(event: E, payload: EventPayload<TEvents, E>): void
+  function emit<E extends TEvent>(event: E, payload?: EventPayload<TEvents, E>): void {
+    state.channel?.postMessage({ event, payload })
+
+    onEvent(event, payload!)
+  }
+
+  function clear(): void {
+    handlers.clear()
+    globalHandlers.clear()
+  }
+
+  function isGlobalEventHandler(value: unknown): value is GlobalEventHandler<TEvents> {
+    return typeof value === 'function'
+  }
+
+  function onEvent<E extends TEvent>(event: E, payload: EventPayload<TEvents, E>): void {
+    handlers.get(event)?.forEach(handler => handler(payload))
+
+    globalHandlers.forEach(handler => handler({
+      kind: event,
+      payload,
+    }))
+  }
+
+  function addGlobalHandler(globalEventHandler: GlobalEventHandler<TEvents>, options?: EmitterOnOptions): () => void {
+    const { signal } = options ?? {}
+
+    if(signal?.aborted) {
+      return () => {}
+    }
+
+    globalHandlers.add(globalEventHandler)
+
+    const offHandler = () => off(globalEventHandler)
+
+    signal?.addEventListener('abort', offHandler)
+
+    return offHandler
+  }
+
+  function addEventHandler<E extends TEvent>(event: E, handler: EventHandler<EventPayload<TEvents, E>>, options?: EmitterOnOptions): () => void {
+    const { signal } = options ?? {}
+
+    if(signal?.aborted) {
+      return () => {}
+    }
+
+    if(!handlers.has(event)){
+      handlers.set(event, new Set())
+    }
+    
+    handlers.get(event)?.add(handler)
+
+    const offHandler = () => off(event, handler)
+
+    signal?.addEventListener('abort', offHandler)
+
+    return offHandler
+  }
+
+  return {
+    on,
+    off,
+    once,
+    next,
+    emit,
+    clear,
+    setOptions,
+  }
+}
+
+function getBroadcastChannel(useBroadcastChannel: string = ''): BroadcastChannel | null {
+  if(useBroadcastChannel) {
+    return new BroadcastChannel(useBroadcastChannel)
+  }
+
+  return null
+}
\ No newline at end of file
diff --git a/src/errors.ts b/src/errors.ts
new file mode 100644
index 0000000..2a77b21
--- /dev/null
+++ b/src/errors.ts
@@ -0,0 +1,5 @@
+export class EmitterTimeoutError extends Error {
+  constructor(event: string, timeout: number) {
+    super(`Timeout waiting for ${event} event after ${timeout}ms`)
+  }
+}
diff --git a/src/main.ts b/src/main.ts
index b25e43b..294590c 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -1,247 +1,13 @@
-export type EmitterOptions = {
-  broadcastChannel?: string
-}
-
-type Handler<T = any> = (...payload: T[]) => void
-
-type Events = Record<string, unknown>
-
-export type GlobalEventHandler<T extends Events> = (event: GlobalEvent<T>) => void
-
-export type GlobalEvent<T extends Events> = {
-  [K in keyof T]: {
-    kind: K,
-    payload: T[K],
-  }
-}[keyof T]
-
-export type NextOptions = {
-  timeout?: number
-}
-
-export type EmitterOnOptions = {
-  signal?: AbortSignal
-}
-
-export type EmitterOnceOptions = {
-  signal?: AbortSignal
-}
-
-export class EmitterTimeoutError extends Error {
-  constructor(event: string, timeout: number) {
-    super(`Timeout waiting for ${event} event after ${timeout}ms`)
-  }
-}
-
-type EmitterState = {
-  channel?: BroadcastChannel | null
-}
-
-function getBroadcastChannel(useBroadcastChannel: string = ''): BroadcastChannel | null {
-  if(useBroadcastChannel) {
-    return new BroadcastChannel(useBroadcastChannel)
-  }
-
-  return null
-}
-
-export function createEmitter<T extends Events>(options?: EmitterOptions) {
-  type Event = keyof T
-  type EventPayload<E extends Event> = T[E]
-  type Handlers = Set<Handler>
-
-  const handlers = new Map<Event, Handlers>()
-  const globalHandlers = new Set<GlobalEventHandler<T>>()
-  const state: EmitterState = {}
-
-  if(options) {
-    setOptions(options)
-  }
-
-  function setOptions(options: EmitterOptions): void {
-    const channel = getBroadcastChannel(options.broadcastChannel)
-
-    if(channel) {
-      channel.onmessage = onBroadcastChannelMessage
-    }
-    
-    state.channel = channel
-  }
-
-  function onBroadcastChannelMessage({data}: MessageEvent) {
-    const { event, payload } = data
-
-    onEvent(event, payload)
-  }
-
-  function on(globalEventHandler: GlobalEventHandler<T>, options?: EmitterOnOptions): () => void
-  function on<E extends Event>(event: E, handler: Handler<EventPayload<E>>, options?: EmitterOnOptions): () => void
-  function on<E extends Event>(globalHandlerOrEvent: E | GlobalEventHandler<T>, handlerOrOptions?: Handler<EventPayload<E>> | EmitterOnOptions, options?: EmitterOnOptions): () => void {
-    if (isGlobalEventHandler(globalHandlerOrEvent)) {
-      const globalHandlerOptions = typeof handlerOrOptions === 'object' ? handlerOrOptions : {}
-
-      return addGlobalHandler(globalHandlerOrEvent, globalHandlerOptions)
-    }
-
-    const handler = typeof handlerOrOptions === 'function' ? handlerOrOptions : undefined
-    const event = globalHandlerOrEvent
-    const handlerOptions = options ?? {}
-
-    if (!handler) {
-      throw new Error(`Handler must be given for ${String(event)} event`)
-    }
-
-    return addEventHandler(event, handler, handlerOptions)
-  }
-
-  function once(globalEventHandler: GlobalEventHandler<T>, options?: EmitterOnceOptions): () => void
-  function once<E extends Event>(event: E, handler: Handler<EventPayload<E>>, options?: EmitterOnceOptions): () => void
-  function once<E extends Event>(globalHandlerOrEvent: E | GlobalEventHandler<T>, handlerOrOptions?: Handler<EventPayload<E>> | EmitterOnceOptions, options?: EmitterOnceOptions): () => void {
-    if (isGlobalEventHandler(globalHandlerOrEvent)) {
-      const globalHandlerOptions = typeof handlerOrOptions === 'object' ? handlerOrOptions : {}
-
-      const callback: GlobalEventHandler<T> = (args) => {
-        off(callback)
-        globalHandlerOrEvent(args)
-      }
-
-      return addGlobalHandler(callback, globalHandlerOptions)
-    }
-
-    const event = globalHandlerOrEvent
-    const handler = typeof handlerOrOptions === 'function' ? handlerOrOptions : undefined
-    const handlerOptions = options ?? {}
-
-    if (!handler) {
-      throw new Error(`Handler must be given for ${String(event)} event`)
-    }
-
-    const callback: Handler<EventPayload<E>> = (args) => {
-      off(event, callback)
-      handler(args)
-    }
-
-    return addEventHandler(event, callback, handlerOptions)
-  }
-
-  function next(options?: NextOptions): Promise<GlobalEvent<T>>
-  function next<E extends Event>(event: E, options?: NextOptions): Promise<EventPayload<E>>
-  function next<E extends Event>(eventOrOptions?: E | NextOptions, options?: NextOptions): Promise<GlobalEvent<T> |EventPayload<E>> {
-    const event = typeof eventOrOptions === 'string' ? eventOrOptions : undefined
-    const { timeout } = typeof eventOrOptions === 'object' ? eventOrOptions : options ?? {}
-
-    if(event) {
-      return new Promise((resolve, reject) => {
-        once(event, resolve)
-
-        if(timeout) {
-          setTimeout(() => {
-            reject(new EmitterTimeoutError(event, timeout))
-          }, timeout)
-        }
-      })
-    }
-
-    return new Promise((resolve, reject) => {
-      once(resolve)
-
-      if(timeout) {
-        setTimeout(() => {
-          reject(new EmitterTimeoutError('global', timeout))
-        }, timeout)
-      }
-    })
-  }
-
-  function off(globalEventHandler: GlobalEventHandler<T>): void
-  function off<E extends Event>(event: E): void
-  function off<E extends Event>(event: E, handler: Handler<EventPayload<E>>): void
-  function off<E extends Event>(globalHandlerOrEvent: E, handler?: Handler<EventPayload<E>>): void {
-    if (isGlobalEventHandler(globalHandlerOrEvent)) {
-      globalHandlers.delete(globalHandlerOrEvent)
-      return
-    }
-
-    const event = globalHandlerOrEvent
-    const eventHandlers = handlers.get(event)
-
-    if (handler) {
-      eventHandlers?.delete(handler)
-      return
-    }
-    
-    eventHandlers?.clear()
-  }
-
-  function emit<E extends Event>(event: undefined extends EventPayload<E> ? E : never): void
-  function emit<E extends Event>(event: E, payload: EventPayload<E>): void
-  function emit<E extends Event>(event: E, payload?: EventPayload<E>): void {
-    state.channel?.postMessage({ event, payload })
-
-    onEvent(event, payload!)
-  }
-
-  function clear(): void {
-    handlers.clear()
-    globalHandlers.clear()
-  }
-
-  function isGlobalEventHandler(value: unknown): value is GlobalEventHandler<T> {
-    return typeof value === 'function'
-  }
-
-  function onEvent<E extends Event>(event: E, payload: EventPayload<E>): void {
-    handlers.get(event)?.forEach(handler => handler(payload))
-
-    globalHandlers.forEach(handler => handler({
-      kind: event,
-      payload,
-    }))
-  }
-
-  function addGlobalHandler(globalEventHandler: GlobalEventHandler<T>, options?: EmitterOnOptions): () => void {
-    const { signal } = options ?? {}
-
-    if(signal?.aborted) {
-      return () => {}
-    }
-
-    globalHandlers.add(globalEventHandler)
-
-    const offHandler = () => off(globalEventHandler)
-
-    signal?.addEventListener('abort', offHandler)
-
-    return offHandler
-  }
-
-  function addEventHandler<E extends Event>(event: E, handler: Handler<EventPayload<E>>, options?: EmitterOnOptions): () => void {
-    const { signal } = options ?? {}
-
-    if(signal?.aborted) {
-      return () => {}
-    }
-
-    if(!handlers.has(event)){
-      handlers.set(event, new Set())
-    }
-    
-    handlers.get(event)?.add(handler)
-
-    const offHandler = () => off(event, handler)
-
-    signal?.addEventListener('abort', offHandler)
-
-    return offHandler
-  }
-
-  return {
-    on,
-    off,
-    once,
-    next,
-    emit,
-    clear,
-    setOptions,
-  }
-}
\ No newline at end of file
+export type { 
+  EmitterOptions,
+  EmitterEvents,
+  EventHandler,
+  GlobalEventHandler,
+  EmitterOnOptions,
+  EmitterOnceOptions,
+  EmitterNextOptions,
+  GlobalEventHandlerResponse,
+} from './types'
+
+export { createEmitter } from './createEmitter'
+export { EmitterTimeoutError } from './errors'
\ No newline at end of file
diff --git a/src/types.ts b/src/types.ts
new file mode 100644
index 0000000..cf9131e
--- /dev/null
+++ b/src/types.ts
@@ -0,0 +1,30 @@
+export type EmitterOptions = {
+  broadcastChannel?: string
+}
+
+export type EmitterNextOptions = {
+  timeout?: number
+}
+
+export type EmitterOnOptions = {
+  signal?: AbortSignal
+}
+
+export type EmitterOnceOptions = {
+  signal?: AbortSignal
+}
+
+export type EventHandler<T = any> = (...payload: T[]) => void
+
+export type EventPayload<TEvents extends EmitterEvents, TEvent extends keyof TEvents> = TEvents[TEvent]
+
+export type EmitterEvents = Record<string, unknown>
+
+export type GlobalEventHandler<T extends EmitterEvents> = (event: GlobalEventHandlerResponse<T>) => void
+
+export type GlobalEventHandlerResponse<T extends EmitterEvents> = {
+  [K in keyof T]: {
+    kind: K,
+    payload: T[K],
+  }
+}[keyof T]
\ No newline at end of file
diff --git a/tests/events.spec-d.ts b/tests/events.spec-d.ts
new file mode 100644
index 0000000..7388f55
--- /dev/null
+++ b/tests/events.spec-d.ts
@@ -0,0 +1,200 @@
+import { describe, expectTypeOf, test, vi } from "vitest";
+import { createEmitter } from "../src/createEmitter";
+import { EmitterNextOptions, EventHandler, EventPayload, GlobalEventHandlerResponse } from "../src/types";
+
+type Events = {
+  ping: void,
+  hello: string,
+  user: { name: string }
+}
+
+describe('emitter.on', () => {
+  test('has the correct return type', () => {
+    const emitter = createEmitter<Events>()
+    const response = emitter.on('ping', vi.fn())
+
+    type Source = typeof response
+    type Expected = () => void
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+
+    const globalResponse = emitter.on(vi.fn())
+
+    type GlobalSource = typeof globalResponse
+    type GlobalExpected = () => void
+
+    expectTypeOf<GlobalSource>().toEqualTypeOf<GlobalExpected>()
+  })
+
+  test('has the correct payload', () => {
+    const emitter = createEmitter<Events>()
+
+    emitter.on('ping', payload => {
+      expectTypeOf<typeof payload>().toEqualTypeOf<void>()
+    })
+
+    emitter.on('hello', payload => {
+      expectTypeOf<typeof payload>().toEqualTypeOf<string>()
+    })
+
+    emitter.on('user', payload => {
+      expectTypeOf<typeof payload>().toEqualTypeOf<{ name: string }>()
+    })
+
+    emitter.on(payload => {
+      type Expected = GlobalEventHandlerResponse<Events>
+      expectTypeOf<typeof payload>().toEqualTypeOf<Expected>()
+    })
+  })
+})
+
+describe('emitter.once', () => {
+  test('has the correct return type', () => {
+    const emitter = createEmitter<Events>()
+    const response = emitter.once('hello', vi.fn())
+
+    type Source = typeof response
+    type Expected = () => void
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+
+    const globalResponse = emitter.once(vi.fn())
+
+    type GlobalSource = typeof globalResponse
+    type GlobalExpected = () => void
+
+    expectTypeOf<GlobalSource>().toEqualTypeOf<GlobalExpected>()
+  })
+
+  test('has the correct payload', () => {
+    const emitter = createEmitter<Events>()
+
+    emitter.once('ping', payload => {
+      expectTypeOf<typeof payload>().toEqualTypeOf<void>()
+    })
+
+    emitter.once('hello', payload => {
+      expectTypeOf<typeof payload>().toEqualTypeOf<string>()
+    })
+
+    emitter.once('user', payload => {
+      expectTypeOf<typeof payload>().toEqualTypeOf<{ name: string }>()
+    })
+
+    emitter.once(payload => {
+      type Expected = GlobalEventHandlerResponse<Events>
+      expectTypeOf<typeof payload>().toEqualTypeOf<Expected>()
+    })
+  })
+})
+
+describe('emitter.next', () => {
+
+  // note: The `Parameters` type only tests the last overload. So we cannot test the global handler parameters.
+  test('has the correct arguments', () => {
+    const emitter = createEmitter<Events>()
+
+    type Source = Parameters<typeof emitter.next>
+    type Expected = [event: keyof Events, options?: EmitterNextOptions]
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+  })
+
+  test('has the correct return type', () => {
+    const emitter = createEmitter<Events>()
+
+    const ping = emitter.next('ping')
+    expectTypeOf<typeof ping>().toEqualTypeOf<Promise<void>>()
+
+    const hello = emitter.next('hello')
+    expectTypeOf<typeof hello>().toEqualTypeOf<Promise<string>>()
+
+    const user = emitter.next('user')
+    expectTypeOf<typeof user>().toEqualTypeOf<Promise<{ name: string }>>()
+
+    const global = emitter.next()
+    expectTypeOf<typeof global>().toEqualTypeOf<Promise<GlobalEventHandlerResponse<Events>>>()
+  })
+})
+
+describe('emitter.off', () => {
+
+  // note: The `Parameters` type only tests the last overload. So we cannot test the global handler parameters.
+  test('has the correct arguments', () => {
+    const emitter = createEmitter<Events>()
+
+    type Source = Parameters<typeof emitter.off>
+    type Expected = [event: keyof Events, handler: EventHandler<EventPayload<Events, keyof Events>>]
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+  })
+
+  test('has the correct return type', () => {
+    const emitter = createEmitter<Events>()
+    const eventResponse = emitter.off('hello')
+
+    type Source = typeof eventResponse
+    type Expected = void
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+
+    const eventHandlerResponse = emitter.off('hello', vi.fn())
+
+    type EventHandlerSource = typeof eventHandlerResponse
+    type EventHandlerExpected = void
+
+    expectTypeOf<EventHandlerSource>().toEqualTypeOf<EventHandlerExpected>()
+
+    const globalResponse = emitter.off(vi.fn())
+
+    type GlobalSource = typeof globalResponse
+    type GlobalExpected = void
+
+    expectTypeOf<GlobalSource>().toEqualTypeOf<GlobalExpected>()
+  })
+})
+
+describe('emitter.clear', () => {
+  test('has the correct arguments', () => {
+    const emitter = createEmitter<Events>()
+
+    type Source = Parameters<typeof emitter.clear>
+    type Expected = []
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+  })
+
+  test('has the correct return type', () => {
+    const emitter = createEmitter<Events>()
+    const response = emitter.clear()
+
+    type Source = typeof response
+    type Expected = void
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+  })
+})
+
+describe('emitter.emit', () => {
+  test('has the correct return type', () => {
+    const emitter = createEmitter<Events>()
+    const response = emitter.emit('ping')
+
+    type Source = typeof response
+    type Expected = void
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+  })
+})
+
+describe('emitter.setOptions', () => {
+  test('has the correct return type', () => {
+    const emitter = createEmitter<Events>()
+    const response = emitter.setOptions({})
+
+    type Source = typeof response
+    type Expected = void
+
+    expectTypeOf<Source>().toEqualTypeOf<Expected>()
+  })
+})
diff --git a/src/main.spec.ts b/tests/events.spec.ts
similarity index 99%
rename from src/main.spec.ts
rename to tests/events.spec.ts
index 87c6d14..bd80122 100644
--- a/src/main.spec.ts
+++ b/tests/events.spec.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test, vi } from 'vitest'
-import { createEmitter } from './main'
+import { createEmitter } from '../src/main'
 
 async function timeout(delay: number = 0): Promise<void> {
   return new Promise<void>(resolve => {
diff --git a/tsconfig.json b/tsconfig.json
index 75abdef..3231acb 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -19,5 +19,5 @@
     "noUnusedParameters": true,
     "noFallthroughCasesInSwitch": true
   },
-  "include": ["src"]
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
 }