diff --git a/package.json b/package.json
index 724596d..64f0461 100644
--- a/package.json
+++ b/package.json
@@ -10,7 +10,7 @@
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
     "test:unit": "c8 tape test/*.js",
-    "test:typescript": "tsd"
+    "test:typescript": "tstyche"
   },
   "repository": {
     "type": "git",
@@ -56,7 +56,7 @@
     "neostandard": "^0.13.0",
     "tape": "^5.7.5",
     "c8": "^11.0.0",
-    "tsd": "^0.33.0"
+    "tstyche": "^7.0.0"
   },
   "files": [
     "LICENSE",
@@ -71,4 +71,4 @@
     "object",
     "immutable"
   ]
-}
+}
\ No newline at end of file
diff --git a/types/index.test-d.ts b/types/index.test-d.ts
deleted file mode 100644
index 58235ac..0000000
--- a/types/index.test-d.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-import { expectAssignable, expectError, expectType } from 'tsd'
-import { deepmerge, type DeepMergeFn, type DeepMergeAllFn, DeepMergeDefinedFn, DeepMergeAllDefinedFn } from '.'
-
-// onlyDefinedProperties: true tests
-// When source has optional properties (Partial), merging into a full type should preserve required-ness
-
-expectAssignable<Function>(deepmerge())
-expectType<DeepMergeFn>(deepmerge())
-
-expectType<string>(deepmerge()({ a: 'a' }, { b: 'b' }).a)
-expectType<string>(deepmerge()({ a: 'a' }, { b: 'b' }).b)
-expectType<number>(deepmerge()({ a: 2 }, { b: 'b' }).a)
-expectType<string>(deepmerge()({ a: 2 }, { b: 'b' }).b)
-expectType<string>(deepmerge()({ a: 2 }, { a: 'b' }).a)
-
-expectError(deepmerge(1))
-expectError(deepmerge({ symbols: 2 }))
-expectError(deepmerge({ symbol: 2 }))
-
-expectAssignable<Function>(deepmerge({ symbols: true }))
-expectType<DeepMergeFn>(deepmerge({ symbols: true }))
-
-expectType<string>(deepmerge()('string', { a: 'string' }).a)
-expectType<string>(deepmerge()(1, { a: 'string' }).a)
-
-expectType<string>(deepmerge()<Object, string>({ a: 'string' }, 'string'))
-expectType<number>(deepmerge()<Object, number>({ a: 'string' }, 1))
-expectType<Date>(deepmerge()({ a: 'string' }, new Date()))
-expectType<RegExp>(deepmerge()({ a: 'string' }, /a/g))
-expectType<{}>(deepmerge()(/a/, {}))
-
-expectType<number>(deepmerge()({ a: 'string' }, { a: 1 }).a)
-expectType<string>(deepmerge()({ a: 'string' }, { b: 1 }).a)
-expectType<string>(deepmerge()({ a: 'string' }, { }).a)
-expectType<number>(deepmerge()({ a: 'string' }, { b: 1 }).b)
-expectType<{ a: string }>(deepmerge()({ a: { a: 'string' } }, { b: 1 }).a)
-expectType<{ a: number }>(deepmerge()({ a: { a: 'string' } }, { a: { a: 1 } }).a)
-expectType<{ a: number, b: string }>(deepmerge()({ a: { a: 'string' } }, { a: { a: 1, b: 'string' } }).a)
-expectType<{ a: number, b: string }>(deepmerge()({ a: { a: { a: 'string' } } }, { a: { a: 1, b: 'string' } }).a)
-expectType<{ a: { a: string, b: string } }>(deepmerge()({ a: { a: { a: 'string' } } }, { a: { a: { b: 'string' } } }).a)
-expectType<string>(deepmerge()({ a: [1, 2, 3, 4] }, { a: 'string' }).a)
-expectType<number[]>(deepmerge()({ a: [1, 2, 3, 4] }, { a: [1, 2, 3, 4] }).a)
-expectType<(number | string)[]>(deepmerge()({ a: [1, 2, 3, 4] }, { a: ['a'] }).a)
-expectType<(number | string)[]>(deepmerge()({ a: [1, 2, 3, 4] as readonly number[] }, { a: ['a'] }).a)
-expectType<[1, 2, 3, 4, 'a']>(deepmerge()({ a: [1, 2, 3, 4] as const }, { a: ['a'] as const }).a)
-expectType<Array<number>>(deepmerge()({ a: [1] }, { a: [2] }).a)
-expectType<{ b: number[] }>(deepmerge()({ a: { b: {} } }, { a: { b: [2] } }).a)
-expectType<{ b: Date }>(deepmerge()({ a: { b: {} } }, { a: { b: new Date() } }).a)
-expectType<{ b: RegExp }>(deepmerge()({ a: { b: {} } }, { a: { b: /abc/g } }).a)
-expectType<Date>(deepmerge()({ a: { b: {} } }, new Date()))
-expectType<Map<any, any>>(deepmerge()({ a: { b: {} } }, new Map()))
-
-expectAssignable<Function>(deepmerge({ all: true }))
-expectType<DeepMergeAllFn>(deepmerge({ all: true }))
-expectAssignable<Function>(deepmerge({ all: true, symbols: true }))
-expectType<DeepMergeAllFn>(deepmerge({ all: true, symbols: true }))
-expectType<string>(deepmerge({ all: true, symbols: true })({ a: 'a' }).a)
-expectType<string>(deepmerge({ all: true, symbols: true })({ a: 'a' }, { b: 'a' }).a)
-expectType<string>(deepmerge({ all: true, symbols: true })({ a: 'a' }, { b: 'a' }).b)
-expectType<number>(deepmerge({ all: true, symbols: true })({ a: 'a' }, { a: 2 }).a)
-expectType<number>(deepmerge({ all: true, symbols: true })({ a: 'a' }, 2))
-expectType<string>(deepmerge({ all: true, symbols: true })({ a: 'a' }, 'string'))
-
-expectError(deepmerge({ mergeArray: function () { } }))
-expectError(deepmerge({ mergeArray: function () { return () => 'test' } }))
-deepmerge({
-  mergeArray: function (options) {
-    expectType<(value: any) => any>(options.clone)
-    const clone = options.clone
-    return function (target, source) {
-      return clone(target.concat(source))
-    }
-  }
-})
-deepmerge({
-  mergeArray: function () {
-    return function (_target, source) {
-      return source
-    }
-  }
-})
-deepmerge({
-  isMergeableObject: function (value) {
-    return true
-  }
-})
-
-expectType<(value: any) => boolean>(deepmerge.isMergeableObject)
-expectError(deepmerge.isMergeableObject = function () { return false })
-
-expectType<DeepMergeDefinedFn>(deepmerge({ onlyDefinedProperties: true }))
-expectType<DeepMergeAllDefinedFn>(deepmerge({ all: true, onlyDefinedProperties: true }))
-
-// Basic case: merging partial into full type preserves required properties
-interface FullOptions {
-  apiUrl: string
-  timeout: number
-  nested: {
-    enabled: boolean
-    value: string
-  }
-}
-
-type PartialOptions = Partial<FullOptions>
-
-// With onlyDefinedProperties: true, merging Partial<T> into T should return T
-// because undefined values from source are ignored at runtime
-const fullTarget: FullOptions = { apiUrl: 'url', timeout: 100, nested: { enabled: true, value: 'test' } }
-const partialSource: PartialOptions = { timeout: 200 }
-
-const mergedDefined = deepmerge({ onlyDefinedProperties: true })(fullTarget, partialSource)
-expectType<string>(mergedDefined.apiUrl)
-expectType<number>(mergedDefined.timeout)
-expectType<{ enabled: boolean; value: string }>(mergedDefined.nested)
-
-// Result should be assignable to FullOptions (the target type)
-expectAssignable<FullOptions>(mergedDefined)
-
-// Contrast with regular merge (without onlyDefinedProperties) - source undefined could override
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const mergedRegular = deepmerge()(fullTarget, partialSource)
-
-// Deep partial merging
-type DeepPartialOptions = {
-  apiUrl?: string
-  timeout?: number
-  nested?: {
-    enabled?: boolean
-    value?: string
-  }
-}
-
-const deepPartialSource: DeepPartialOptions = { nested: { enabled: false } }
-const mergedDeep = deepmerge({ onlyDefinedProperties: true })(fullTarget, deepPartialSource)
-expectType<string>(mergedDeep.apiUrl)
-expectType<number>(mergedDeep.timeout)
-// Nested properties should also preserve required-ness from target
-expectAssignable<{ enabled: boolean; value: string }>(mergedDeep.nested)
-
-// all mode with onlyDefinedProperties
-const mergedAll = deepmerge({ all: true, onlyDefinedProperties: true })(
-  fullTarget,
-  { timeout: 300 } as PartialOptions,
-  { apiUrl: 'newUrl' } as PartialOptions
-)
-expectAssignable<FullOptions>(mergedAll)
diff --git a/types/index.tst.ts b/types/index.tst.ts
new file mode 100644
index 0000000..b1d56ae
--- /dev/null
+++ b/types/index.tst.ts
@@ -0,0 +1,139 @@
+import { expect } from 'tstyche'
+import { deepmerge, type DeepMergeFn, type DeepMergeAllFn, DeepMergeDefinedFn, DeepMergeAllDefinedFn } from '.'
+
+expect(deepmerge()).type.toBeAssignableTo<Function>()
+expect(deepmerge()).type.toBe<DeepMergeFn>()
+
+expect(deepmerge()({ a: 'a' }, { b: 'b' }).a).type.toBe<string>()
+expect(deepmerge()({ a: 'a' }, { b: 'b' }).b).type.toBe<string>()
+expect(deepmerge()({ a: 2 }, { b: 'b' }).a).type.toBe<number>()
+expect(deepmerge()({ a: 2 }, { b: 'b' }).b).type.toBe<string>()
+expect(deepmerge()({ a: 2 }, { a: 'b' }).a).type.toBe<string>()
+
+expect(deepmerge).type.not.toBeCallableWith(1)
+expect(deepmerge).type.not.toBeCallableWith({ symbols: 2 })
+expect(deepmerge).type.not.toBeCallableWith({ symbol: 2 })
+
+expect(deepmerge({ symbols: true })).type.toBeAssignableTo<Function>()
+expect(deepmerge({ symbols: true })).type.toBe<DeepMergeFn>()
+
+expect(deepmerge()('string', { a: 'string' }).a).type.toBe<string>()
+expect(deepmerge()(1, { a: 'string' }).a).type.toBe<string>()
+
+expect(deepmerge()<Object, string>({ a: 'string' }, 'string')).type.toBe<string>()
+expect(deepmerge()<Object, number>({ a: 'string' }, 1)).type.toBe<number>()
+expect(deepmerge()({ a: 'string' }, new Date())).type.toBe<Date>()
+expect(deepmerge()({ a: 'string' }, /a/g)).type.toBe<RegExp>()
+expect(deepmerge()(/a/, {})).type.toBe<{}>()
+
+expect(deepmerge()({ a: 'string' }, { a: 1 }).a).type.toBe<number>()
+expect(deepmerge()({ a: 'string' }, { b: 1 }).a).type.toBe<string>()
+expect(deepmerge()({ a: 'string' }, { }).a).type.toBe<string>()
+expect(deepmerge()({ a: 'string' }, { b: 1 }).b).type.toBe<number>()
+expect(deepmerge()({ a: { a: 'string' } }, { b: 1 }).a).type.toBe<{ a: string }>()
+expect(deepmerge()({ a: { a: 'string' } }, { a: { a: 1 } }).a).type.toBe<{ a: number }>()
+expect(deepmerge()({ a: { a: 'string' } }, { a: { a: 1, b: 'string' } }).a).type.toBe<{ a: number, b: string }>()
+expect(deepmerge()({ a: { a: { a: 'string' } } }, { a: { a: 1, b: 'string' } }).a).type.toBe<{ a: number, b: string }>()
+expect(deepmerge()({ a: { a: { a: 'string' } } }, { a: { a: { b: 'string' } } }).a).type.toBe<{ a: { a: string, b: string } }>()
+expect(deepmerge()({ a: [1, 2, 3, 4] }, { a: 'string' }).a).type.toBe<string>()
+expect(deepmerge()({ a: [1, 2, 3, 4] }, { a: [1, 2, 3, 4] }).a).type.toBe<number[]>()
+expect(deepmerge()({ a: [1, 2, 3, 4] }, { a: ['a'] }).a).type.toBe<(number | string)[]>()
+expect(deepmerge()({ a: [1, 2, 3, 4] as readonly number[] }, { a: ['a'] }).a).type.toBe<(number | string)[]>()
+expect(deepmerge()({ a: [1, 2, 3, 4] as const }, { a: ['a'] as const }).a).type.toBe<[1, 2, 3, 4, 'a']>()
+expect(deepmerge()({ a: [1] }, { a: [2] }).a).type.toBe<Array<number>>()
+expect(deepmerge()({ a: { b: {} } }, { a: { b: [2] } }).a).type.toBe<{ b: number[] }>()
+expect(deepmerge()({ a: { b: {} } }, { a: { b: new Date() } }).a).type.toBe<{ b: Date }>()
+expect(deepmerge()({ a: { b: {} } }, { a: { b: /abc/g } }).a).type.toBe<{ b: RegExp }>()
+expect(deepmerge()({ a: { b: {} } }, new Date())).type.toBe<Date>()
+expect(deepmerge()({ a: { b: {} } }, new Map())).type.toBe<Map<any, any>>()
+
+expect(deepmerge({ all: true })).type.toBeAssignableTo<Function>()
+expect(deepmerge({ all: true })).type.toBe<DeepMergeAllFn>()
+expect(deepmerge({ all: true, symbols: true })).type.toBeAssignableTo<Function>()
+expect(deepmerge({ all: true, symbols: true })).type.toBe<DeepMergeAllFn>()
+expect(deepmerge({ all: true, symbols: true })({ a: 'a' }).a).type.toBe<string>()
+expect(deepmerge({ all: true, symbols: true })({ a: 'a' }, { b: 'a' }).a).type.toBe<string>()
+expect(deepmerge({ all: true, symbols: true })({ a: 'a' }, { b: 'a' }).b).type.toBe<string>()
+expect(deepmerge({ all: true, symbols: true })({ a: 'a' }, { a: 2 }).a).type.toBe<number>()
+expect(deepmerge({ all: true, symbols: true })({ a: 'a' }, 2)).type.toBe<number>()
+expect(deepmerge({ all: true, symbols: true })({ a: 'a' }, 'string')).type.toBe<string>()
+
+expect(deepmerge).type.not.toBeCallableWith({ mergeArray: function () {} })
+expect(deepmerge).type.not.toBeCallableWith({
+  mergeArray: function () {
+    return () => 'test'
+  }
+})
+
+deepmerge({
+  mergeArray: function (options) {
+    expect(options.clone).type.toBe<(value: any) => any>()
+    const clone = options.clone
+    return function (target, source) {
+      return clone(target.concat(source))
+    }
+  }
+})
+deepmerge({
+  mergeArray: function () {
+    return function (_target, source) {
+      return source
+    }
+  }
+})
+deepmerge({
+  isMergeableObject: function (value) {
+    return true
+  }
+})
+
+expect(deepmerge.isMergeableObject).type.toBe<(value: any) => boolean>()
+
+expect(deepmerge({ onlyDefinedProperties: true })).type.toBe<DeepMergeDefinedFn>()
+expect(deepmerge({ all: true, onlyDefinedProperties: true })).type.toBe<DeepMergeAllDefinedFn>()
+
+interface FullOptions {
+  apiUrl: string
+  timeout: number
+  nested: {
+    enabled: boolean
+    value: string
+  }
+}
+
+type PartialOptions = Partial<FullOptions>
+
+const fullTarget: FullOptions = { apiUrl: 'url', timeout: 100, nested: { enabled: true, value: 'test' } }
+const partialSource: PartialOptions = { timeout: 200 }
+
+const mergedDefined = deepmerge({ onlyDefinedProperties: true })(fullTarget, partialSource)
+expect(mergedDefined.apiUrl).type.toBe<string>()
+expect(mergedDefined.timeout).type.toBe<number>()
+expect(mergedDefined.nested).type.toBe<{ enabled: boolean; value: string }>()
+
+expect(mergedDefined).type.toBeAssignableTo<FullOptions>()
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const mergedRegular = deepmerge()(fullTarget, partialSource)
+
+type DeepPartialOptions = {
+  apiUrl?: string
+  timeout?: number
+  nested?: {
+    enabled?: boolean
+    value?: string
+  }
+}
+
+const deepPartialSource: DeepPartialOptions = { nested: { enabled: false } }
+const mergedDeep = deepmerge({ onlyDefinedProperties: true })(fullTarget, deepPartialSource)
+expect(mergedDeep.apiUrl).type.toBe<string>()
+expect(mergedDeep.timeout).type.toBe<number>()
+expect(mergedDeep.nested).type.toBeAssignableTo<{ enabled: boolean; value: string }>()
+
+const mergedAll = deepmerge({ all: true, onlyDefinedProperties: true })(
+  fullTarget,
+  { timeout: 300 } as PartialOptions,
+  { apiUrl: 'newUrl' } as PartialOptions
+)
+expect(mergedAll).type.toBeAssignableTo<FullOptions>()