// Generated from "libraryinfo/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 libraryinfo

import javaemul.lang.*
import java.lang.Class
import jsinterop.annotations.JsEnum
import jsinterop.annotations.JsFunction
import jsinterop.annotations.JsMethod
import jsinterop.annotations.JsPackage
import jsinterop.annotations.JsProperty
import jsinterop.annotations.JsType
import kotlin.Any
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.jvm.JvmField
import kotlin.jvm.JvmStatic
import kotlin.jvm.javaObjectType

open class Main {
 private fun execute() {
  Main.log(42)
 }

 override fun toString(): String {
  return super.toString()
 }

 companion object {
  @JvmField
  var STATIC_FIELD: String? = "STATIC_FIELD"

  const val CONSTANT: String = "STATIC_FIELD"

  @JsProperty
  const val JS_CONSTANT: String = "STATIC_FIELD"

  @JvmStatic
  @JsMethod
  fun entryPoint() {
   Main().execute()
   var jsFunction: Function = FunctionImpl()
   jsFunction = Function { s: String? ->
    Main.log(42)
   }
   jsFunction.apply("foo")
   MyJsType()
   object : Any() {
    @JsMethod(name = "foo")
    internal fun foo_pp_libraryinfo() {}
   }
  }

  @JvmStatic
  @JsMethod(name = "console.log", namespace = JsPackage.GLOBAL)
  external fun log(o: Int)

  @JvmStatic
  @JsMethod
  fun main() {
   val foo: Main.Foo? = null
   foo!!.instanceMethod_pp_libraryinfo()
   val clazz: Class<*> = Foo::class.javaObjectType
  }
 }

 @JsType
 interface JsTypeInterface {
  fun foo()

  fun bar()
 }

 fun interface FunctionnalInterface {
  fun foo()
 }

 fun interface JsAccessibleFunctionnalInterface {
  @JsMethod
  fun accessibleFunctionalInterfaceMethod()
 }

 @JsFunction
 fun interface Function {
  fun apply(s: String?)
 }

 class FunctionImpl internal constructor(): Function {
  override fun apply(s: String?) {}
 }

 @JsEnum
 enum class MyJsEnum {
  A,
  B,
  C;
 }

 enum class MyEnum {
  FOO,
  BAR;
 }

 @JsType
 open class MyJsType {
  @JvmField
  internal var someField_pp_libraryinfo: Any? = null

  constructor() {
   this.someField_pp_libraryinfo = Main()
  }
 }

 open inner class Foo {
  internal open fun instanceMethod_pp_libraryinfo() {}
 }
}
