diff --git a/index.d.ts b/index.d.ts
index 6d0e1aa3..81df9958 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -57,17 +57,17 @@ declare namespace Router {
     store: any
   ) => void;
 
-  interface ConstraintStrategy<V extends HTTPVersion> {
+  interface ConstraintStrategy<V extends HTTPVersion, T = string> {
     name: string,
     mustMatchWhenDerived?: boolean,
     storage() : {
-      get(version: String) : Handler<V> | null,
-      set(version: String, store: Handler<V>) : void,
-      del(version: String) : void,
+      get(value: T) : Handler<V> | null,
+      set(value: T, handler: Handler<V>) : void,
+      del(value: T) : void,
       empty() : void
     },
     validate(value: unknown): void,
-    deriveConstraint<Context>(req: Req<V>, ctx?: Context) : String,
+    deriveConstraint<Context>(req: Req<V>, ctx?: Context) : T,
   }
 
   interface Config<V extends HTTPVersion> {
diff --git a/test/types/router.test-d.ts b/test/types/router.test-d.ts
index e36ee58e..0c1f79f8 100644
--- a/test/types/router.test-d.ts
+++ b/test/types/router.test-d.ts
@@ -111,3 +111,61 @@ let http2Res!: Http2ServerResponse;
   expectType<string>(router.prettyPrint())
 
 }
+
+// Custom Constraint
+{
+  let handler: Router.Handler<Router.HTTPVersion.V1>
+
+  interface AcceptAndContentType { accept?: string, contentType?: string }
+
+  const customConstraintWithObject: Router.ConstraintStrategy<Router.HTTPVersion.V1, AcceptAndContentType> = {
+    name: "customConstraintWithObject",
+    deriveConstraint<Context>(req: Router.Req<Router.HTTPVersion.V1>, ctx: Context | undefined): AcceptAndContentType {
+      return {
+        accept: req.headers.accept,
+        contentType: req.headers["content-type"]
+      }
+    },
+    validate(value: unknown): void {},
+    storage () {
+      return {
+        get (version) { return handler },
+        set (version, handler) {},
+        del (version) {},
+        empty () {}
+      }
+    }
+  }
+  const storageWithObject = customConstraintWithObject.storage()
+  const acceptAndContentType: AcceptAndContentType = { accept: 'application/json', contentType: 'application/xml' }
+
+  expectType<AcceptAndContentType>(customConstraintWithObject.deriveConstraint(http1Req, http1Res))
+  expectType<void>(storageWithObject.empty())
+  expectType<void>(storageWithObject.del(acceptAndContentType));
+  expectType<Router.Handler<Router.HTTPVersion.V1> | null>(storageWithObject.get(acceptAndContentType));
+  expectType<void>(storageWithObject.set(acceptAndContentType, () => {}));
+
+  const customConstraintWithDefault: Router.ConstraintStrategy<Router.HTTPVersion.V1> = {
+    name: "customConstraintWithObject",
+    deriveConstraint<Context>(req: Router.Req<Router.HTTPVersion.V1>, ctx: Context | undefined): string {
+      return req.headers.accept ?? ''
+    },
+    validate(value: unknown): void {},
+    storage () {
+      return {
+        get (version) { return handler },
+        set (version, handler) {},
+        del (version) {},
+        empty () {}
+      }
+    }
+  }
+
+  const storageWithDefault = customConstraintWithDefault.storage()
+
+  expectType<string>(customConstraintWithDefault.deriveConstraint(http1Req, http1Res))
+  expectType<void>(storageWithDefault.empty())
+  expectType<void>(storageWithDefault.del(''));
+  expectType<Router.Handler<Router.HTTPVersion.V1> | null>(storageWithDefault.get(''));
+  expectType<void>(storageWithDefault.set('', () => {}));
+}