diff --git a/packages/crypto/src/keys/index.ts b/packages/crypto/src/keys/index.ts
index 2051052858..5f08aa20c5 100644
--- a/packages/crypto/src/keys/index.ts
+++ b/packages/crypto/src/keys/index.ts
@@ -1,9 +1,7 @@
 /**
  * @packageDocumentation
  *
- * **Supported Key Types**
- *
- * The {@link generateKeyPair}, {@link marshalPublicKey}, and {@link marshalPrivateKey} functions accept a string `type` argument.
+ * ## Supported Key Types
  *
  * Currently the `'RSA'`, `'ed25519'`, and `secp256k1` types are supported, although ed25519 and secp256k1 keys support only signing and verification of messages.
  *
@@ -19,6 +17,8 @@ import type { PrivateKey, PublicKey, KeyType, RSAPrivateKey, Secp256k1PrivateKey
 import type { MultihashDigest } from 'multiformats'
 
 export { generateEphemeralKeyPair } from './ecdh/index.js'
+export type { Curve } from './ecdh/index.js'
+export type { ECDHKey, EnhancedKey, EnhancedKeyPair, ECDHKeyPair } from './interface.js'
 export { keyStretcher } from './key-stretcher.js'
 
 /**
diff --git a/packages/interface-compliance-tests/src/mocks/connection-manager.ts b/packages/interface-compliance-tests/src/mocks/connection-manager.ts
index 2b43fe11b8..6e820543e4 100644
--- a/packages/interface-compliance-tests/src/mocks/connection-manager.ts
+++ b/packages/interface-compliance-tests/src/mocks/connection-manager.ts
@@ -16,7 +16,7 @@ export interface MockNetworkComponents {
   logger: ComponentLogger
 }
 
-class MockNetwork {
+export class MockNetwork {
   private components: MockNetworkComponents[] = []
 
   addNode (components: MockNetworkComponents): void {
diff --git a/packages/interface-compliance-tests/src/mocks/index.ts b/packages/interface-compliance-tests/src/mocks/index.ts
index ae9277d131..1c94ae79da 100644
--- a/packages/interface-compliance-tests/src/mocks/index.ts
+++ b/packages/interface-compliance-tests/src/mocks/index.ts
@@ -8,4 +8,6 @@ export { mockUpgrader } from './upgrader.js'
 export { mockDuplex } from './duplex.js'
 export { mockMetrics } from './metrics.js'
 export type { MockUpgraderInit } from './upgrader.js'
-export type { MockNetworkComponents } from './connection-manager.js'
+export type { MockNetworkComponents, MockConnectionManagerComponents, MockNetwork } from './connection-manager.js'
+export type { MockConnectionOptions, StreamInit, StreamPairInit } from './connection.js'
+export type { MockMultiaddrConnPairOptions } from './multiaddr-connection.js'
diff --git a/packages/interface-compliance-tests/src/mocks/muxer.ts b/packages/interface-compliance-tests/src/mocks/muxer.ts
index e71bb6c9ae..96f2218faa 100644
--- a/packages/interface-compliance-tests/src/mocks/muxer.ts
+++ b/packages/interface-compliance-tests/src/mocks/muxer.ts
@@ -309,6 +309,6 @@ class MockMuxerFactory implements StreamMuxerFactory {
   }
 }
 
-export function mockMuxer (): MockMuxerFactory {
+export function mockMuxer (): StreamMuxerFactory {
   return new MockMuxerFactory()
 }
diff --git a/packages/interface-compliance-tests/typedoc.json b/packages/interface-compliance-tests/typedoc.json
index f4e39476fb..d1d95c755c 100644
--- a/packages/interface-compliance-tests/typedoc.json
+++ b/packages/interface-compliance-tests/typedoc.json
@@ -7,7 +7,6 @@
     "./src/matchers.ts",
     "./src/mocks/index.ts",
     "./src/peer-discovery/index.ts",
-    "./src/peers.ts",
     "./src/pubsub/index.ts",
     "./src/stream-muxer/index.ts",
     "./src/transport/index.ts"
diff --git a/packages/interface-internal/src/connection-manager/index.ts b/packages/interface-internal/src/connection-manager/index.ts
index 91069d0b2e..860c8c9f62 100644
--- a/packages/interface-internal/src/connection-manager/index.ts
+++ b/packages/interface-internal/src/connection-manager/index.ts
@@ -6,14 +6,18 @@ import type { ProgressOptions } from 'progress-events'
 export interface OpenConnectionOptions extends AbortOptions, ProgressOptions<OpenConnectionProgressEvents> {
   /**
    * Connection requests with a higher priority will be executed before those
-   * with a lower priority. (default: 50)
+   * with a lower priority.
+   *
+   * @default 50
    */
   priority?: number
 
   /**
    * When opening a connection to a remote peer, if a connection already exists
    * it will be returned instead of creating a new connection. Pass true here
-   * to override that and dial a new connection anyway. (default: false)
+   * to override that and dial a new connection anyway.
+   *
+   * @default false
    */
   force?: boolean
 }
diff --git a/packages/interface-internal/src/registrar/index.ts b/packages/interface-internal/src/registrar/index.ts
index edddb9daf3..d230cf3228 100644
--- a/packages/interface-internal/src/registrar/index.ts
+++ b/packages/interface-internal/src/registrar/index.ts
@@ -18,12 +18,16 @@ export interface StreamHandler {
 
 export interface StreamHandlerOptions {
   /**
-   * How many incoming streams can be open for this protocol at the same time on each connection (default: 32)
+   * How many incoming streams can be open for this protocol at the same time on each connection
+   *
+   * @default 32
    */
   maxInboundStreams?: number
 
   /**
-   * How many outgoing streams can be open for this protocol at the same time on each connection (default: 64)
+   * How many outgoing streams can be open for this protocol at the same time on each connection
+   *
+   * @default 64
    */
   maxOutboundStreams?: number
 
diff --git a/packages/interface/src/connection/index.ts b/packages/interface/src/connection/index.ts
index 46287959bc..696c74830d 100644
--- a/packages/interface/src/connection/index.ts
+++ b/packages/interface/src/connection/index.ts
@@ -126,7 +126,7 @@ export interface Stream extends Duplex<AsyncGenerator<Uint8ArrayList>, Source<Ui
    *
    * This will cause a `RESET` message to be sent to the remote, *unless* the sink has already ended.
    *
-   * The sink will return and the source will throw if an error is passed or return normally if not.
+   * The sink will return and the source will throw.
    */
   abort(err: Error): void
 
diff --git a/packages/interface/src/events.browser.ts b/packages/interface/src/events.browser.ts
index 7c1fabd36c..90480a73f6 100644
--- a/packages/interface/src/events.browser.ts
+++ b/packages/interface/src/events.browser.ts
@@ -1,2 +1,4 @@
-/** Noop for browser compatibility */
+/**
+ * Noop for browser compatibility
+ */
 export function setMaxListeners (): void {}
diff --git a/packages/interface/src/events.ts b/packages/interface/src/events.ts
index 1e0da6452c..9c9e661313 100644
--- a/packages/interface/src/events.ts
+++ b/packages/interface/src/events.ts
@@ -1,6 +1,8 @@
 import { setMaxListeners as nodeSetMaxListeners } from 'events'
 
-// create a setMaxListeners that doesn't break browser usage
+/**
+ * Create a setMaxListeners that doesn't break browser usage
+ */
 export const setMaxListeners: typeof nodeSetMaxListeners = (n, ...eventTargets) => {
   try {
     nodeSetMaxListeners(n, ...eventTargets)
diff --git a/packages/interface/src/keys/index.ts b/packages/interface/src/keys/index.ts
index b0d95ab498..7980c5231e 100644
--- a/packages/interface/src/keys/index.ts
+++ b/packages/interface/src/keys/index.ts
@@ -4,15 +4,14 @@ import type { Uint8ArrayList } from 'uint8arraylist'
 
 export type KeyType = 'RSA' | 'Ed25519' | 'secp256k1'
 
-interface PublicKeyBase<KeyType extends string, DigestCode extends number = number> {
+export interface RSAPublicKey {
   /**
    * The type of this key
    */
-  readonly type: KeyType
+  readonly type: 'RSA'
 
   /**
-   * The raw public key bytes (for Ed25519 and secp256k1 keys) or PKIX in ASN1
-   * DER format (for RSA keys)
+   * PKIX in ASN1 DER format
    */
   readonly raw: Uint8Array
 
@@ -24,20 +23,101 @@ interface PublicKeyBase<KeyType extends string, DigestCode extends number = numb
   /**
    * Returns this public key as a Multihash digest.
    *
-   * It contains either an identity hash containing the protobuf version of the
-   * public key (for Ed25519 and secp256k1 keys) or a sha256 hash of the
-   * protobuf version of the public key (RSA keys).
+   * It contains a sha256 hash of the protobuf version of the public key.
    */
-  toMultihash(): MultihashDigest<DigestCode>
+  toMultihash(): MultihashDigest<0x12>
 
   /**
    * Return this public key as a CID encoded with the `libp2p-key` codec
    *
-   * The digest contains either an identity hash containing the protobuf version
-   * of the public key (for Ed25519 and secp256k1 keys) or a sha256 hash of the
-   * protobuf version of the public key (RSA keys).
+   * The digest contains a sha256 hash of the protobuf version of the public
+   * key.
    */
-  toCID(): CID<unknown, 0x72, DigestCode, 1>
+  toCID(): CID<unknown, 0x72, 0x12, 1>
+
+  /**
+   * Verify the passed data was signed by the private key corresponding to this
+   * public key
+   */
+  verify(data: Uint8Array | Uint8ArrayList, sig: Uint8Array): boolean | Promise<boolean>
+
+  /**
+   * Returns this key as a multihash with base58btc encoding
+   */
+  toString(): string
+}
+
+export interface Ed25519PublicKey {
+  /**
+   * The type of this key
+   */
+  readonly type: 'Ed25519'
+
+  /**
+   * The raw public key bytes
+   */
+  readonly raw: Uint8Array
+
+  /**
+   * Returns `true` if the passed object matches this key
+   */
+  equals(key?: any): boolean
+
+  /**
+   * Returns this public key as an identity hash containing the protobuf wrapped
+   * public key
+   */
+  toMultihash(): MultihashDigest<0x0>
+
+  /**
+   * Return this public key as a CID encoded with the `libp2p-key` codec
+   *
+   * The digest contains an identity hash containing the protobuf wrapped
+   * version of the public key.
+   */
+  toCID(): CID<unknown, 0x72, 0x0, 1>
+
+  /**
+   * Verify the passed data was signed by the private key corresponding to this
+   * public key
+   */
+  verify(data: Uint8Array | Uint8ArrayList, sig: Uint8Array): boolean | Promise<boolean>
+
+  /**
+   * Returns this key as a multihash with base58btc encoding
+   */
+  toString(): string
+}
+
+export interface Secp256k1PublicKey {
+  /**
+   * The type of this key
+   */
+  readonly type: 'secp256k1'
+
+  /**
+   * The raw public key bytes
+   */
+  readonly raw: Uint8Array
+
+  /**
+   * Returns `true` if the passed object matches this key
+   */
+  equals(key?: any): boolean
+
+  /**
+   * Returns this public key as an identity hash containing the protobuf wrapped
+   * public key
+   */
+  toMultihash(): MultihashDigest<0x0>
+
+  /**
+   * Return this public key as a CID encoded with the `libp2p-key` codec
+   *
+   * The digest contains an identity hash containing the protobuf wrapped
+   * version of the public key.
+   */
+  toCID(): CID<unknown, 0x72, 0x0, 1>
 
   /**
    * Verify the passed data was signed by the private key corresponding to this
@@ -51,9 +131,6 @@ interface PublicKeyBase<KeyType extends string, DigestCode extends number = numb
   toString(): string
 }
 
-export interface RSAPublicKey extends PublicKeyBase<'RSA', 0x12> {}
-export interface Ed25519PublicKey extends PublicKeyBase<'Ed25519', 0x0> {}
-export interface Secp256k1PublicKey extends PublicKeyBase<'secp256k1', 0x0> {}
 export type PublicKey = RSAPublicKey | Ed25519PublicKey | Secp256k1PublicKey
 
 /**
@@ -76,20 +153,75 @@ export function isPublicKey (key?: any): key is PublicKey {
 /**
  * Generic private key interface
  */
-interface PrivateKeyBase<KeyType extends string, PublicKeyType extends PublicKeyBase<KeyType>> {
+export interface RSAPrivateKey {
+  /**
+   * The type of this key
+   */
+  readonly type: 'RSA'
+
+  /**
+   * The public key that corresponds to this private key
+   */
+  readonly publicKey: RSAPublicKey
+
+  /**
+   * PKIX in ASN1 DER format
+   */
+  readonly raw: Uint8Array
+
+  /**
+   * Returns `true` if the passed object matches this key
+   */
+  equals(key?: any): boolean
+
+  /**
+   * Sign the passed data with this private key and return the signature for
+   * later verification
+   */
+  sign(data: Uint8Array | Uint8ArrayList): Uint8Array | Promise<Uint8Array>
+}
+
+export interface Ed25519PrivateKey {
+  /**
+   * The type of this key
+   */
+  readonly type: 'Ed25519'
+
+  /**
+   * The public key that corresponds to this private key
+   */
+  readonly publicKey: Ed25519PublicKey
+
+  /**
+   * The raw public key bytes
+   */
+  readonly raw: Uint8Array
+
+  /**
+   * Returns `true` if the passed object matches this key
+   */
+  equals(key?: any): boolean
+
+  /**
+   * Sign the passed data with this private key and return the signature for
+   * later verification
+   */
+  sign(data: Uint8Array | Uint8ArrayList): Uint8Array | Promise<Uint8Array>
+}
+
+export interface Secp256k1PrivateKey {
   /**
    * The type of this key
    */
-  readonly type: KeyType
+  readonly type: 'secp256k1'
 
   /**
    * The public key that corresponds to this private key
    */
-  readonly publicKey: PublicKeyType
+  readonly publicKey: Secp256k1PublicKey
 
   /**
-   * The raw public key bytes (for Ed25519 and secp256k1 keys) or PKIX in ASN1
-   * DER format (for RSA keys)
+   * The raw public key bytes
    */
   readonly raw: Uint8Array
 
@@ -105,9 +237,6 @@ interface PrivateKeyBase<KeyType extends string, PublicKeyType extends PublicKey
   sign(data: Uint8Array | Uint8ArrayList): Uint8Array | Promise<Uint8Array>
 }
 
-export interface RSAPrivateKey extends PrivateKeyBase<'RSA', RSAPublicKey> {}
-export interface Ed25519PrivateKey extends PrivateKeyBase<'Ed25519', Ed25519PublicKey> {}
-export interface Secp256k1PrivateKey extends PrivateKeyBase<'secp256k1', Secp256k1PublicKey> {}
 export type PrivateKey = RSAPrivateKey | Ed25519PrivateKey | Secp256k1PrivateKey
 
 /**
diff --git a/packages/interface/src/pubsub/index.ts b/packages/interface/src/pubsub/index.ts
index a53d6c1500..49c2744a18 100644
--- a/packages/interface/src/pubsub/index.ts
+++ b/packages/interface/src/pubsub/index.ts
@@ -115,7 +115,7 @@ export interface PubSubInit {
   maxOutboundStreams?: number
 }
 
-interface Subscription {
+export interface Subscription {
   topic: string
   subscribe: boolean
 }
diff --git a/packages/interface/src/stream-handler/index.ts b/packages/interface/src/stream-handler/index.ts
index df409d5973..761c8ddd7a 100644
--- a/packages/interface/src/stream-handler/index.ts
+++ b/packages/interface/src/stream-handler/index.ts
@@ -11,12 +11,16 @@ export interface StreamHandler {
 
 export interface StreamHandlerOptions {
   /**
-   * How many incoming streams can be open for this protocol at the same time on each connection (default: 32)
+   * How many incoming streams can be open for this protocol at the same time on each connection
+   *
+   * @default 32
    */
   maxInboundStreams?: number
 
   /**
-   * How many outgoing streams can be open for this protocol at the same time on each connection (default: 64)
+   * How many outgoing streams can be open for this protocol at the same time on each connection
+   *
+   * @default 64
    */
   maxOutboundStreams?: number
 
diff --git a/packages/kad-dht/src/index.ts b/packages/kad-dht/src/index.ts
index b80a4aca5f..8acfb9056f 100644
--- a/packages/kad-dht/src/index.ts
+++ b/packages/kad-dht/src/index.ts
@@ -299,6 +299,8 @@ export type Selectors = Record<string, SelectFn>
  */
 export type Validators = Record<string, ValidateFn>
 
+export type { ProvidersInit }
+
 export interface KadDHTInit {
   /**
    * How many peers to store in each kBucket. Once there are more than this
diff --git a/packages/kad-dht/test/routing-table.spec.ts b/packages/kad-dht/test/routing-table.spec.ts
index 51bf54d41d..aa82a1b567 100644
--- a/packages/kad-dht/test/routing-table.spec.ts
+++ b/packages/kad-dht/test/routing-table.spec.ts
@@ -6,7 +6,7 @@ import { mockConnectionManager } from '@libp2p/interface-compliance-tests/mocks'
 import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString, peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { expect } from 'aegir/chai'
 import { MemoryDatastore } from 'datastore-core'
 import all from 'it-all'
@@ -47,7 +47,7 @@ describe('Routing Table', () => {
       registrar: stubInterface<Registrar>(),
       events
     })
-    components.peerStore = new PersistentPeerStore({
+    components.peerStore = persistentPeerStore({
       ...components,
       datastore: new MemoryDatastore(),
       events
diff --git a/packages/kad-dht/test/rpc/handlers/get-providers.spec.ts b/packages/kad-dht/test/rpc/handlers/get-providers.spec.ts
index 14c48b10da..4133018c6b 100644
--- a/packages/kad-dht/test/rpc/handlers/get-providers.spec.ts
+++ b/packages/kad-dht/test/rpc/handlers/get-providers.spec.ts
@@ -3,7 +3,7 @@
 import { TypedEventEmitter } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { peerIdFromMultihash } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { multiaddr } from '@multiformats/multiaddr'
 import { expect } from 'aegir/chai'
 import { MemoryDatastore } from 'datastore-core'
@@ -41,7 +41,7 @@ describe('rpc - handlers - GetProviders', () => {
 
     peerRouting = Sinon.createStubInstance(PeerRouting)
     providers = Sinon.createStubInstance(Providers)
-    peerStore = new PersistentPeerStore({
+    peerStore = persistentPeerStore({
       peerId,
       datastore: new MemoryDatastore(),
       events: new TypedEventEmitter<Libp2pEvents>(),
diff --git a/packages/kad-dht/test/rpc/handlers/get-value.spec.ts b/packages/kad-dht/test/rpc/handlers/get-value.spec.ts
index 36c9129b00..a8aef528a2 100644
--- a/packages/kad-dht/test/rpc/handlers/get-value.spec.ts
+++ b/packages/kad-dht/test/rpc/handlers/get-value.spec.ts
@@ -3,7 +3,7 @@
 import { publicKeyToProtobuf } from '@libp2p/crypto/keys'
 import { TypedEventEmitter } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { Libp2pRecord } from '@libp2p/record'
 import { expect } from 'aegir/chai'
 import { MemoryDatastore } from 'datastore-core'
@@ -37,7 +37,7 @@ describe('rpc - handlers - GetValue', () => {
     targetPeer = await createPeerId()
     peerRouting = Sinon.createStubInstance(PeerRouting)
     datastore = new MemoryDatastore()
-    peerStore = new PersistentPeerStore({
+    peerStore = persistentPeerStore({
       peerId,
       datastore,
       events: new TypedEventEmitter<Libp2pEvents>(),
diff --git a/packages/kad-dht/test/rpc/index.node.ts b/packages/kad-dht/test/rpc/index.node.ts
index c4886d22dc..1fb1c98eea 100644
--- a/packages/kad-dht/test/rpc/index.node.ts
+++ b/packages/kad-dht/test/rpc/index.node.ts
@@ -3,7 +3,7 @@
 import { TypedEventEmitter, start } from '@libp2p/interface'
 import { mockStream } from '@libp2p/interface-compliance-tests/mocks'
 import { defaultLogger } from '@libp2p/logger'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { expect } from 'aegir/chai'
 import { MemoryDatastore } from 'datastore-core'
 import all from 'it-all'
@@ -48,7 +48,7 @@ describe('rpc', () => {
       addressManager: stubInterface<AddressManager>(),
       logger: defaultLogger()
     }
-    components.peerStore = new PersistentPeerStore({
+    components.peerStore = persistentPeerStore({
       ...components,
       events: new TypedEventEmitter<Libp2pEvents>()
     })
diff --git a/packages/kad-dht/test/utils/test-dht.ts b/packages/kad-dht/test/utils/test-dht.ts
index ba30519fdc..dff13bd89f 100644
--- a/packages/kad-dht/test/utils/test-dht.ts
+++ b/packages/kad-dht/test/utils/test-dht.ts
@@ -3,7 +3,7 @@ import { TypedEventEmitter, start, stop } from '@libp2p/interface'
 import { mockRegistrar, mockConnectionManager, mockNetwork } from '@libp2p/interface-compliance-tests/mocks'
 import { defaultLogger } from '@libp2p/logger'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { multiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
 import delay from 'delay'
@@ -44,7 +44,7 @@ export class TestDHT {
       ...components,
       events
     })
-    components.peerStore = new PersistentPeerStore({
+    components.peerStore = persistentPeerStore({
       ...components,
       events
     })
diff --git a/packages/libp2p/src/connection-manager/index.ts b/packages/libp2p/src/connection-manager/index.ts
index 5b2e59e778..ced6d27d28 100644
--- a/packages/libp2p/src/connection-manager/index.ts
+++ b/packages/libp2p/src/connection-manager/index.ts
@@ -88,7 +88,9 @@ export interface ConnectionManagerInit {
 
   /**
    * If more than this many connections are opened per second by a single
-   * host, reject subsequent connections. (default: 5)
+   * host, reject subsequent connections.
+   *
+   * @default 5
    */
   inboundConnectionThreshold?: number
 
diff --git a/packages/libp2p/src/index.ts b/packages/libp2p/src/index.ts
index f38218329d..fc68bc0bdf 100644
--- a/packages/libp2p/src/index.ts
+++ b/packages/libp2p/src/index.ts
@@ -18,7 +18,7 @@ import { generateKeyPair } from '@libp2p/crypto/keys'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
 import { validateConfig } from './config.js'
 import { Libp2p as Libp2pClass } from './libp2p.js'
-import type { AddressManagerInit } from './address-manager/index.js'
+import type { AddressManagerInit, AddressFilter } from './address-manager/index.js'
 import type { Components } from './components.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { ConnectionMonitorInit } from './connection-monitor.js'
@@ -32,6 +32,8 @@ export type ServiceFactoryMap<T extends ServiceMap = ServiceMap> = {
   [Property in keyof T]: (components: Components & T) => T[Property]
 }
 
+export type { AddressManagerInit, AddressFilter }
+
 /**
  * For Libp2p configurations and modules details read the [Configuration Document](https://github.com/libp2p/js-libp2p/tree/main/doc/CONFIGURATION.md).
  */
@@ -164,7 +166,7 @@ export interface Libp2pInit<T extends ServiceMap = ServiceMap> {
   dns?: DNS
 }
 
-export type { Libp2p }
+export type { Libp2p, ConnectionManagerInit, ConnectionMonitorInit, TransportManagerInit }
 
 export type Libp2pOptions<T extends ServiceMap = ServiceMap> = Libp2pInit<T> & { start?: boolean }
 
diff --git a/packages/libp2p/src/libp2p.ts b/packages/libp2p/src/libp2p.ts
index 40a59079d5..16221de1c3 100644
--- a/packages/libp2p/src/libp2p.ts
+++ b/packages/libp2p/src/libp2p.ts
@@ -3,7 +3,7 @@ import { contentRoutingSymbol, TypedEventEmitter, setMaxListeners, peerDiscovery
 import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
@@ -79,7 +79,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
       dns: init.dns
     })
 
-    this.peerStore = this.configureComponent('peerStore', new PersistentPeerStore(components, {
+    this.peerStore = this.configureComponent('peerStore', persistentPeerStore(components, {
       addressFilter: this.components.connectionGater.filterMultiaddrForPeer,
       ...init.peerStore
     }))
diff --git a/packages/libp2p/test/connection-manager/direct.node.ts b/packages/libp2p/test/connection-manager/direct.node.ts
index 0ae47aad27..d12639eb3e 100644
--- a/packages/libp2p/test/connection-manager/direct.node.ts
+++ b/packages/libp2p/test/connection-manager/direct.node.ts
@@ -10,7 +10,7 @@ import { mockConnection, mockConnectionGater, mockDuplex, mockMultiaddrConnectio
 import { defaultLogger } from '@libp2p/logger'
 import { mplex } from '@libp2p/mplex'
 import { peerIdFromString, peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { plaintext } from '@libp2p/plaintext'
 import { tcp } from '@libp2p/tcp'
 import { multiaddr } from '@multiformats/multiaddr'
@@ -65,7 +65,7 @@ describe('dialing (direct, TCP)', () => {
         getAddrs: Sinon.stub().returns([])
       })
     })
-    remoteComponents.peerStore = new PersistentPeerStore(remoteComponents)
+    remoteComponents.peerStore = persistentPeerStore(remoteComponents)
     remoteComponents.addressManager = new DefaultAddressManager(remoteComponents, {
       listen: [
         listenAddr.toString()
@@ -86,7 +86,7 @@ describe('dialing (direct, TCP)', () => {
       transportManager: stubInterface<TransportManager>(),
       connectionGater: mockConnectionGater()
     })
-    localComponents.peerStore = new PersistentPeerStore(localComponents)
+    localComponents.peerStore = persistentPeerStore(localComponents)
     localComponents.connectionManager = new DefaultConnectionManager(localComponents, {
       maxConnections: 100,
       inboundUpgradeTimeout: 1000
diff --git a/packages/libp2p/test/connection-manager/direct.spec.ts b/packages/libp2p/test/connection-manager/direct.spec.ts
index c1d6af041d..7bd3958bd1 100644
--- a/packages/libp2p/test/connection-manager/direct.spec.ts
+++ b/packages/libp2p/test/connection-manager/direct.spec.ts
@@ -8,7 +8,7 @@ import { mockConnectionGater, mockDuplex, mockMultiaddrConnection, mockUpgrader,
 import { defaultLogger } from '@libp2p/logger'
 import { mplex } from '@libp2p/mplex'
 import { peerIdFromString, peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { plaintext } from '@libp2p/plaintext'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { webSockets } from '@libp2p/websockets'
@@ -50,7 +50,7 @@ describe('dialing (direct, WebSockets)', () => {
       transportManager: stubInterface<TransportManager>(),
       events: localEvents
     })
-    localComponents.peerStore = new PersistentPeerStore(localComponents, {
+    localComponents.peerStore = persistentPeerStore(localComponents, {
       addressFilter: localComponents.connectionGater.filterMultiaddrForPeer
     })
     localComponents.connectionManager = new DefaultConnectionManager(localComponents, {
diff --git a/packages/libp2p/test/fixtures/creators/peer.ts b/packages/libp2p/test/fixtures/creators/peer.ts
index aef41f5083..1c006ed483 100644
--- a/packages/libp2p/test/fixtures/creators/peer.ts
+++ b/packages/libp2p/test/fixtures/creators/peer.ts
@@ -9,12 +9,16 @@ const listenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
 
 export interface CreatePeerOptions <T extends ServiceMap> {
   /**
-   * number of peers (default: 1)
+   * number of peers
+   *
+   * @default 1
    */
   number?: number
 
   /**
-   * nodes should start (default: true)
+   * nodes should start
+   *
+   * @default true
    */
   started?: boolean
 
diff --git a/packages/libp2p/test/registrar/errors.spec.ts b/packages/libp2p/test/registrar/errors.spec.ts
index 8b1fb325ae..3ad554331d 100644
--- a/packages/libp2p/test/registrar/errors.spec.ts
+++ b/packages/libp2p/test/registrar/errors.spec.ts
@@ -4,7 +4,7 @@ import { generateKeyPair } from '@libp2p/crypto/keys'
 import { TypedEventEmitter, type ConnectionGater, type PeerId } from '@libp2p/interface'
 import { mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { expect } from 'aegir/chai'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { stubInterface } from 'sinon-ts'
@@ -30,7 +30,7 @@ describe('registrar errors', () => {
       transportManager: stubInterface<TransportManager>(),
       connectionGater: stubInterface<ConnectionGater>()
     })
-    components.peerStore = new PersistentPeerStore(components)
+    components.peerStore = persistentPeerStore(components)
     components.connectionManager = new DefaultConnectionManager(components, {
       maxConnections: 1000,
       inboundUpgradeTimeout: 1000
diff --git a/packages/libp2p/test/transports/transport-manager.node.ts b/packages/libp2p/test/transports/transport-manager.node.ts
index cb1b151da5..7b93d1fd5d 100644
--- a/packages/libp2p/test/transports/transport-manager.node.ts
+++ b/packages/libp2p/test/transports/transport-manager.node.ts
@@ -5,7 +5,7 @@ import { TypedEventEmitter, start, stop, FaultTolerance } from '@libp2p/interfac
 import { mockUpgrader } from '@libp2p/interface-compliance-tests/mocks'
 import { defaultLogger } from '@libp2p/logger'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { tcp } from '@libp2p/tcp'
 import { multiaddr } from '@multiformats/multiaddr'
 import { expect } from 'aegir/chai'
@@ -41,7 +41,7 @@ describe('Transport Manager (TCP)', () => {
       upgrader: mockUpgrader({ events })
     })
     components.addressManager = new DefaultAddressManager(components, { listen: addrs.map(addr => addr.toString()) })
-    components.peerStore = new PersistentPeerStore(components)
+    components.peerStore = persistentPeerStore(components)
 
     tm = new DefaultTransportManager(components, {
       faultTolerance: FaultTolerance.NO_FATAL
diff --git a/packages/libp2p/test/upgrading/upgrader.spec.ts b/packages/libp2p/test/upgrading/upgrader.spec.ts
index 7603f82d24..4e7a75c502 100644
--- a/packages/libp2p/test/upgrading/upgrader.spec.ts
+++ b/packages/libp2p/test/upgrading/upgrader.spec.ts
@@ -8,7 +8,7 @@ import { TypedEventEmitter } from '@libp2p/interface'
 import { mockConnectionGater, mockConnectionManager, mockMultiaddrConnPair, mockRegistrar, mockStream, mockMuxer } from '@libp2p/interface-compliance-tests/mocks'
 import { mplex } from '@libp2p/mplex'
 import { peerIdFromCID, peerIdFromPrivateKey } from '@libp2p/peer-id'
-import { PersistentPeerStore } from '@libp2p/peer-store'
+import { persistentPeerStore } from '@libp2p/peer-store'
 import { plaintext } from '@libp2p/plaintext'
 import { webSockets } from '@libp2p/websockets'
 import * as filters from '@libp2p/websockets/filters'
@@ -71,7 +71,7 @@ describe('Upgrader', () => {
       connectionProtector: localConnectionProtector,
       events: new TypedEventEmitter()
     })
-    localComponents.peerStore = new PersistentPeerStore(localComponents)
+    localComponents.peerStore = persistentPeerStore(localComponents)
     localComponents.connectionManager = mockConnectionManager(localComponents)
     localMuxerFactory = mplex()(localComponents)
     localYamuxerFactory = yamux()(localComponents)
@@ -99,7 +99,7 @@ describe('Upgrader', () => {
       connectionProtector: remoteConnectionProtector,
       events: new TypedEventEmitter()
     })
-    remoteComponents.peerStore = new PersistentPeerStore(remoteComponents)
+    remoteComponents.peerStore = persistentPeerStore(remoteComponents)
     remoteComponents.connectionManager = mockConnectionManager(remoteComponents)
     remoteMuxerFactory = mplex()(remoteComponents)
     remoteYamuxerFactory = yamux()(remoteComponents)
diff --git a/packages/multistream-select/src/index.ts b/packages/multistream-select/src/index.ts
index 41d72b09ef..a4ffa25cc1 100644
--- a/packages/multistream-select/src/index.ts
+++ b/packages/multistream-select/src/index.ts
@@ -43,4 +43,5 @@ export interface MultistreamSelectInit extends AbortOptions, LoggerOptions, Part
 }
 
 export { select } from './select.js'
+export type { SelectStream } from './select.js'
 export { handle } from './handle.js'
diff --git a/packages/peer-collections/src/index.ts b/packages/peer-collections/src/index.ts
index 006f011892..c5bdbf4ae4 100644
--- a/packages/peer-collections/src/index.ts
+++ b/packages/peer-collections/src/index.ts
@@ -113,5 +113,8 @@ export { PeerList, peerList } from './list.js'
 export { PeerFilter, peerFilter } from './filter.js'
 
 export { trackedPeerMap } from './tracked-map.js'
+export type { TrackedPeerMapInit } from './tracked-map.js'
 export { trackedPeerSet } from './tracked-set.js'
+export type { TrackedPeerSetInit } from './tracked-set.js'
 export { trackedPeerList } from './tracked-list.js'
+export type { TrackedPeerListInit } from './tracked-list.js'
diff --git a/packages/peer-collections/src/tracked-list.ts b/packages/peer-collections/src/tracked-list.ts
index 73ba96e49c..05ad86be5e 100644
--- a/packages/peer-collections/src/tracked-list.ts
+++ b/packages/peer-collections/src/tracked-list.ts
@@ -3,13 +3,13 @@ import type { Metric, Metrics, PeerId } from '@libp2p/interface'
 
 export interface TrackedPeerListInit {
   name: string
-  metrics: Metrics
+  metrics?: Metrics
 }
 
 class TrackedPeerList extends PeerList {
   private readonly metric: Metric
 
-  constructor (init: TrackedPeerListInit) {
+  constructor (init: Required<TrackedPeerListInit>) {
     super()
 
     const { name, metrics } = init
@@ -51,18 +51,6 @@ class TrackedPeerList extends PeerList {
   }
 }
 
-export interface CreateTrackedPeerListInit {
-  /**
-   * The metric name to use
-   */
-  name: string
-
-  /**
-   * A metrics implementation
-   */
-  metrics?: Metrics
-}
-
 /**
  * Creates a PeerList that reports it's size to the libp2p Metrics service
  *
@@ -78,7 +66,7 @@ export interface CreateTrackedPeerListInit {
  * list.push(peerId)
  * ```
  */
-export function trackedPeerList (config: CreateTrackedPeerListInit): PeerList {
+export function trackedPeerList (config: TrackedPeerListInit): PeerList {
   const { name, metrics } = config
   let map: PeerList
 
diff --git a/packages/peer-collections/src/tracked-map.ts b/packages/peer-collections/src/tracked-map.ts
index 5c3836c04a..81a8e7467d 100644
--- a/packages/peer-collections/src/tracked-map.ts
+++ b/packages/peer-collections/src/tracked-map.ts
@@ -3,13 +3,13 @@ import type { Metric, Metrics, PeerId } from '@libp2p/interface'
 
 export interface TrackedPeerMapInit {
   name: string
-  metrics: Metrics
+  metrics?: Metrics
 }
 
 class TrackedPeerMap<V> extends PeerMap<V> {
   private readonly metric: Metric
 
-  constructor (init: TrackedPeerMapInit) {
+  constructor (init: Required<TrackedPeerMapInit>) {
     super()
 
     const { name, metrics } = init
@@ -40,18 +40,6 @@ class TrackedPeerMap<V> extends PeerMap<V> {
   }
 }
 
-export interface CreateTrackedPeerMapInit {
-  /**
-   * The metric name to use
-   */
-  name: string
-
-  /**
-   * A metrics implementation
-   */
-  metrics?: Metrics
-}
-
 /**
  * Creates a PeerMap that reports it's size to the libp2p Metrics service
  *
@@ -67,7 +55,7 @@ export interface CreateTrackedPeerMapInit {
  * map.set(peerId, 'value')
  * ```
  */
-export function trackedPeerMap <V> (config: CreateTrackedPeerMapInit): PeerMap<V> {
+export function trackedPeerMap <V> (config: TrackedPeerMapInit): PeerMap<V> {
   const { name, metrics } = config
   let map: PeerMap<V>
 
diff --git a/packages/peer-collections/src/tracked-set.ts b/packages/peer-collections/src/tracked-set.ts
index 26ccb6e275..381022af84 100644
--- a/packages/peer-collections/src/tracked-set.ts
+++ b/packages/peer-collections/src/tracked-set.ts
@@ -3,13 +3,13 @@ import type { Metric, Metrics, PeerId } from '@libp2p/interface'
 
 export interface TrackedPeerSetInit {
   name: string
-  metrics: Metrics
+  metrics?: Metrics
 }
 
 class TrackedPeerSet extends PeerSet {
   private readonly metric: Metric
 
-  constructor (init: TrackedPeerSetInit) {
+  constructor (init: Required<TrackedPeerSetInit>) {
     super()
 
     const { name, metrics } = init
@@ -38,18 +38,6 @@ class TrackedPeerSet extends PeerSet {
   }
 }
 
-export interface CreateTrackedPeerSetInit {
-  /**
-   * The metric name to use
-   */
-  name: string
-
-  /**
-   * A metrics implementation
-   */
-  metrics?: Metrics
-}
-
 /**
  * Creates a PeerSet that reports it's size to the libp2p Metrics service
  *
@@ -65,7 +53,7 @@ export interface CreateTrackedPeerSetInit {
  * map.add(peerId)
  * ```
  */
-export function trackedPeerSet (config: CreateTrackedPeerSetInit): PeerSet {
+export function trackedPeerSet (config: TrackedPeerSetInit): PeerSet {
   const { name, metrics } = config
   let map: PeerSet
 
diff --git a/packages/peer-discovery-bootstrap/src/index.ts b/packages/peer-discovery-bootstrap/src/index.ts
index 140a2078cd..f7527c24c0 100644
--- a/packages/peer-discovery-bootstrap/src/index.ts
+++ b/packages/peer-discovery-bootstrap/src/index.ts
@@ -62,7 +62,9 @@ export interface BootstrapInit {
   tagName?: string
 
   /**
-   * The bootstrap peer tag will have this value (default: 50)
+   * The bootstrap peer tag will have this value
+   *
+   * @default 50
    */
   tagValue?: number
 
diff --git a/packages/peer-discovery-mdns/src/index.ts b/packages/peer-discovery-mdns/src/index.ts
index 4f741d814c..aeacaa5f71 100644
--- a/packages/peer-discovery-mdns/src/index.ts
+++ b/packages/peer-discovery-mdns/src/index.ts
@@ -80,6 +80,8 @@ import { MulticastDNS } from './mdns.js'
 import type { MulticastDNSInit, MulticastDNSComponents } from './mdns.js'
 import type { PeerDiscovery } from '@libp2p/interface'
 
+export type { MulticastDNSInit, MulticastDNSComponents }
+
 export function mdns (init: MulticastDNSInit = {}): (components: MulticastDNSComponents) => PeerDiscovery {
   return (components: MulticastDNSComponents) => new MulticastDNS(components, init)
 }
diff --git a/packages/peer-store/src/index.ts b/packages/peer-store/src/index.ts
index 3b24c57b5f..7fdbeb7d6f 100644
--- a/packages/peer-store/src/index.ts
+++ b/packages/peer-store/src/index.ts
@@ -33,7 +33,7 @@ export interface PersistentPeerStoreInit {
 /**
  * An implementation of PeerStore that stores data in a Datastore
  */
-export class PersistentPeerStore implements PeerStore {
+class PersistentPeerStore implements PeerStore {
   private readonly store: PersistentStore
   private readonly events: TypedEventTarget<Libp2pEvents>
   private readonly peerId: PeerId
@@ -220,3 +220,7 @@ export class PersistentPeerStore implements PeerStore {
     }
   }
 }
+
+export function persistentPeerStore (components: PersistentPeerStoreComponents, init: PersistentPeerStoreInit = {}): PeerStore {
+  return new PersistentPeerStore(components, init)
+}
diff --git a/packages/peer-store/test/index.spec.ts b/packages/peer-store/test/index.spec.ts
index 48f9a5a73d..4d507e8a6c 100644
--- a/packages/peer-store/test/index.spec.ts
+++ b/packages/peer-store/test/index.spec.ts
@@ -2,7 +2,7 @@
 /* eslint max-nested-callbacks: ["error", 6] */
 
 import { generateKeyPair } from '@libp2p/crypto/keys'
-import { TypedEventEmitter, type TypedEventTarget, type Libp2pEvents, type PeerId, type PrivateKey } from '@libp2p/interface'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
@@ -10,7 +10,8 @@ import { multiaddr } from '@multiformats/multiaddr'
 import { expect } from 'aegir/chai'
 import { MemoryDatastore } from 'datastore-core/memory'
 import delay from 'delay'
-import { PersistentPeerStore } from '../src/index.js'
+import { persistentPeerStore } from '../src/index.js'
+import type { TypedEventTarget, Libp2pEvents, PeerId, PrivateKey, PeerStore } from '@libp2p/interface'
 
 const addr1 = multiaddr('/ip4/127.0.0.1/tcp/8000')
 
@@ -18,7 +19,7 @@ describe('PersistentPeerStore', () => {
   let key: PrivateKey
   let peerId: PeerId
   let otherPeerId: PeerId
-  let peerStore: PersistentPeerStore
+  let peerStore: PeerStore
   let events: TypedEventTarget<Libp2pEvents>
 
   beforeEach(async () => {
@@ -26,7 +27,7 @@ describe('PersistentPeerStore', () => {
     peerId = peerIdFromPrivateKey(key)
     otherPeerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
     events = new TypedEventEmitter()
-    peerStore = new PersistentPeerStore({
+    peerStore = persistentPeerStore({
       peerId,
       events,
       datastore: new MemoryDatastore(),
diff --git a/packages/peer-store/test/merge.spec.ts b/packages/peer-store/test/merge.spec.ts
index e6fece898b..33cea797b3 100644
--- a/packages/peer-store/test/merge.spec.ts
+++ b/packages/peer-store/test/merge.spec.ts
@@ -2,14 +2,15 @@
 /* eslint max-nested-callbacks: ["error", 6] */
 
 import { generateKeyPair } from '@libp2p/crypto/keys'
-import { TypedEventEmitter, type TypedEventTarget, type Libp2pEvents, type PeerId, type PeerData } from '@libp2p/interface'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import { expect } from 'aegir/chai'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { pEvent } from 'p-event'
-import { PersistentPeerStore } from '../src/index.js'
+import { persistentPeerStore } from '../src/index.js'
+import type { TypedEventTarget, Libp2pEvents, PeerId, PeerStore, PeerData } from '@libp2p/interface'
 
 const addr1 = multiaddr('/ip4/127.0.0.1/tcp/8000')
 const addr2 = multiaddr('/ip4/20.0.0.1/tcp/8001')
@@ -18,14 +19,14 @@ const addr3 = multiaddr('/ip4/127.0.0.1/tcp/8002')
 describe('merge', () => {
   let peerId: PeerId
   let otherPeerId: PeerId
-  let peerStore: PersistentPeerStore
+  let peerStore: PeerStore
   let events: TypedEventTarget<Libp2pEvents>
 
   beforeEach(async () => {
     peerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
     otherPeerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
     events = new TypedEventEmitter()
-    peerStore = new PersistentPeerStore({
+    peerStore = persistentPeerStore({
       peerId,
       events,
       datastore: new MemoryDatastore(),
diff --git a/packages/peer-store/test/patch.spec.ts b/packages/peer-store/test/patch.spec.ts
index 54ada9018e..7466c90813 100644
--- a/packages/peer-store/test/patch.spec.ts
+++ b/packages/peer-store/test/patch.spec.ts
@@ -2,14 +2,15 @@
 /* eslint max-nested-callbacks: ["error", 6] */
 
 import { generateKeyPair } from '@libp2p/crypto/keys'
-import { TypedEventEmitter, type TypedEventTarget, type Libp2pEvents, type PeerId, type PeerData } from '@libp2p/interface'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import { expect } from 'aegir/chai'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { pEvent } from 'p-event'
-import { PersistentPeerStore } from '../src/index.js'
+import { persistentPeerStore } from '../src/index.js'
+import type { TypedEventTarget, Libp2pEvents, PeerId, PeerStore, PeerData } from '@libp2p/interface'
 
 const addr1 = multiaddr('/ip4/127.0.0.1/tcp/8000')
 const addr2 = multiaddr('/ip4/20.0.0.1/tcp/8001')
@@ -18,14 +19,14 @@ const addr3 = multiaddr('/ip4/127.0.0.1/tcp/8002')
 describe('patch', () => {
   let peerId: PeerId
   let otherPeerId: PeerId
-  let peerStore: PersistentPeerStore
+  let peerStore: PeerStore
   let events: TypedEventTarget<Libp2pEvents>
 
   beforeEach(async () => {
     peerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
     otherPeerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
     events = new TypedEventEmitter()
-    peerStore = new PersistentPeerStore({
+    peerStore = persistentPeerStore({
       peerId,
       events,
       datastore: new MemoryDatastore(),
diff --git a/packages/peer-store/test/save.spec.ts b/packages/peer-store/test/save.spec.ts
index ae28a91b32..34a8c1e266 100644
--- a/packages/peer-store/test/save.spec.ts
+++ b/packages/peer-store/test/save.spec.ts
@@ -2,7 +2,7 @@
 /* eslint max-nested-callbacks: ["error", 6] */
 
 import { generateKeyPair, publicKeyToProtobuf } from '@libp2p/crypto/keys'
-import { TypedEventEmitter, type TypedEventTarget, type Libp2pEvents, type PeerUpdate, type PeerId, type PeerData } from '@libp2p/interface'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { defaultLogger } from '@libp2p/logger'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
@@ -11,8 +11,9 @@ import { MemoryDatastore } from 'datastore-core/memory'
 import pDefer from 'p-defer'
 import { pEvent } from 'p-event'
 import sinon from 'sinon'
-import { PersistentPeerStore } from '../src/index.js'
+import { persistentPeerStore } from '../src/index.js'
 import { Peer as PeerPB } from '../src/pb/peer.js'
+import type { TypedEventTarget, Libp2pEvents, PeerId, PeerStore, PeerData, PeerUpdate } from '@libp2p/interface'
 
 const addr1 = multiaddr('/ip4/127.0.0.1/tcp/8000')
 const addr2 = multiaddr('/ip4/20.0.0.1/tcp/8001')
@@ -20,14 +21,14 @@ const addr2 = multiaddr('/ip4/20.0.0.1/tcp/8001')
 describe('save', () => {
   let peerId: PeerId
   let otherPeerId: PeerId
-  let peerStore: PersistentPeerStore
+  let peerStore: PeerStore
   let events: TypedEventTarget<Libp2pEvents>
 
   beforeEach(async () => {
     peerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
     otherPeerId = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
     events = new TypedEventEmitter()
-    peerStore = new PersistentPeerStore({
+    peerStore = persistentPeerStore({
       peerId,
       events,
       datastore: new MemoryDatastore(),
diff --git a/packages/pnet/src/index.ts b/packages/pnet/src/index.ts
index b770d9d5bc..0ca39fa1ef 100644
--- a/packages/pnet/src/index.ts
+++ b/packages/pnet/src/index.ts
@@ -81,7 +81,8 @@ export interface ProtectorInit {
   psk: Uint8Array
   /**
    * The initial nonce exchange must complete within this many milliseconds
-   * (default: 1000)
+   *
+   * @default 1000
    */
   timeout?: number
 }
diff --git a/packages/protocol-dcutr/src/index.ts b/packages/protocol-dcutr/src/index.ts
index eb86246e69..2189a15b62 100644
--- a/packages/protocol-dcutr/src/index.ts
+++ b/packages/protocol-dcutr/src/index.ts
@@ -61,24 +61,32 @@ import type { AddressManager, ConnectionManager, Registrar, TransportManager } f
 
 export interface DCUtRServiceInit {
   /**
-   * How long we should wait for the connection upgrade to complete (default: 5s)
+   * How long we should wait for the connection upgrade to complete
+   *
+   * @default 5000
    */
   timeout?: number
 
   /**
-   * How many times to retry the connection upgrade (default: 3)
+   * How many times to retry the connection upgrade
+   *
+   * @default 3
    */
   retries?: number
 
   /**
    * How many simultaneous inbound DCUtR protocol streams to allow on each
-   * connection (default: 1)
+   * connection
+   *
+   * @default 1
    */
   maxInboundStreams?: number
 
   /**
    * How many simultaneous outbound DCUtR protocol streams to allow on each
-   * connection (default: 1)
+   * connection
+   *
+   * @default 1
    */
   maxOutboundStreams?: number
 }
diff --git a/packages/protocol-perf/README.md b/packages/protocol-perf/README.md
index 872319f368..63445f1f84 100644
--- a/packages/protocol-perf/README.md
+++ b/packages/protocol-perf/README.md
@@ -24,7 +24,7 @@ repo and examine the changes made.
 
 -->
 
-The PerfService implements the [perf protocol](https://github.com/libp2p/specs/blob/master/perf/perf.md), which can be used to measure transfer performance within and across libp2p implementations.
+The Perf service implements the [perf protocol](https://github.com/libp2p/specs/blob/master/perf/perf.md), which can be used to measure transfer performance within and across libp2p implementations.
 
 ## Example
 
diff --git a/packages/protocol-perf/src/index.ts b/packages/protocol-perf/src/index.ts
index a9d117508b..4965614f5e 100644
--- a/packages/protocol-perf/src/index.ts
+++ b/packages/protocol-perf/src/index.ts
@@ -1,7 +1,7 @@
 /**
  * @packageDocumentation
  *
- * The {@link PerfService} implements the [perf protocol](https://github.com/libp2p/specs/blob/master/perf/perf.md), which can be used to measure transfer performance within and across libp2p implementations.
+ * The {@link Perf} service implements the [perf protocol](https://github.com/libp2p/specs/blob/master/perf/perf.md), which can be used to measure transfer performance within and across libp2p implementations.
  *
  * @example
  *
@@ -62,7 +62,9 @@ export interface PerfOptions extends AbortOptions {
    * connection, so a new connection will be opened for every performance run.
    *
    * To override this and re-use an existing connection if one is present, pass
-   * `true` here. (default: false)
+   * `true` here.
+   *
+   * @default false
    */
   reuseExistingConnection?: boolean
 }
@@ -85,7 +87,9 @@ export interface PerfInit {
   runOnLimitedConnection?: boolean
 
   /**
-   * Data sent/received will be sent in chunks of this size (default: 64KiB)
+   * Data sent/received will be sent in chunks of this size
+   *
+   * @default 65536
    */
   writeBlockSize?: number
 }
diff --git a/packages/pubsub-floodsub/src/index.ts b/packages/pubsub-floodsub/src/index.ts
index a2517a68c3..eb18207788 100644
--- a/packages/pubsub-floodsub/src/index.ts
+++ b/packages/pubsub-floodsub/src/index.ts
@@ -56,7 +56,7 @@ export interface FloodSubComponents extends PubSubComponents {
  * delivering an API for Publish/Subscribe, but with no CastTree Forming
  * (it just floods the network).
  */
-export class FloodSub extends PubSubBaseProtocol {
+class FloodSub extends PubSubBaseProtocol {
   public seenCache: SimpleTimeCache<boolean>
 
   constructor (components: FloodSubComponents, init?: FloodSubInit) {
diff --git a/packages/pubsub-floodsub/test/compliance.spec.ts b/packages/pubsub-floodsub/test/compliance.spec.ts
index 006a7a46ba..78bea1def2 100644
--- a/packages/pubsub-floodsub/test/compliance.spec.ts
+++ b/packages/pubsub-floodsub/test/compliance.spec.ts
@@ -1,7 +1,7 @@
 /* eslint-env mocha */
 
 import tests from '@libp2p/interface-compliance-tests/pubsub'
-import { FloodSub } from '../src/index.js'
+import { floodsub } from '../src/index.js'
 
 describe('interface compliance', () => {
   tests({
@@ -10,7 +10,7 @@ describe('interface compliance', () => {
         throw new Error('PubSubOptions is required')
       }
 
-      const pubsub = new FloodSub(args.components, args.init)
+      const pubsub = floodsub(args.init)(args.components)
 
       return pubsub
     },
diff --git a/packages/pubsub-floodsub/test/floodsub.spec.ts b/packages/pubsub-floodsub/test/floodsub.spec.ts
index 0a92559875..faeb5f74cf 100644
--- a/packages/pubsub-floodsub/test/floodsub.spec.ts
+++ b/packages/pubsub-floodsub/test/floodsub.spec.ts
@@ -1,7 +1,7 @@
 /* eslint-env mocha */
 
 import { generateKeyPair } from '@libp2p/crypto/keys'
-import { type Message, type PubSubRPC, StrictNoSign } from '@libp2p/interface'
+import { type Message, type PubSubRPC, StrictNoSign, start, stop } from '@libp2p/interface'
 import { mockRegistrar } from '@libp2p/interface-compliance-tests/mocks'
 import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
@@ -13,13 +13,13 @@ import pWaitFor from 'p-wait-for'
 import sinon from 'sinon'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { FloodSub, multicodec } from '../src/index.js'
+import { floodsub, multicodec } from '../src/index.js'
 
 const topic = 'my-topic'
 const message = uint8ArrayFromString('a neat message')
 
 describe('floodsub', () => {
-  let floodsub: FloodSub
+  let pubsub: any
 
   before(async () => {
     expect(multicodec).to.exist()
@@ -27,24 +27,24 @@ describe('floodsub', () => {
     const privateKey = await generateKeyPair('Ed25519')
     const peerId = peerIdFromPrivateKey(privateKey)
 
-    floodsub = new FloodSub({
+    pubsub = floodsub({
+      emitSelf: true,
+      globalSignaturePolicy: StrictNoSign
+    })({
       peerId,
       privateKey,
       registrar: mockRegistrar(),
       logger: defaultLogger()
-    }, {
-      emitSelf: true,
-      globalSignaturePolicy: StrictNoSign
     })
   })
 
   beforeEach(async () => {
-    await floodsub.start()
+    await start(pubsub)
   })
 
   afterEach(async () => {
     sinon.restore()
-    await floodsub.stop()
+    await stop(pubsub)
   })
 
   it('checks cache when processing incoming message', async function () {
@@ -68,46 +68,46 @@ describe('floodsub', () => {
       }]
     }
 
-    floodsub.subscribe(topic)
-    floodsub.addEventListener('message', (evt) => {
+    pubsub.subscribe(topic)
+    pubsub.addEventListener('message', (evt: any) => {
       if (evt.detail.topic === topic) {
         callCount++
       }
     })
 
     // the message should not be in the cache
-    expect(floodsub.seenCache.has(key)).to.be.false()
+    expect(pubsub.seenCache.has(key)).to.be.false()
 
     // receive the message once
-    await floodsub.processRpc(peerStream.id, peerStream, rpc)
-    await floodsub.queue.onIdle()
+    await pubsub.processRpc(peerStream.id, peerStream, rpc)
+    await pubsub.queue.onIdle()
 
     // should have received the message
     expect(callCount).to.equal(1)
 
     // should be in the cache now
-    expect(floodsub.seenCache.has(key)).to.be.true()
+    expect(pubsub.seenCache.has(key)).to.be.true()
 
     // receive the message multiple times
-    await floodsub.processRpc(peerStream.id, peerStream, rpc)
-    await floodsub.processRpc(peerStream.id, peerStream, rpc)
-    await floodsub.processRpc(peerStream.id, peerStream, rpc)
+    await pubsub.processRpc(peerStream.id, peerStream, rpc)
+    await pubsub.processRpc(peerStream.id, peerStream, rpc)
+    await pubsub.processRpc(peerStream.id, peerStream, rpc)
 
     // should only have emitted the message once
     expect(callCount).to.equal(1)
   })
 
   it('forwards normalized messages on publish', async () => {
-    const spy = sinon.spy(floodsub, 'send')
+    const spy = sinon.spy(pubsub, 'send')
 
     const otherPeer = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
 
-    floodsub.getSubscribers = () => {
+    pubsub.getSubscribers = () => {
       return [otherPeer]
     }
 
-    expect(floodsub.send).to.have.property('callCount', 0)
-    await floodsub.publish(topic, message)
+    expect(pubsub.send).to.have.property('callCount', 0)
+    await pubsub.publish(topic, message)
 
     await pWaitFor(async () => spy.callCount === 1)
 
@@ -124,7 +124,7 @@ describe('floodsub', () => {
   })
 
   it('does not send received message back to original sender', async () => {
-    sinon.spy(floodsub, 'sendRpc')
+    sinon.spy(pubsub, 'sendRpc')
 
     const sender = peerIdFromPrivateKey(await generateKeyPair('Ed25519'))
 
@@ -146,12 +146,12 @@ describe('floodsub', () => {
     // otherPeer is subscribed to the topic
     const peerSet = new PeerSet()
     peerSet.add(sender)
-    floodsub.topics.set(topic, peerSet)
+    pubsub.topics.set(topic, peerSet)
 
     // receive the message
-    await floodsub.processRpc(peerStream.id, peerStream, rpc)
+    await pubsub.processRpc(peerStream.id, peerStream, rpc)
 
     // should not forward back to the sender
-    expect(floodsub.sendRpc).to.have.property('called', false)
+    expect(pubsub.sendRpc).to.have.property('called', false)
   })
 })
diff --git a/packages/pubsub/typedoc.json b/packages/pubsub/typedoc.json
index a37049da87..25428cb221 100644
--- a/packages/pubsub/typedoc.json
+++ b/packages/pubsub/typedoc.json
@@ -1,7 +1,6 @@
 {
   "entryPoints": [
     "./src/index.ts",
-    "./src/errors.ts",
     "./src/peer-streams.ts",
     "./src/utils.ts"
   ]
diff --git a/packages/stream-multiplexer-mplex/src/index.ts b/packages/stream-multiplexer-mplex/src/index.ts
index 0f86c2e3ef..0fcdb51a2a 100644
--- a/packages/stream-multiplexer-mplex/src/index.ts
+++ b/packages/stream-multiplexer-mplex/src/index.ts
@@ -35,12 +35,16 @@ import { serviceCapabilities } from '@libp2p/interface'
 import { MplexStreamMuxer, type MplexComponents } from './mplex.js'
 import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface'
 
+export type { MplexComponents }
+
 export interface MplexInit {
   /**
    * The maximum size of message that can be sent in one go in bytes.
    * Messages larger than this will be split into multiple smaller
    * messages. If we receive a message larger than this an error will
-   * be thrown and the connection closed. (default: 1MB)
+   * be thrown and the connection closed.
+   *
+   * @default 1048576
    */
   maxMsgSize?: number
 
@@ -49,7 +53,8 @@ export interface MplexInit {
    * Before messages are deserialized, the raw bytes are buffered to ensure
    * we have the complete message to deserialized. If the queue gets longer
    * than this value an error will be thrown and the connection closed.
-   * (default: 4MB)
+   *
+   * @default 4194304
    */
   maxUnprocessedMessageQueueSize?: number
 
@@ -57,27 +62,35 @@ export interface MplexInit {
    * The maximum number of multiplexed streams that can be open at any
    * one time. A request to open more than this will have a stream
    * reset message sent immediately as a response for the newly opened
-   * stream id (default: 1024)
+   * stream id
+   *
+   * @default 1024
    */
   maxInboundStreams?: number
 
   /**
    * The maximum number of multiplexed streams that can be open at any
-   * one time. An attempt to open more than this will throw (default: 1024)
+   * one time. An attempt to open more than this will throw
+   *
+   * @default 1024
    */
   maxOutboundStreams?: number
 
   /**
    * Incoming stream messages are buffered until processed by the stream
    * handler. If the buffer reaches this size in bytes the stream will
-   * be reset (default: 4MB)
+   * be reset
+   *
+   * @default 4194304
    */
   maxStreamBufferSize?: number
 
   /**
    * When `maxInboundStreams` is hit, if the remote continues try to open
    * more than this many new multiplexed streams per second the connection
-   * will be closed (default: 5)
+   * will be closed
+   *
+   * @default 5
    */
   disconnectThreshold?: number
 }
diff --git a/packages/transport-circuit-relay-v2/src/index.ts b/packages/transport-circuit-relay-v2/src/index.ts
index 429f669345..98d94b0259 100644
--- a/packages/transport-circuit-relay-v2/src/index.ts
+++ b/packages/transport-circuit-relay-v2/src/index.ts
@@ -44,6 +44,8 @@ import type { TypedEventEmitter } from '@libp2p/interface'
 import type { PeerMap } from '@libp2p/peer-collections'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
+export type { Limit }
+
 export interface RelayReservation {
   expire: Date
   addr: Multiaddr
@@ -61,7 +63,12 @@ export interface CircuitRelayService extends TypedEventEmitter<CircuitRelayServi
 }
 
 export { circuitRelayServer } from './server/index.js'
+export type { CircuitRelayServerInit, CircuitRelayServerComponents } from './server/index.js'
+export type { ReservationStoreInit } from './server/reservation-store.js'
 export { circuitRelayTransport } from './transport/index.js'
+export type { RelayDiscoveryComponents } from './transport/discovery.js'
+export type { RelayStoreInit } from './transport/reservation-store.js'
+export type { CircuitRelayTransportInit, CircuitRelayTransportComponents } from './transport/index.js'
 
 export {
   RELAY_V2_HOP_CODEC,
diff --git a/packages/transport-circuit-relay-v2/src/server/index.ts b/packages/transport-circuit-relay-v2/src/server/index.ts
index c71f28ee0f..34069f95d9 100644
--- a/packages/transport-circuit-relay-v2/src/server/index.ts
+++ b/packages/transport-circuit-relay-v2/src/server/index.ts
@@ -27,7 +27,9 @@ const isRelayAddr = (ma: Multiaddr): boolean => ma.protoCodes().includes(CIRCUIT
 export interface CircuitRelayServerInit {
   /**
    * Incoming hop requests must complete within this time in ms otherwise
-   * the stream will be reset (default: 30s)
+   * the stream will be reset
+   *
+   * @default 30000
    */
   hopTimeout?: number
 
@@ -48,7 +50,9 @@ export interface CircuitRelayServerInit {
 
   /**
    * The maximum number of simultaneous STOP outbound streams that can be open at
-   * once. (default: 300)
+   * once.
+   *
+   * @default 300
    */
   maxOutboundStopStreams?: number
 }
diff --git a/packages/transport-circuit-relay-v2/src/server/reservation-store.ts b/packages/transport-circuit-relay-v2/src/server/reservation-store.ts
index e3bc8192b7..fe1daf41c5 100644
--- a/packages/transport-circuit-relay-v2/src/server/reservation-store.ts
+++ b/packages/transport-circuit-relay-v2/src/server/reservation-store.ts
@@ -8,26 +8,39 @@ import type { Multiaddr } from '@multiformats/multiaddr'
 export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED
 
 export interface ReservationStoreInit {
-  /*
-   * maximum number of reservations allowed, default: 15
+  /**
+   * maximum number of reservations allowed
+   *
+   * @default 15
    */
   maxReservations?: number
-  /*
-   * interval after which stale reservations are cleared, default: 300s
+
+  /**
+   * interval after which stale reservations are cleared
+   *
+   * @default 300000
    */
   reservationClearInterval?: number
-  /*
-   * apply default relay limits to a new reservation, default: true
+
+  /**
+   * apply default relay limits to a new reservation
+   *
+   * @default true
    */
   applyDefaultLimit?: boolean
+
   /**
-   * reservation ttl, default: 2 hours
+   * reservation ttl
+   *
+   * @default 7200000
    */
   reservationTtl?: number
+
   /**
    * The maximum time a relayed connection can be open for
    */
   defaultDurationLimit?: number
+
   /**
    * The maximum amount of data allowed to be transferred over a relayed connection
    */
diff --git a/packages/transport-circuit-relay-v2/src/transport/reservation-store.ts b/packages/transport-circuit-relay-v2/src/transport/reservation-store.ts
index c8de6ff56a..dccd44a4d9 100644
--- a/packages/transport-circuit-relay-v2/src/transport/reservation-store.ts
+++ b/packages/transport-circuit-relay-v2/src/transport/reservation-store.ts
@@ -39,7 +39,9 @@ export interface RelayStoreInit {
    * slot on at once. If set to more than one, we may end up listening on
    * more relays than the `maxReservations` value, but on networks with poor
    * connectivity the user may wish to attempt to reserve on multiple relays
-   * simultaneously. (default: 1)
+   * simultaneously.
+   *
+   * @default 1
    */
   reservationConcurrency?: number
 
@@ -49,13 +51,16 @@ export interface RelayStoreInit {
   discoverRelays?: number
 
   /**
-   * Limit the number of potential relays we will dial (default: 100)
+   * Limit the number of potential relays we will dial
+   *
+   * @default 100
    */
   maxReservationQueueLength?: number
 
   /**
    * When creating a reservation it must complete within this number of ms
-   * (default: 5000)
+   *
+   * @default 5000
    */
   reservationCompletionTimeout?: number
 }
diff --git a/packages/transport-tcp/src/index.ts b/packages/transport-tcp/src/index.ts
index c3d0a1f8ea..9a74dd3e93 100644
--- a/packages/transport-tcp/src/index.ts
+++ b/packages/transport-tcp/src/index.ts
@@ -33,6 +33,8 @@ import type { ComponentLogger, CounterGroup, Metrics, CreateListenerOptions, Dia
 import type { AbortOptions } from '@multiformats/multiaddr'
 import type { ProgressEvent } from 'progress-events'
 
+export type { CloseServerOnMaxConnectionsOpts }
+
 export interface TCPOptions {
   /**
    * An optional number in ms that is used as an inactivity timeout after which the socket will be closed
diff --git a/packages/transport-webrtc/src/index.ts b/packages/transport-webrtc/src/index.ts
index 55e8ed0f97..406e4bad04 100644
--- a/packages/transport-webrtc/src/index.ts
+++ b/packages/transport-webrtc/src/index.ts
@@ -198,34 +198,44 @@ import type { Transport } from '@libp2p/interface'
 
 export interface DataChannelOptions {
   /**
-   * The maximum message size sendable over the channel in bytes (default 16KB)
+   * The maximum message size sendable over the channel in bytes
+   *
+   * @default 16384
    */
   maxMessageSize?: number
 
   /**
    * If the channel's `bufferedAmount` grows over this amount in bytes, wait
-   * for it to drain before sending more data (default: 16MB)
+   * for it to drain before sending more data
+   *
+   * @default 16777216
    */
   maxBufferedAmount?: number
 
   /**
    * When `bufferedAmount` is above `maxBufferedAmount`, we pause sending until
    * the `bufferedAmountLow` event fires - this controls how long we wait for
-   * that event in ms (default: 30s)
+   * that event in ms
+   *
+   * @default 30000
    */
   bufferedAmountLowEventTimeout?: number
 
   /**
    * When closing a stream, we wait for `bufferedAmount` to become 0 before
    * closing the underlying RTCDataChannel - this controls how long we wait
-   * in ms (default: 30s)
+   * in ms
+   *
+   * @default 30000
    */
   drainTimeout?: number
 
   /**
    * When closing a stream we first send a FIN flag to the remote and wait
    * for a FIN_ACK reply before closing the underlying RTCDataChannel - this
-   * controls how long we wait for the acknowledgement in ms (default: 5s)
+   * controls how long we wait for the acknowledgement in ms
+   *
+   * @default 5000
    */
   closeTimeout?: number
 
@@ -236,27 +246,14 @@ export interface DataChannelOptions {
   openTimeout?: number
 }
 
-/**
- * @param {WebRTCTransportDirectInit} init - WebRTC direct transport configuration
- * @param init.dataChannel - DataChannel configurations
- * @param {number} init.dataChannel.maxMessageSize - Max message size that can be sent through the DataChannel. Larger messages will be chunked into smaller messages below this size (default 16kb)
- * @param {number} init.dataChannel.maxBufferedAmount - Max buffered amount a DataChannel can have (default 16mb)
- * @param {number} init.dataChannel.bufferedAmountLowEventTimeout - If max buffered amount is reached, this is the max time that is waited before the buffer is cleared (default 30 seconds)
- * @returns
- */
+export type { WebRTCTransportDirectInit, WebRTCDirectTransportComponents }
+
 function webRTCDirect (init?: WebRTCTransportDirectInit): (components: WebRTCDirectTransportComponents) => Transport {
   return (components: WebRTCDirectTransportComponents) => new WebRTCDirectTransport(components, init)
 }
 
-/**
- * @param {WebRTCTransportInit} init - WebRTC transport configuration
- * @param {RTCConfiguration} init.rtcConfiguration - RTCConfiguration
- * @param init.dataChannel - DataChannel configurations
- * @param {number} init.dataChannel.maxMessageSize - Max message size that can be sent through the DataChannel. Larger messages will be chunked into smaller messages below this size (default 16kb)
- * @param {number} init.dataChannel.maxBufferedAmount - Max buffered amount a DataChannel can have (default 16mb)
- * @param {number} init.dataChannel.bufferedAmountLowEventTimeout - If max buffered amount is reached, this is the max time that is waited before the buffer is cleared (default 30 seconds)
- * @returns
- */
+export type { WebRTCTransportInit, WebRTCTransportComponents }
+
 function webRTC (init?: WebRTCTransportInit): (components: WebRTCTransportComponents) => Transport {
   return (components: WebRTCTransportComponents) => new WebRTCTransport(components, init)
 }
diff --git a/packages/transport-webrtc/src/private-to-private/transport.ts b/packages/transport-webrtc/src/private-to-private/transport.ts
index e6cf91d851..1e374107ba 100644
--- a/packages/transport-webrtc/src/private-to-private/transport.ts
+++ b/packages/transport-webrtc/src/private-to-private/transport.ts
@@ -25,7 +25,8 @@ export interface WebRTCTransportInit {
 
   /**
    * Inbound connections must complete the upgrade within this many ms
-   * (default: 30s)
+   *
+   * @default 30000
    */
   inboundConnectionTimeout?: number
 }
diff --git a/packages/utils/src/abstract-stream.ts b/packages/utils/src/abstract-stream.ts
index b5971c8a71..a92810d0e4 100644
--- a/packages/utils/src/abstract-stream.ts
+++ b/packages/utils/src/abstract-stream.ts
@@ -59,7 +59,9 @@ export interface AbstractStreamInit {
 
   /**
    * How long to wait in ms for stream data to be written to the underlying
-   * connection when closing the writable end of the stream. (default: 500)
+   * connection when closing the writable end of the stream.
+   *
+   * @default 500
    */
   closeTimeout?: number
 
diff --git a/packages/utils/src/filters/index.ts b/packages/utils/src/filters/index.ts
index 6f13a9aa1f..20c911a05c 100644
--- a/packages/utils/src/filters/index.ts
+++ b/packages/utils/src/filters/index.ts
@@ -1,6 +1,9 @@
 export { BloomFilter, createBloomFilter, type BloomFilterOptions } from './bloom-filter.js'
 export { CuckooFilter, createCuckooFilter, type CuckooFilterInit } from './cuckoo-filter.js'
 export { ScalableCuckooFilter, createScalableCuckooFilter, type ScalableCuckooFilterInit } from './scalable-cuckoo-filter.js'
+export type { Bucket } from './bucket.js'
+export type { Fingerprint } from './fingerprint.js'
+export type { Hash } from './hashes.js'
 
 export interface Filter {
   add(item: Uint8Array | string): void
diff --git a/packages/utils/src/queue/index.ts b/packages/utils/src/queue/index.ts
index f35c386376..3c9969ba25 100644
--- a/packages/utils/src/queue/index.ts
+++ b/packages/utils/src/queue/index.ts
@@ -4,6 +4,9 @@ import { raceEvent } from 'race-event'
 import { Job } from './job.js'
 import type { AbortOptions, Metrics } from '@libp2p/interface'
 
+export type { Job, JobTimeline } from './job.js'
+export type { JobRecipient } from './recipient.js'
+
 export interface Comparator<T> {
   (a: T, b: T): -1 | 0 | 1
 }
diff --git a/packages/utils/src/rate-limiter.ts b/packages/utils/src/rate-limiter.ts
index 3b0099c430..2a544c93cd 100644
--- a/packages/utils/src/rate-limiter.ts
+++ b/packages/utils/src/rate-limiter.ts
@@ -188,7 +188,7 @@ export class RateLimiter {
   }
 }
 
-class MemoryStorage {
+export class MemoryStorage {
   public readonly storage: Map<string, RateRecord>
 
   constructor () {