Equals<string, string> // "T"
Equals<string, number> // "F"

Omit<{ a: string; b: number }, 'a'> // { b: number }

Overwrite<{ a: string; b: number }, { b: boolean }> // { a: string; b: boolean }

Diff<{ a: string; b: number }, 'b'> // { a: string; b?: number }

declare function f(x: RowLacks<{ a: string; b: number }, 'a'>): void
// $ExpectError
f({ a: 'foo', b: 1 })

declare function f<T extends Exact<{ a: string }, T>>(a: T): void
declare const x: { a: string }
declare const y: { a: string; b: number }
f(x)
// $ExpectError
f(y)

KeysOfType<{a: string, b: string | boolean, c: boolean, d: string}, string> // "a" | "d"

declare function f<T extends AnyTuple>(x: T): T
declare const x: [number]
declare const y: [number, string]
declare const z: [number, string, boolean]
declare const t: Array<number>
f(x)
f(y)
f(z)
// $ExpectError
f(t)

interface Foo {
  bar: {
    baz: string
    quux: Array<{ barbaz: number }>
  }
}

type ReadonlyFoo = DeepReadonly<Foo>
declare const x: ReadonlyFoo
// $ExpectError
x.bar.quux[1].barbaz = 1

type A = { tag: 'A'; a: string }
type B = { tag: 'B'; b: number }
type C = A | B
TaggedUnionMember<C, 'tag', 'A'> // A

type A = { a: string; b: number; x?: string; y?: number }
RequiredKeys<A> // "a" | "b"
OptionalKeys<A> // "x" | "y"