function throwErr(): never {
  throw new Error("an error");
}

const age = 18;

throwErr();

// Unreachable code detected.
age.toFixed(2);

// string | number
type T = string | number | never;

type Human = {
  age: number;
  name: string;
  lover: string;
  gender: 1 | 0;
};

type Filter<T> = {
  [P in {
    [K in keyof T]: K extends "age" | "name" ? K : never;
  }[keyof T]]: T[P];
};

// type T = {
//     age: number;
//     name: string;
// }
type T = Filter<Human>;

// 上面只是为了试验 never 的幺元特性 Filter可以更简单的写法
// type Filter<T, P> = {
//   [K in Extract<keyof T, P] : T[K]
// };
// Filter<Human, 'name' | 'age'>

function test(b: any) {
  if (typeof b === "string") {
    // Property 'test' does not exist on type 'string'
    b.test();
  }
}

const test = (a: string) => a.length;

const obj = {
  a: 1,
  b: false,
};

// (a: string) => number
type A = typeof test; // (x: string) => number
// {
//   a: number;
//   b: boolean;
// }
type B = typeof obj;

type Test = {
  a;
  b;
};

// 'a' | 'b'
type Res = keyof Test;

type Test = {
  a;
  b;
};

// type Res = {
//     a: string;
//     b: string;
// }
type Res = {
  [K in keyof Test]: string;
};

type Test1 = {
  a;
  b;
};
type Test2 = [1, 2];

// any
type Res1 = Test["a"];
// 2
type Res2 = Test2[1];

const $ = require('jquery')

declare module '$' {
  export function forEach(callback: () => any): void
}

单一导出函数或者常量本身

declare module 'koa' {
  function random_name(): any
  export=random_name
}

export declare var age: number
//or
declare var name: string
export { name }
// or
export default name

interface Animal<T> {
  type: T
}

const Jessica: Animal<'people'> = {
  type: 'people'
}

const Wangcai: Animal<'dog'> = {
  type: 'dog'
}

T extends U ? X : Y

interface Human {
  name: string
  age: number
  secondLanguage: string
  lover?: Human
}

const Jessica: Human = {
  name: 'jessica',
  age: 21,
  secondLanguage: 'Frence'
}

const Lucia: Human = { // Type error secondLanguage is required
  name: 'jessica',
  age: 21,
}

type TEST<T, K> = {
  [P in K]: T[P]
}

type TEST<T, K extends keyof T> = {
  [P in K]: T[P]
}

type EXCLUDE<T, U> = T extends U ? never : T;

type OMIT<T, K extends keyof T> = {
  [P in EXCLUDE<keyof T, K>]: T[P]
}

type Human_exclude = OMIT<Human, 'language'>

const Lucia: Human = { // pass
  name: 'jessica',
  age: 21,
}

1. 定义去除key所对应的可选类型

2. 定义去除指定的属性后的类型

3. 选取1和2的交叉类型

type type OPTIONAL_K<T, K extends keyof T> = {
  [P in K]?: T[P];
} &
  OMIT<T, K>;

const Lucia: Human = { // pass
  name: 'jessica',
  age: 21,
}

Lucia.luanguage = 'en' // pass

type ParamType<T> = T extends (param: infer P) => any ? P : T;

type PICK<T, K extends keyof T> = {
  [P in K]: T[P];
};

type A = PICK<Human, "age">;

type PARTIAL<T> = {
  [P in keyof T]?: T[P];
};

type F = PARTIAL<Human>;

type REQUIRED<T> = {
  [P in keyof T]-?: T[P];
};

type G = REQUIRED<Human>;

type REQUIRED_K<T, K extends keyof T> = {
  [P in K]-?: T[P];
} &
  OMIT<T, K>;

type E = REQUIRED_K<Human, "lover">;

type SIG = {
  key: {
    key: {
      key: any
    }
  }
}

type READONLY_RECURSIVE<T> = {
  readonly [P in keyof T]: T[P] extends {[index: string]: any} ? READONLY_RECURSIVE<T[P]> : T[P];
};


const test: READONLY_RECURSIVE<SIG> = {
  key: {
    key: {
      key: 123
    }
  }
}

test.key.key = 123 // err: Cannot assign to 'key' because it is a read-only property.ts(2540)

type RETURN<T extends () => any> = T extends () => infer R ? R : never;

type CONSTRUCTOR_P<T extends new (...args: any[]) => any> = T extends new (
  ...args: infer P
) => any
  ? P
  : any[];

function bark() {
  return "string";
}

type Eat = () => number;

type BarkReturn = RETURN<typeof bark>; // string
type EatReturn = RETURN<Eat>; // number

class HumanBeing {
  constructor(name: string, age: number) {}
}

type HB = CONSTRUCTOR_P<typeof HumanBeing>; // [string, number]

type PROMISE_LIKE<T = any> = {
  then<T1 = T, T2 = never>(
    resolve?: (value?: T) => T1 | PROMISE_LIKE<T1> | undefined | null,
    reject?: (value?: any) => T2 | PROMISE_LIKE<T2> | undefined | null
  ): PROMISE_LIKE<T1 | T2>;
};

type PROMISE<T = any> = {
  then<T1 = T, T2 = never>(
    resolve?: (value?: T) => T1 | PROMISE_LIKE<T1> | undefined | null,
    reject?: (value?: any) => T2 | PROMISE_LIKE<T2> | undefined | null
  ): PROMISE_LIKE<T1 | T2>;

  catch<T1 = never>(value?: any): T1 | PROMISE_LIKE<T1> | undefined | null;
};

interface PromiseLike<T> {
/**
 * Attaches callbacks for the resolution and/or rejection of the Promise.
 * @param onfulfilled The callback to execute when the Promise is resolved.
 * @param onrejected The callback to execute when the Promise is rejected.
 * @returns A Promise for the completion of which ever callback is executed.
 */
  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
}

/**
 * Represents the completion of an asynchronous operation
 */
interface Promise<T> {
/**
 * Attaches callbacks for the resolution and/or rejection of the Promise.
 * @param onfulfilled The callback to execute when the Promise is resolved.
 * @param onrejected The callback to execute when the Promise is rejected.
 * @returns A Promise for the completion of which ever callback is executed.
 */
  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

/**
 * Attaches a callback for only the rejection of the Promise.
 * @param onrejected The callback to execute when the Promise is rejected.
 * @returns A Promise for the completion of the callback.
 */
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
}

type Partial<T> = {
    [P in keyof T]?: T[P];
};

/**
 * Make all properties in T required
 */
type Required<T> = {
    [P in keyof T]-?: T[P];
};

/**
 * Make all properties in T readonly
 */
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

/**
 * From T, pick a set of properties whose keys are in the union K
 */
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

/**
 * Construct a type with a set of properties K of type T
 */
type Record<K extends keyof any, T> = {
    [P in K]: T;
};

/**
 * Exclude from T those types that are assignable to U
 */
type Exclude<T, U> = T extends U ? never : T;

/**
 * Extract from T those types that are assignable to U
 */
type Extract<T, U> = T extends U ? T : never;

/**
 * Construct a type with the properties of T except for those in type K.
 */
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

/**
 * Exclude null and undefined from T
 */
type NonNullable<T> = T extends null | undefined ? never : T;

/**
 * Obtain the parameters of a function type in a tuple
 */
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

/**
 * Obtain the parameters of a constructor function type in a tuple
 */
type ConstructorParameters<T extends new (...args: any) => any> = T extends new (...args: infer P) => any ? P : never;

/**
 * Obtain the return type of a function type
 */
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

/**
 * Obtain the return type of a constructor function type
 */
type InstanceType<T extends new (...args: any) => any> = T extends new (...args: any) => infer R ? R : any;

interface Action<T> {
  payload?: T;
  type: string;
}

class EffectModule {
  count = 1;
  message = "hello!";

  delay(input: Promise<number>) {
    return input.then(i => ({
      payload: `hello ${i}!`,
      type: 'delay'
    }));
  }

  setMessage(action: Action<Date>) {
    return {
      payload: action.payload!.getMilliseconds(),
      type: "set-message"
    };
  }
}

type Result {
  delay<T, U>(input: T): Action<U>;
  setMessage<T, U>(action: T): Action<U>;
}