declare global {
  export type Writable<T> = {
    -readonly [P in keyof T]: T[P]
  }
  declare type Diff<T extends {}, P extends {}> = {
    [K in Exclude<keyof T, keyof P> | Exclude<keyof P, keyof T>]: (T & P)[K]
  }
  declare type PickCommon<T extends {}, P extends {}> = Pick<T, keyof T & keyof P>
  declare type Arrayable<T> = T | T[]
  declare type Nullable<T> = T | null
  declare type NonNullable<T> = T extends null | undefined ? never : T
  declare type Recordable<T = any> = Record<string, T>
  declare type ReadonlyRecordable<T = any> = {
    readonly [key: string]: T
  }
  declare type Indexable<T = any> = {
    [key: string]: T
  }
  declare type DeepPartial<T> = {
    [P in keyof T]?: DeepPartial<T[P]>
  }
  declare type TimeoutHandle = ReturnType<typeof setTimeout>
  declare type IntervalHandle = ReturnType<typeof setInterval>

  declare function parseInt(s: string | number, radix?: number): number
  declare function parseFloat(string: string | number): number
}

export {}