interface Foo {
    bar?: string;
    baz?: number;
}

type PartialFoo = Partial<Foo>;

type User = {
  surname: string;
  middleName?: string;
  givenName: string;
  age: number;
  address?: string;
  nationality: string;
  createdAt: string;
  updatedAt: string;
};
 
function findUsers(
  surname?: string,
  middleName?: string,
  givenName?: string,
  age?: number,
  address?: string,
  nationality?: string
) {
  // ...
}

 findUsers(undefined, undefined, undefined, 22);　// 年齢以降がundefinedなら省略可

type FindUsersArgs = Partial<User>;

function findUsers({
  surname,
  middleName,
  givenName,
  age,
  address,
  nationality,
}: FindUsersArgs) {
  // ...
}

function findUsers({
  surname,
  middleName,
  givenName,
  age,
  address,
  nationality,
}: FindUsersArgs = {}) {
  // ...
}

findUsers({ age: 22 });

type RequireA = Required<Foo>;

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

type Picked = Pick<Foo, "name">

type Book = {
  id: number;
  title: string;
  author: string;
  createdAt: Date;
  updatedAt: Date;
};

type BookInputData = {
  title: string;
  author: string;
};

type Book = {
  id: number;
  title: string;
  author: Person;  // ここ
  createdAt: Date;
  updatedAt: Date;
};

type BookInputData = {
  title: string;
  author: Person; // ここ
};

type BookInputData = Pick<Book, "title" | "author">;

type Omited = Omit<Foo, "age">;

{ name: string, age: number }

const str = "text";　// text型として扱われる

interface Part {
  name: string;
  age: number;
  add(): number;
}

type MethodNames<T> = {
  [K in keyof T]: T[K] extends Function ? K : never;
}[keyof T];

type PartMethodNames = MethodNames<Part>; // "add"

MethodNames<Part> 

type MethodNames<T> = {

[K in keyof T]

T[K] extends Function　? K : never;

[keyof T]

  name
  age
  add()

never | never| add //  never は無視される

type Foo = { a: number; b: string; c: boolean };
type T = Foo[keyof Foo];  // type T = string | number | boolean

function throwError(): never {
  throw new Error();
}

function forever(): never {
  while (true) {} // 無限ループ
}

function fail(message: string): never { throw new Error(message); }

const ok: void = undefined;
const ng: never = undefined;

type Func = () => number;
type Result = ReturnType<Func>;  // Result は number 型になります

type ResolvedType<T> =
T extends Promise<infer R> ? R :
T extends Observable<infer R> ? R :
T;

type ResolvedType<T> =
  Tがプロミス型のとき ? プロミス型を返す : そうでなければAの内容;

// Aの内容
  (TがObservable型のとき ? Observable型を返す :
  Tを返す)

T extends Promise<infer R> ? R :

type PropNullable<T> = {[P in keyof T]: T[P] | null};

interface User { name: string, age: number, money: null }

const obj:PropNullable<User> = { name: "kenji", age: 99, money: null }

type PropNullable<T> = {[P in keyof T]: T[P] | null};

let arr = <T extends any[]>(...rest: T) => {
   return rest
}

// 型推論によってリテラル型を変数に代入した際にプリミティブ型に拡張されること
// 例えば、

let a = "a" //string

// constでは再代入はできないので`a`型というリテラル型になるが、letは再代入可能なので推論は拡張されプリミティブ型になる

let a: "a" = "a" //"a"

// このように型注釈をつけることでa型というリテラル型になる(型注釈はwideningより優先される)

if (typeof value === "number") {
    // valueはここではnumber型として絞り込まれる
    console.log(value.toFixed(2));
}

function func(value: number | null | undefined) {
  // value が null または undefined でない場合に絞り込まれる
  const result = value ?? 0;
  // result は引数に与えられた数値または 0
  console.log(result.toFixed(2));
}

function isString(value: any): value is string {
    return typeof value === "string";
}

let input: string | number = "Hello";

if (isString(input)) {
    // inputはここではstring型として絞り込まれる
    console.log(input.length);
}

function getStringOrUndefined(condition: boolean): string | undefined {
    if (condition) {
        return "Hello";
    }
    // ここではreturn文がないため、undefinedが暗黙的に返される
}

function logMessage(message: string): void {
    console.log(message);
    // return文がなくても、void型の関数
}

type Func = (arg: number) => number;

const double: Func = function(num) {
  // 引数 num の型は number 型と推論されている
  return num * 2;
};

type Func = (arg: number) => number;

const double: Func =

(_num: number) => { // ok, _ pre
  return "return";
}

// tslint:disable-next-line: no-unused-variable
(num: number) => { // ok, _ pre
  return "return";
}

function eachItem(val: number | string, i: number) {
    // valがnumber型の場合のみtoExponentialを呼び出す
    if (typeof val === "number") {
        return val.toExponential(3);
    }
    // valがstring型の場合はそのまま返す
    return val;
}

const arr = [4, "fafa", 6];
const result = arr.map(eachItem);
console.log(result); // 結果: [ '4e+0', 'fafa', '6e+0' ]

interface Fun {(e: number): number;}

function fa(callback:Fun, e: number){
  return callback(e);
}
const fun:Fun = (e) => 1 * e;
const v = fa(fun, 1);

let arr: (string | null)[] = []

const E:Record<keyof F, string> = { foo: "fafa", bar: "fafa"}

type Grade = "A" | "B" | "C" | "D" | "E";
type PassGrade = Exclude<Grade, "E">;
type PassGrade = "A" | "B" | "C" | "D";

export defaut function person({ detail = {} as Detail} : Person) {
  return <div>{detail.name}</div>
};

 export default function person({ detail = { name: '' } } : Person) {
  return <div>{detail.name}</div>
};

interface Person {
  id: number;
  detail?: Detail;
}

interface State {
  name?: string;
  age?: number;
}

function a(o: ServiceUser | User | AppUser){
  if("serviceID" in o) return o.serviceID;
  if("appID" in o) return o.appID;
  return o.id;
}

const result = a(serviceUser) // string

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

const person: Person = {
  name: 'yamada',
  old: 22,
};

console.log('name' in person); // true
console.log('xxx' in person); // false

const isService = (o: any): o is ServiceUser => {
    return o.serviceID === "serviceID";
}
const isAppUser = (o: any): o is AppUser => {
    return o.AppUser === "appUser";
}

type O = ServiceUser | User | AppUser;
function a(o: any){
    if(isService(o)) return o.serviceID;
    if(isAppUser(o)) return o.appID;
    return o.id; // User
}
const result = a(serviceUser)

const getDefaultProps = () => {
    return {name: "hoge"}
}
const defaultProps = getDefaultProps();
const o = {name: "hoge"}
function a(o = defaultProps){
    return o
}

a(o)
a();

const b = (b: NotHumman) => {
    if ("run" in b) { // animalであることが確定する
        b.run
    } else {
        b.fly
    }
}

declare function beforeAll(action: (arg: any) => void, timeout?: number): void;

declare function fn(x: HTMLDivElement): string;
declare function fn(x: HTMLElement): number;
declare function fn(x: any): any;

var myElem: HTMLDivElement;
var x = fn(myElem); // x: string, :)

interface Example {
  diff(one: string, two?: string, three?: boolean): number;
}

let reverseAny = function(y: any): any {
  // yは任意の型であるため、型に関する情報が失われています。
  // ここにyに対する操作を書くことができますが、型安全ではありません。
  return y;
};

let result1 = reverseAny("Hello"); // result1はany型
let result2 = reverseAny(123);     // result2もany型

let reverseGeneric = function<U>(y: U): U {
  // yはU型です。この型はこの関数が呼び出される際に決定されます。
  // yに対する操作は型Uに適合する必要があります。
  return y;
};

let result1 = reverseGeneric("Hello"); // result1はstring型
let result2 = reverseGeneric(123);     // result2はnumber型

type StrFunc = (arg: string) => string;
type NumFunc = (arg: number) => string;
type StrOrNumFunc = <T>(arg: T) => string

declare const obj: StrOrNumFunc
obj("fa");

// or

(obj as StrFunc)("fa"); // unnn...

interface MyObj {
  name: string;
  age?: number | undefined;
}

declare var console: Console;

interface Foo {
  name: string;
+   [other: string]: any; //here
}

interface Example {
  prop: string;
}

const obj: Example = { prop: "Hello" };

// この場合、propValの型はstringです。
const propVal = obj.prop; // 通常はstring型

// 存在しないプロパティにアクセスしても、コンパイラはエラーを報告しません。
const nonExistent = obj.nonExistent; // これはエラーにならない。

interface Example {
  prop: string;
}

const obj: Example = { prop: "Hello" };

// この場合、propValの型はstring | undefinedです。
const propVal = obj.prop; // string | undefined型

// 存在しないプロパティにアクセスすると、コンパイラはエラーを報告します。
const nonExistent = obj.nonExistent; // これはエラーになる。

let foo:{ [index: string]: { message: string }} = {}
foo["a"] = { message: "some message"};

const tupleStrNum = ["x", 2] as [string, number];

type RecursivePartial<T> = {
    [P in keyof T]?: T[P] extends object ? RecursivePartial<T[P]> : T[P];
};

type PartialSomeObject = RecursivePartial<SomeObject>;

type PartialExcept<T, K extends keyof T> = RecursivePartial<T> & Pick<T, K>;

const d = {name: "kenji", age: 99}

type E = {name: string, age: number}
type User<T> = {[K in keyof T]: T[K] | null }

const e:User<E> = { name: null, age: null};

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

const t1:Diff<"a" | "b", "b" | "c"> = "a";　// const t1: "a"

type T3 = "name" | "age"

type F<T> = T extends (a: infer P) => any ? P : T;

type Value<T> = T[keyof T]

type User = { name: string, age: number }
type Value<T> = T[keyof T]
type ValueType = Value<User> // string | number

type User = { name: string, age: number, id: number }

type Value<T> = { [K in keyof T]: T[K] extends number ? K : never }[keyof T]

type NumberType = Pick<User, Value<User>>

const isNarrowScreen = () => false
export function wideNarrow<T>(wide: T,narrow:T){
    return isNarrowScreen() ? narrow : wide;
}

const a = wideNarrow(0, 8)
const extendedAreaHeight = 26;
const b = a + extendedAreaHeight
console.log(b)

function add<T extends number | string>(a: T, b: T): T {
  if (typeof a === 'string' && typeof b === 'string') {
    return (a + b) as T;
  } else if (typeof a === 'number' && typeof b === 'number') {
    return (a + b) as T;
  } else {
    throw new Error('Type mismatch: a and b must be of the same type');
  }
}

function stringLiterals<T extends string>(...args: T[]): T[] { return args; }
type OneOf<T extends unknown[]> = T extends (infer R)[] ? R : never;
const values = stringLiterals('A', 'B'); // ("A" | "B")[]
type Foo = OneOf<typeof values>; // "A" | "B"

type A = { name: string }
type B = { age: number }
type T1 = keyof (A & B)

type MyUnionType =
  | { foo: 'a', bar: 1 }
  | { foo: 'b', bar: 2 }
  | { foo: 'c', bar: 3 }

type FooType = MyUnionType['foo']

const source =  {
    doorToDoor: "delivery at door",
    airDelivery: "flying in",
    specialDelivery: "special delivery",
    inStore: "in-store pickup",
};
const a: Record<keyof typeof source, string> = source
const aa = a["name"] // error

const a: Record<"doorToDoor" | "airDelivery" | "specialDelivery" | "inStore", string> = source;

interface Foo {
    foo: number;
    common: string;
}

interface Bar {
    bar: number;
    common: string;
}

function isFoo(arg: any): arg is Foo {
  return arg.foo !== undefined;
}
function fooAndBar(arg: Bar | Foo){
  if(isFoo(arg)){
    return arg.foo
  } else {
    return arg.bar
  }
}

const result = fooAndBar({ foo: 9, common: "fa" });

interface NumberMap {
   [key: string]: number;
}

function careteMap<T extends NumberMap>(v: T){
 return v
}

const map = careteMap({
 one: 1,
 two: 2,
 three: 3,
})

const lol = map.weoiroweiroew;

type MyKeys = keyof typeof map;

type Person = {
  name: string, age: number, id: number,
}
const me = {name: "a", age: 11, id:999};

Object.keys(me).forEach(key => {
  console.log(me[key as keyof Person]) // ok
})

type User = {
    id: string
    email: string
    password: string
}

type UserProfile = User & { name: string, job: string }

function insert<T extends User>(user: Exact<User, T>) {
    console.log(user)
}

type Exact<TExpected, TActual extends TExpected> = TExpected extends TActual ? TExpected: never;

const userProfile = {id: "1", email: "fa@gmail.com", password: "000", name: "222", job: "engineer"}
insert(userProfile) // 期待するerror

// other: 関数の中で過剰なオブジェクトを受け入れて、type guardで型チェック。正統だったら実行するなども

function _insert(user: User) {
 console.log(user)
}

function insertUser(user: unknown) {
    if(isUser(user)) {
        //user arg is now verified to be of shape User, safe to insert into db
        _insert(user);
    }
}

//do your check
function isUser(user: unknown): user is User {
    if(typeof user !== "object" || user === null)
        return false;

    const neededKeys: Array<keyof User> = ["email", "id", "password"];
    const actualKeys = Object.keys(user);

    return new Set([...neededKeys, ...actualKeys]).size === neededKeys.length;
}

type Exact<TExpected, TActual extends TExpected> = TExpected extends TActual ? TExpected: never;

const a = {a: "A", b: "B", c: 1} as const
type LiteralsUnion = typeof a[keyof typeof a]