// Generated from "bridgejsmethod/Main.java"
@file:Suppress(
 "ALWAYS_NULL",
 "PARAMETER_NAME_CHANGED_ON_OVERRIDE",
 "SENSELESS_COMPARISON",
 "UNCHECKED_CAST",
 "UNNECESSARY_LATEINIT",
 "UNNECESSARY_NOT_NULL_ASSERTION",
 "UNREACHABLE_CODE",
 "UNUSED_ANONYMOUS_PARAMETER",
 "UNUSED_PARAMETER",
 "UNUSED_VARIABLE",
 "USELESS_CAST",
 "VARIABLE_IN_SINGLETON_WITHOUT_THREAD_LOCAL",
 "VARIABLE_WITH_REDUNDANT_INITIALIZER",
 "REDUNDANT_ELSE_IN_WHEN")

package bridgejsmethod

import javaemul.lang.*
import jsinterop.annotations.JsMethod
import jsinterop.annotations.JsType
import kotlin.Any
import kotlin.Int
import kotlin.Number
import kotlin.String
import kotlin.Suppress
import kotlin.jvm.JvmStatic

open class Main {
 companion object {
  @JvmStatic
  fun test() {
   val a: A<Any?> = A<Int?>() as A<Any?>
   a.`fun`(1)
   a.bar(1)
   val b: B = B()
   b.`fun`("abc")
   b.bar("abc")
   val c: C = C()
   c.`fun`(1)
   c.bar(1)
   val d: D = D()
   d.`fun`(1)
   d.bar(1)
   val e: E = E()
   e.`fun`("abc")
   e.bar("abc")
   val h: H<Int?> = H<Int?>()
   h.enclose(1)
   val l: L<Int?> = L<Int?>()
   l.fun_pp_bridgejsmethod("foo", 1)
  }
 }

 open class A<T> {
  @JsMethod
  open fun `fun`(t: T): T {
   return t
  }

  open fun bar(t: T) {}
 }

 fun interface I<T: Number?> {
  @JsMethod(name = "mNumber")
  fun `fun`(t: T): T
 }

 fun interface J<T> {
  fun bar(t: T)
 }

 open class B: A<String?>() {
  override fun `fun`(s: String?): String? {
   return s
  }

  @JsMethod
  override fun bar(s: String?) {}
 }

 open class C: A<Int?>() {
  override fun `fun`(i: Int?): Int? {
   return i
  }
 }

 open class D: A<Int?>(), I<Int?> {
  override fun `fun`(i: Int?): Int? {
   return i
  }
 }

 open class E: B(), J<String?>

 open class F: A<Int?>(), I<Int?>

 fun interface G<V> {
  fun enclose(value: V): V
 }

 open class H<V>: G<V> {
  @JsMethod
  override fun enclose(value: V): V {
   return null as V
  }
 }

 open class K<K1, K2> {
  internal open fun fun_pp_bridgejsmethod(k1: K1, k2: K2) {}
 }

 open class L<L1>: K<String?, L1>() {
  @JsMethod(name = "fun")
  override fun fun_pp_bridgejsmethod(string: String?, l1: L1) {}
 }

 fun interface M {
  fun getB(): B?
 }

 @JsType
 abstract inner class N internal constructor(): M {
  abstract override fun getB(): B?
 }

 open inner class O internal constructor(): Main.N() {
  private var b: B? = null

  override fun getB(): B? {
   return this.b
  }
 }

 fun interface P {
  fun getKey(): String?
 }

 @JsType
 abstract inner class Q internal constructor(): P {
  abstract override fun getKey(): String?
 }

 @JsType
 abstract inner class R internal constructor(): Main.Q() {
  override fun getKey(): String? {
   return null
  }
 }

 open inner class S internal constructor(): Main.R()

 open inner class GrandParent<T> internal constructor() {
  @JsMethod
  open fun jsMethod(t: T) {}

  open fun method(t: T) {}
 }

 open inner class Parent<T: Main.Parent<*>?> internal constructor(): Main.GrandParent<T>() {
  override fun jsMethod(t: T) {}

  override fun method(t: T) {}
 }

 open inner class ChildWithoutOverrides internal constructor(): Main.Parent<Main.ChildWithoutOverrides?>()

 open inner class ChildWithOverrides<T: Main.ChildWithOverrides<T>?> internal constructor(): Main.Parent<T>() {
  override fun jsMethod(t: T) {}

  override fun method(t: T) {}
 }

 open inner class ChildWithRenamedOverride internal constructor(): Main.GrandParent<Main.ChildWithRenamedOverride?>() {
  @JsMethod(name = "renamedJsMethod")
  override fun jsMethod(t: Main.ChildWithRenamedOverride?) {}
 }
}
