// Conditional types: https://github.com/Microsoft/TypeScript/pull/21316
// Remove null and undefined from T
type NonNullableValue<T> =
  T extends null ? never :
  T extends undefined ? never :
  T

type NonNullable<T> = { [K in keyof T]: NonNullableValue<T[K]> }

type Nullable<T> = { [K in keyof T]: T[K] }

declare const ensureNonNull: <T>(value: Nullable<T>) => NonNullable<T>
declare const val: { a: number | null, b: string | undefined }
const nonNullVal: { a: number, b: string } = ensureNonNull(val)

// `infer`: https://github.com/Microsoft/TypeScript/pull/21496
type Obj<K extends string, V> = { key: K, value: V }
type ReturnSplit<AC> =
  AC extends (...args: any[]) => Obj<infer K, infer V>
    ? { [k in K]: V }
    : never

declare const func: (someParam: number) => Obj<'SomeString', Array<number>>

type T0 = ReturnSplit<typeof func>
const t0: T0 = { SomeString: [1] }

type Animals = {
  ant: { a: string },
  bat: { b: number },
  cat: { c: boolean },
}

type UnionOf<T> = T[keyof T]

type T1 = UnionOf<Animals>
// We can assign any of the values to a variable of type T1
const t1a: T1 = { a: '' }
const t1b: T1 = { b: 2 }
const t1c: T1 = { c: false }

// Thanks to these new features now we can create an intersection type
export type IntersectionOf<T> =
  ({ [K in keyof T]: (x: T[K]) => void }) extends Record<keyof T, (x: infer V) => void> ? V : never

type T2 = IntersectionOf<Animals>
const t2: T2 = { a: '', b: 3, c: true }