• fix for tsgo (+ test in CI) (#156) 7d6fa42
• Update jsdoc (#154) 0c9d8c2
• Update TypeScript and add it to test matrix (#151) 7ff4f4d
• Create SECURITY.md 1149186

v1.2.1...v1.2.2

• docs: update deprecated usage examples 0c5a05d

v1.2.0...v1.2.1

What's Changed

• .map fn by @mmkal in #98
• toMatchObjectType + toExtend - replacements for toMatchTypeOf by @mmkal in #126

❗ toMatchTypeOf is now deprecated. There are no plans to remove it any time soon, so it's not critical to immediately remove usages, but if you want to avoid squigglies in IDEs complaining about deprecations, here's what you should do:

If you have an assertion like this:

expectTypeOf(foo).toMatchTypeOf<Abc>()

There are a few options for upgrading it. The easiest is toExtend which is identical to the behaviour of toMatchTypeOf:

expectTypeOf(foo).toExtend<Abc>()

This will work in all cases. But, there is now a stricter option that will work in many cases and be slightly more likely to catch things like readonly properties matching:

expectTypeOf(foo).toMatchObjectType<Abc>()

But, as the name suggests, this will only work on plain object types, it will fail for union types, and some other complex types.

If you have code like this:

expectTypeOf(foo).toMatchTypeOf(bar)

You'll need to use typeof because toExtend and toMatchObjectType do not accept arguments

expectTypeOf(foo).toExtend<typeof bar>()
expectTypeOf(foo).toMatchObjectType<typeof bar>()

Full Changelog: v1.1.0...v1.2.0

What's Changed

• Add .toBeBigInt() by @aryaemami59 in #123
• [ci] try artifact.ci by @mmkal in #124
• bigint printtype by @mmkal in #125

Full Changelog: v1.0.0...v1.1.0

v1! 🎉🎉🎉

After many years being commitment-phobic, expect-type is now in v1.

This release does not add any user facing features on top of v0.20.0 or v1.0.0-rc.0. It's just "making it official". For anyone new to the project, or coming here from vitest or viteconf (👋 ), the usage docs from the readme are pasted below.

For anyone on an old-ish v0 version, here are links to the non-trivial changes that have gone in since v0.15.0:

• v0.20.0: Function overloads support (proper support, beyond the default typescript functionality which eliminates all but one overloads by default)
• v0.19.0: Beefed up JSDocs thanks to @aryaemami59
• v0.18.0: .pick and .omit thanks to @aryaemami59
• v0.17.0: massively improved error messages, so (in most cases) when an assertion fails you can see what's wrong, not just that something is wrong
• v0.16.0: default to internal typescript implementation of type-identicalness. Introduce the .branded helper for the old behaviour. Also support function this parameters - thank to @trevorade and @papb

Full usage docs below, for newbies (head to the readme to keep up to date):

Installation and usage

npm install expect-type --save-dev

import {expectTypeOf} from 'expect-type'

Documentation

The expectTypeOf method takes a single argument or a generic type parameter. Neither it nor the functions chained off its return value have any meaningful runtime behaviour. The assertions you write will be compile-time errors if they don't hold true.

Features

Check an object's type with .toEqualTypeOf:

expectTypeOf({a: 1}).toEqualTypeOf<{a: number}>()

.toEqualTypeOf can check that two concrete objects have equivalent types (note: when these assertions fail, the error messages can be less informative vs the generic type argument syntax above - see error messages docs):

expectTypeOf({a: 1}).toEqualTypeOf({a: 1})

.toEqualTypeOf succeeds for objects with different values, but the same type:

expectTypeOf({a: 1}).toEqualTypeOf({a: 2})

.toEqualTypeOf fails on excess properties:

// @ts-expect-error
expectTypeOf({a: 1, b: 1}).toEqualTypeOf<{a: number}>()

To allow for extra properties, use .toMatchTypeOf. This is roughly equivalent to an extends constraint in a function type argument.:

expectTypeOf({a: 1, b: 1}).toMatchTypeOf<{a: number}>()

.toEqualTypeOf and .toMatchTypeOf both fail on missing properties:

// @ts-expect-error
expectTypeOf({a: 1}).toEqualTypeOf<{a: number; b: number}>()
// @ts-expect-error
expectTypeOf({a: 1}).toMatchTypeOf<{a: number; b: number}>()

Another example of the difference between .toMatchTypeOf and .toEqualTypeOf, using generics. .toMatchTypeOf can be used for "is-a" relationships:

type Fruit = {type: 'Fruit'; edible: boolean}
type Apple = {type: 'Fruit'; name: 'Apple'; edible: true}

expectTypeOf<Apple>().toMatchTypeOf<Fruit>()

// @ts-expect-error
expectTypeOf<Fruit>().toMatchTypeOf<Apple>()

// @ts-expect-error
expectTypeOf<Apple>().toEqualTypeOf<Fruit>()

Assertions can be inverted with .not:

expectTypeOf({a: 1}).not.toMatchTypeOf({b: 1})

.not can be easier than relying on // @ts-expect-error:

type Fruit = {type: 'Fruit'; edible: boolean}
type Apple = {type: 'Fruit'; name: 'Apple'; edible: true}

expectTypeOf<Apple>().toMatchTypeOf<Fruit>()

expectTypeOf<Fruit>().not.toMatchTypeOf<Apple>()
expectTypeOf<Apple>().not.toEqualTypeOf<Fruit>()

Catch any/unknown/never types:

expectTypeOf<unknown>().toBeUnknown()
expectTypeOf<any>().toBeAny()
expectTypeOf<never>().toBeNever()

// @ts-expect-error
expectTypeOf<never>().toBeNumber()

.toEqualTypeOf distinguishes between deeply-nested any and unknown properties:

expectTypeOf<{deeply: {nested: any}}>().not.toEqualTypeOf<{deeply: {nested: unknown}}>()

You can test for basic JavaScript types:

expectTypeOf(() => 1).toBeFunction()
expectTypeOf({}).toBeObject()
expectTypeOf([]).toBeArray()
expectTypeOf('').toBeString()
expectTypeOf(1).toBeNumber()
expectTypeOf(true).toBeBoolean()
expectTypeOf(() => {}).returns.toBeVoid()
expectTypeOf(Promise.resolve(123)).resolves.toBeNumber()
expectTypeOf(Symbol(1)).toBeSymbol()

.toBe... methods allow for types that extend the expected type:

expectTypeOf<number>().toBeNumber()
expectTypeOf<1>().toBeNumber()

expectTypeOf<any[]>().toBeArray()
expectTypeOf<number[]>().toBeArray()

expectTypeOf<string>().toBeString()
expectTypeOf<'foo'>().toBeString()

expectTypeOf<boolean>().toBeBoolean()
expectTypeOf<true>().toBeBoolean()

.toBe... methods protect against any:

const goodIntParser = (s: string) => Number.parseInt(s, 10)
const badIntParser = (s: string) => JSON.parse(s) // uh-oh - works at runtime if the input is a number, but return 'any'

expectTypeOf(goodIntParser).returns.toBeNumber()
// @ts-expect-error - if you write a test like this, `.toBeNumber()` will let you know your implementation returns `any`.
expectTypeOf(badIntParser).returns.toBeNumber()

Nullable types:

expectTypeOf(undefined).toBeUndefined()
expectTypeOf(undefined).toBeNullable()
expectTypeOf(undefined).not.toBeNull()

expectTypeOf(null).toBeNull()
expectTypeOf(null).toBeNullable()
expectTypeOf(null).not.toBeUndefined()

expectTypeOf<1 | undefined>().toBeNullable()
expectTypeOf<1 | null>().toBeNullable()
expectTypeOf<1 | undefined | null>().toBeNullable()

More .not examples:

expectTypeOf(1).not.toBeUnknown()
expectTypeOf(1).not.toBeAny()
expectTypeOf(1).not.toBeNever()
expectTypeOf(1).not.toBeNull()
expectTypeOf(1).not.toBeUndefined()
expectTypeOf(1).not.toBeNullable()

Detect assignability of unioned types:

expectTypeOf<number>().toMatchTypeOf<string | number>()
expectTypeOf<string | number>().not.toMatchTypeOf<number>()

Use .extract and .exclude to narrow down complex union types:

type ResponsiveProp<T> = T | T[] | {xs?: T; sm?: T; md?: T}
const getResponsiveProp = <T>(_props: T): ResponsiveProp<T> => ({})
type CSSProperties = {margin?: string; padding?: string}

const cssProperties: CSSProperties = {margin: '1px', padding: '2px'}

expectTypeOf(getResponsiveProp(cssProperties))
  .exclude<unknown[]>()
  .exclude<{xs?: unknown}>()
  .toEqualTypeOf<CSSProperties>()

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<unknown[]>()
  .toEqualTypeOf<CSSProperties[]>()

expectTypeOf(getResponsiveProp(cssProperties))
  .extract<{xs?: any}>()
  .toEqualTypeOf<{xs?: CSSProperties; sm?: CSSProperties; md?: CSSProperties}>()

expectTypeOf<ResponsiveProp<number>>().exclude<number | number[]>().toHaveProperty('sm')
expectTypeOf<ResponsiveProp<number>>().exclude<number | number[]>().not.toHaveProperty('xxl')

.extract and .exclude return never if no types remain after exclusion:

type Person = {name: string; age: number}
type Customer = Person & {customerId: string}
type Employee = Person & {employeeId: string}

expectTypeOf<Customer | Employee>().extract<{foo: string}>().toBeNever()
expectTypeOf<Customer | Employee>().exclude<{name: string}>().toBeNever()

Use .pick to pick a set of properties from an object:

type Person = {name: string; age: number}

expectTypeOf<Person>().pick<'name'>().toEqualTypeOf<{name: string}>()

Use .omit to remove a set of properties from an object:

type Person = {name: string; age: number}

expectTypeOf<Person>().omit<'name'>().toEqualTypeOf<{age: number}>()

Make assertions about object properties:

const obj = {a: 1, b: ''}

// check that properties exist (or don't) with `.toHaveProperty`
expectTypeOf(obj).toHaveProperty('a')
expectTypeOf(obj).not.toHaveProperty('c')

// check types of properties
expectTypeOf(obj).toHaveProperty('a').toBeNumber()
expectTypeOf(obj).toHaveProperty('b').toBeString()
expectTypeOf(obj).toHaveProperty('a').not.toBeString()

.toEqualTypeOf can be used to distinguish between functions:

type NoParam = () => void
type HasParam = (s: string) => void

expectTypeOf<NoParam>().not.toEqualTypeOf<HasParam>()

But often it's preferable to use .parameters or .returns for more specific function assertions:

type NoParam = () => void
type HasParam = (s: string) => void

expectTypeOf<NoParam>().parameters.toEqualTypeOf<[]>()
expectTypeOf<NoParam>().returns.toBeVoid()

expectTypeOf<HasParam>().parameters.toEqualTypeOf<[string]>()
expectTypeOf<HasParam>().returns.toBeVoid()

Up to ten overloads will produce union types for .parameters and .returns:

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}

expectTypeOf<Factorize>().parameters.toEqualTypeOf<[number] | [bigint]>()
expectTypeOf<Factorize>().returns.toEqualTypeOf<number[] | bigint[]>()

expectTypeOf<Factorize>().parameter(0).toEqualTypeOf<number | bigint>()

Note that these aren't exactly like TypeScript's built-in Parameters<...> and ReturnType<...>:

The TypeScript builtins simply choose a single overload (see the Overloaded functions section for more information)

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}

// overload using `number` is ignored!
expectTypeOf<Parameters<Factorize>>().toEqualTypeOf<[bigint]>()
expectTypeOf<ReturnType<Factorize>>().toEqualTypeOf<bigint[]>()

More examples of ways to work with functions - parameters using .parameter(n) or .parameters, and return values using .returns:

const f = (a: number) => [a, a]

expectTypeOf(f).toBeFunction()

expectTypeOf(f).toBeCallableWith(1)
expectTypeOf(f).not.toBeAny()
expectTypeOf(f).returns.not.toBeAny()
expectTypeOf(f).returns.toEqualTypeOf([1, 2])
expectTypeOf(f).returns.toEqualTypeOf([1, 2, 3])
expectTypeOf(f).parameter(0).not.toEqualTypeOf('1')
expectTypeOf(f).parameter(0).toEqualTypeOf(1)
expectTypeOf(1).parameter(0).toBeNever()

const twoArgFunc = (a: number, b: string) => ({a, b})

expectTypeOf(twoArgFunc).parameters.toEqualTypeOf<[number, string]>()

.toBeCallableWith allows for overloads. You can also use it to narrow down the return type for given input parameters.:

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}

expectTypeOf<Factorize>().toBeCallableWith(6)
expectTypeOf<Factorize>().toBeCallableWith(6n)

.toBeCallableWith returns a type that can be used to narrow down the return type for given input parameters.:

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}
expectTypeOf<Factorize>().toBeCallableWith(6).returns.toEqualTypeOf<number[]>()
expectTypeOf<Factorize>().toBeCallableWith(6n).returns.toEqualTypeOf<bigint[]>()

.toBeCallableWith can be used to narrow down the parameters of a function:

type Delete = {
  (path: string): void
  (paths: string[], options?: {force: boolean}): void
}

expectTypeOf<Delete>().toBeCallableWith('abc').parameters.toEqualTypeOf<[string]>()
expectTypeOf<Delete>()
  .toBeCallableWith(['abc', 'def'], {force: true})
  .parameters.toEqualTypeOf<[string[], {force: boolean}?]>()

expectTypeOf<Delete>().toBeCallableWith('abc').parameter(0).toBeString()
expectTypeOf<Delete>().toBeCallableWith('abc').parameter(1).toBeUndefined()

expectTypeOf<Delete>()
  .toBeCallableWith(['abc', 'def', 'ghi'])
  .parameter(0)
  .toEqualTypeOf<string[]>()

expectTypeOf<Delete>()
  .toBeCallableWith(['abc', 'def', 'ghi'])
  .parameter(1)
  .toEqualTypeOf<{force: boolean} | undefined>()

You can't use .toBeCallableWith with .not - you need to use ts-expect-error::

const f = (a: number) => [a, a]

// @ts-expect-error
expectTypeOf(f).toBeCallableWith('foo')

You can also check type guards & type assertions:

Note truncated.

1.0.0 release candidate

No changes other than dev dependency updates since v0.20.0: https://github.com/mmkal/expect-type/releases/tag/v0.20.0

The intent is to publish a 1.0.0 as-is, since this is used in vitest already.

Breaking changes

• improve overloads support, attempt 2 by @mmkal in #83

This change updates how overloaded functions are treated. Now, .parameters gives you a union of the parameter-tuples that a function can take. For example, given the following type:

type Factorize = {
  (input: number): number[]
  (input: bigint): bigint[]
}

Behvaiour before:

expectTypeOf<Factorize>().parameters.toEqualTypeOf<[bigint]>()

Behaviour now:

expectTypeOf<Factorize>().parameters.toEqualTypeOf<[number] | [bigint]>()

There were similar changes for .returns, .parameter(...), and .toBeCallableWith. Also, overloaded functions are now differentiated properly when using .branded.toEqualTypeOf (this was a bug that it seems nobody found).

See #83 for more details or look at the updated docs (including a new section called "Overloaded functions", which has more info on how this behaviour differs for TypeScript versions before 5.3).

What's Changed

• Fix rendering issue in readme by @mrazauskas in #69
• Fix minor issues in docs by @aryaemami59 in #91
• create utils file by @mmkal in #93
• branding.ts and messages.ts by @mmkal in #95
• improve overloads support, attempt 2 by @mmkal in #83
• Extends: explain myself 1e37116
• Mark internal APIs with @internal JSDoc tag (#104) 4c40b07
• Re-export everything in overloads.ts file (#107) 5ee0181
• JSDoc improvements (#100) 0bbeffa

Full Changelog: v0.19.0...v0.20.0

What's Changed

• Fix .omit() to work similarly to Omit by @aryaemami59 in https://github.com/mmkal/expect-type/pull/54
• Add JSDocs to everything by @aryaemami59 in https://github.com/mmkal/expect-type/pull/56
• Remove test import in README.md by @aryaemami59 in https://github.com/mmkal/expect-type/pull/65

Full Changelog: https://github.com/mmkal/expect-type/compare/0.18.0...0.19.0

What's Changed

• Add .pick and .omit by @aryaemami59 in https://github.com/mmkal/expect-type/pull/51

New Contributors

• @aryaemami59 made their first contribution in https://github.com/mmkal/expect-type/pull/51

Full Changelog: https://github.com/mmkal/expect-type/compare/v0.17.3...0.18.0

• docs: why-is-my-assertion-failing 907b8aa
• I think the previous build was out of date somehow too, so see https://github.com/mmkal/expect-type/releases/v0.17.2

https://github.com/mmkal/expect-type/compare/v0.17.3-0...v0.17.3

• Improve tuple errors (#40) 4b38117

Diff(truncated - scroll right!):

test('toEqualTypeOf with tuples', () => {
  const assertion = `expectTypeOf<[[number], [1], []]>().toEqualTypeOf<[[number], [2], []]>()`
  expect(tsErrors(assertion)).toMatchInlineSnapshot(`
-    "test/test.ts:999:999 - error TS2344: Type '[[number], [2], []]' does not satisfy the constraint '{ [x: number]: { [x: number]: number; [iterator]: (() => IterableIterator<1>) | (() => IterableIterator<number>) | (() => IterableIterator<never>); [unscopables]: (() => { copyWithin: boolean; entries: boolean; fill: boolean; find: boolean; findIndex: boolean; keys: boolean; values: boolean; }) | (() => { copyWithin: boolean; entries: boolean; fill: boolean; find: boolean; findIndex: boolean; keys: boolean; values: boolean; }) | (() => { copyWithin: boolean; entries: boolean; fill: boolean; find: boolean; findIndex: boolean; keys: boolean; values: boolean; }); length: 0 | 1; toString:  ... truncated!!!!'.
-      Types of property 'sort' are incompatible.
-        Type '(compareFn?: ((a: [] | [number] | [2], b: [] | [number] | [2]) => number) | undefined) => [[number], [2], []]' is not assignable to type '\\"Expected: function, Actual: function\\"'.
+    "test/test.ts:999:999 - error TS2344: Type '[[number], [2], []]' does not satisfy the constraint '{ 0: { 0: number; }; 1: { 0: \\"Expected: literal number: 2, Actual: literal number: 1\\"; }; 2: {}; }'.
+      The types of '1[0]' are incompatible between these types.
+        Type '2' is not assignable to type '\\"Expected: literal number: 2, Actual: literal number: 1\\"'.
    999 expectTypeOf<[[number], [1], []]>().toEqualTypeOf<[[number], [2], []]>()
                                                          ~~~~~~~~~~~~~~~~~~~"
  `)
})

https://github.com/mmkal/expect-type/compare/v0.17.1...v0.17.2

• disallow .not and .branded together cf38918

(this was actually documented in the v0.17.0 release but really it was only pushed here)

https://github.com/mmkal/expect-type/compare/v0.17.0...v0.17.1

#16 went in to - hopefully - significantly improve the error messages produce on failing assertions. Here's an example of how vitest's failing tests were improved:

Before:

<img width="551" alt="image" src="https://github.com/vitest-dev/vitest/assets/15040698/3bfea594-14b5-4919-9dac-4a562e603d59">

After:

<img width="672" alt="image" src="https://github.com/vitest-dev/vitest/assets/15040698/ca106058-178b-401e-be26-6f08ae628fd4">

Docs copied from the readme about how to interpret these error messages

Error messages

When types don't match, .toEqualTypeOf and .toMatchTypeOf use a special helper type to produce error messages that are as actionable as possible. But there's a bit of an nuance to understanding them. Since the assertions are written "fluently", the failure should be on the "expected" type, not the "actual" type (expect<Actual>().toEqualTypeOf<Expected>()). This means that type errors can be a little confusing - so this library produces a MismatchInfo type to try to make explicit what the expectation is. For example:

expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

Is an assertion that will fail, since {a: 1} has type {a: number} and not {a: string}. The error message in this case will read something like this:

test/test.ts:999:999 - error TS2344: Type '{ a: string; }' does not satisfy the constraint '{ a: \\"Expected: string, Actual: number\\"; }'.
  Types of property 'a' are incompatible.
    Type 'string' is not assignable to type '\\"Expected: string, Actual: number\\"'.

999 expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

Note that the type constraint reported is a human-readable messaging specifying both the "expected" and "actual" types. Rather than taking the sentence Types of property 'a' are incompatible // Type 'string' is not assignable to type "Expected: string, Actual: number" literally - just look at the property name ('a') and the message: Expected: string, Actual: number. This will tell you what's wrong, in most cases. Extremely complex types will of course be more effort to debug, and may require some experimentation. Please raise an issue if the error messages are actually misleading.

The toBe... methods (like toBeString, toBeNumber, toBeVoid etc.) fail by resolving to a non-callable type when the Actual type under test doesn't match up. For example, the failure for an assertion like expectTypeOf(1).toBeString() will look something like this:

test/test.ts:999:999 - error TS2349: This expression is not callable.
  Type 'ExpectString<number>' has no call signatures.

999 expectTypeOf(1).toBeString()
                    ~~~~~~~~~~

The This expression is not callable part isn't all that helpful - the meaningful error is the next line, Type 'ExpectString<number> has no call signatures. This essentially means you passed a number but asserted it should be a string.

If TypeScript added support for "throw" types these error messagess could be improved. Until then they will take a certain amount of squinting.

Concrete "expected" objects vs typeargs

Error messages for an assertion like this:

expectTypeOf({a: 1}).toEqualTypeOf({a: ''})

Will be less helpful than for an assertion like this:

expectTypeOf({a: 1}).toEqualTypeOf<{a: string}>()

This is because the TypeScript compiler needs to infer the typearg for the .toEqualTypeOf({a: ''}) style, and this library can only mark it as a failure by comparing it against a generic Mismatch type. So, where possible, use a typearg rather than a concrete type for .toEqualTypeOf and toMatchTypeOf. If it's much more convenient to compare two concrete types, you can use typeof:

const one = valueFromFunctionOne({some: {complex: inputs}})
const two = valueFromFunctionTwo({some: {other: inputs}})

expectTypeOf(one).toEqualTypeof<typeof two>()

Kinda-breaking changes: essentially none, but technically, .branded no longer returns a "full" ExpectTypeOf instance at compile-time. Previously you could do this:

expectTypeOf<{a: {b: 1} & {c: 1}}>().branded.not.toEqualTypeOf<{a: {b: 1; c: ''}}>()
expectTypeOf<{a: {b: 1} & {c: 1}}>().not.branded.toEqualTypeOf<{a: {b: 1; c: ''}}>()

Now that won't work (and it was always slightly nonsensical), so you'd have to use // @ts-expect-error instead of not if you have a negated case where you need branded:

// @ts-expect-error
expectTypeOf<{a: {b: 1} & {c: 1}}>().branded.not.toEqualTypeOf<{a: {b: 1; c: ''}}>()

What's Changed

• Improve CLI error messages by @mmkal in https://github.com/mmkal/expect-type/pull/16
• expect-type is usually a dev dependency by @SerkanSipahi in https://github.com/mmkal/expect-type/pull/39

New Contributors

• @SerkanSipahi made their first contribution in https://github.com/mmkal/expect-type/pull/39

Full Changelog: https://github.com/mmkal/expect-type/compare/v0.16.0...v0.17.0

What's Changed

• support functions with this parameters by @mmkal and @papb in https://github.com/mmkal/expect-type/pull/15
• Prevent the .not modifier from being chained by @trevorade in https://github.com/mmkal/expect-type/pull/20
• Rewrite Equal to use the equality check from ReadonlyEquivalent exclusively by @trevorade in https://github.com/mmkal/expect-type/pull/21

Note that #21 has affected behavior for intersection types, which can result in (arguably) false errors:

// @ts-expect-error the following line doesn't compile, even though the types are arguably the same.
// See https://github.com/mmkal/expect-type/pull/21
expectTypeOf<{a: 1} & {b: 2}>().toEqualTypeOf<{a: 1; b: 2}>()

Full Changelog: https://github.com/mmkal/expect-type/compare/v0.15.0...v16.0.0

What's Changed

• Update Extends to not distribute over union types by @trevorade in https://github.com/mmkal/expect-type/pull/12

New Contributors

• @trevorade made their first contribution in https://github.com/mmkal/expect-type/pull/12

Full Changelog: https://github.com/mmkal/expect-type/compare/v0.14.2...v0.15.0

• update homepage in package.json c29243d

https://github.com/mmkal/expect-type/compare/v0.14.1...v0.14.2

Pure docs update

• Mention https://github.com/SamVerschueren/tsd/issues/142 cd3b522
• lint markdown 026a117
• add badges 929558d
• Create ci.yml d9eecdf

https://github.com/mmkal/expect-type/compare/v0.14.0...v0.14.1

• minor release from this repo
• previously release from mmkal/ts repo: https://github.com/mmkal/ts/releases/tag/expect-type_v0.13.0 - follow the breadcrumbs from there if interested!

https://github.com/mmkal/expect-type/compare/v0.14.0-0...v0.14.0