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

import javaemul.lang.*
import java.lang.Class
import kotlin.Any
import kotlin.Boolean
import kotlin.Int
import kotlin.String
import kotlin.Suppress
import kotlin.jvm.JvmField
import kotlin.jvm.javaObjectType
import nativekttypes.Fn
import nativekttypes.NativeDefaultName
import nativekttypes.nativekt.KBridge
import nativekttypes.nativekt.KCompanionObject
import nativekttypes.nativekt.KFunctionalInterfaceBridge
import nativekttypes.nativekt.KFunctionalInterfaceRequiringBridge
import nativekttypes.nativekt.KInterface
import nativekttypes.nativekt.KInterface.KFunctionalInterface
import nativekttypes.nativekt.KRequiringBridge
import nativekttypes.nativekt.KTopLevel
import nativekttypes.nativekt.KTopLevel.KInner
import nativekttypes.nativekt.KTopLevel.KNested
import nativekttypes.nativekt.KWithCompanionObject

open class Main {
 @JvmField
 var nativeDefaultName: NativeDefaultName? = null

 @JvmField
 var topLevelField: KTopLevel<String?>? = null

 @JvmField
 var nestedField: KNested<String?>? = null

 @JvmField
 var innerField: KTopLevel<String?>.KInner<String?>? = null

 open fun methodArguments(foo: KTopLevel<String?>?, nested: KNested<String?>?, inner: KTopLevel<String?>.KInner<String?>?) {}

 open fun memberAccess() {
  val topLevel: KTopLevel<String?> = KTopLevel<String?>("foo")
  val fooInstanceMethod: String? = topLevel.instanceMethod("foo")
  val fooStaticMethod: String? = KTopLevel.staticMethod<String?>("foo")
  val fooInstanceField: String? = topLevel.instanceField
  topLevel.instanceField = "foo"
  val fooStaticField: Any? = KTopLevel.staticField
  KTopLevel.staticField = "foo"
  topLevel.nonPublicField = 0
  val fieldToRename: Int = topLevel.renamedField
  val methodToRename: Int = topLevel.renamedMethod()
  val methodAsProperty: Int = topLevel.methodAsProperty
  val uppercaseprefixMethodAsProperty: Int = topLevel.uppercaseprefixMethodAsProperty
  val uppercasemethodasproperty: Int = topLevel.uppercasemethodasproperty
  val nonGetMethodAsProperty: Int = topLevel.nonGetMethodAsProperty
  val methodToRenameAsProperty: Int = topLevel.renamedMethodAsProperty
  val isFieldToRename: Boolean = topLevel.isRenamedField
  val isMethodAsProperty: Boolean = topLevel.isMethodAsProperty
  val getstartingmethodAsProperty: Int = topLevel.getstartingmethodAsProperty
  topLevel.nonPublicMethod()
  val nested: KNested<String?> = KNested<String?>("foo")
  val nestedInstanceMethod: String? = nested.instanceMethod("foo")
  val nestedStaticMethod: String? = KNested.staticMethod<String?>("foo")
  val nestedInstanceField: String? = nested.instanceField
  nested.instanceField = "foo"
  val nestedStaticField: Any? = KNested.staticField
  KNested.staticField = "foo"
  val nestedAnonynous: KNested<String?> = object : KNested<String?>("foo") {}
  val inner: KTopLevel<String?>.KInner<String?> = topLevel.KInner<String?>("foo")
  val subclass: Subclass<String?> = Subclass<String?>("foo")
  val subclassMethodToRename: Int = subclass.renamedMethod()
  val subclassInterfaceMethod: Int = subclass.interfaceMethod("foo")
  val subclassInterfaceMethodToRename: Int = subclass.renamedInterfaceMethod("foo")
  val interfaceAnonymousSubclass: KFunctionalInterface = object : KFunctionalInterface {
   override fun run() {}
  }
  val interfaceExpression: KFunctionalInterface = KFunctionalInterface {
   return@KFunctionalInterface
  }
 }

 open fun bridges() {
  var o: KRequiringBridge = KBridge()
  o = object : KBridge() {}
  o = BridgeSubclass()
  var fi: KFunctionalInterfaceRequiringBridge<String?>? = null
  fi = KFunctionalInterfaceBridge { s: String? ->
   return@KFunctionalInterfaceBridge s
  }
  fi = object : KFunctionalInterfaceBridge<String?> {
   override fun foo(s: String?): String? {
    return s
   }
  }
  val cast: KRequiringBridge? = o as KRequiringBridge?
  val instanceofCheck: Boolean = o is KRequiringBridge
 }

 open fun casts() {
  val o1: KTopLevel<String?>? = null as KTopLevel<String?>?
  val o2: KNested<String?>? = null as KNested<String?>?
  val o3: KTopLevel<String?>.KInner<String?>? = null as KTopLevel<String?>.KInner<String?>?
 }

 open fun companionObject() {
  val o: KWithCompanionObject = KWithCompanionObject()
  val i1: Int = o.instanceField
  o.instanceMethod()
  KCompanionObject.staticMethod()
  val i2: Int = KCompanionObject.staticField
  KCompanionObject.staticField = i2
 }

 open fun typeLiterals() {
  val c1: Class<*> = KTopLevel::class.javaObjectType as Class<*>
  val c2: Class<*> = KNested::class.javaObjectType as Class<*>
  val c3: Class<*> = KInner::class.javaObjectType as Class<*>
 }

 open fun disabledVoidMethod() {}

 open fun disabledNonVoidMethod(): Boolean {
  return false
 }

 open fun <I, O> acceptFn_generic(f: Fn<I, O>?, i: I): O {
  return f!!.apply(i)
 }

 open fun acceptFn_parametrized(f: Fn<String?, String?>?, i: String?): String? {
  return f!!.apply(i)
 }

 open fun <I, O> acceptFn_genericWildcard(f: Fn<I, O>?, i: I): O {
  return f!!.apply(i)
 }

 open fun acceptFn_parametrizedWildcard(f: Fn<String?, String?>?, i: String?): String? {
  return f!!.apply(i)
 }

 open fun acceptFn_unboundWildcard(f: Fn<*, *>?, i: Any?): Any? {
  return (f as Fn<Any?, Any?>?)!!.apply(i)
 }

 open fun acceptFn_raw(f: Fn<Any?, Any?>?, i: Any?): Any? {
  return f!!.apply(i)
 }
}

open class Subclass<V>: KTopLevel<V>, KInterface<V> {
 internal constructor(v: V): super(v)

 override fun renamedMethod(): Int {
  return super<KTopLevel>.renamedMethod()
 }

 override val methodAsProperty: Int
  get() {
   return super<KTopLevel>.methodAsProperty
  }

 override val uppercaseprefixMethodAsProperty: Int
  get() {
   return super<KTopLevel>.uppercaseprefixMethodAsProperty
  }

 override val uppercasemethodasproperty: Int
  get() {
   return super<KTopLevel>.uppercasemethodasproperty
  }

 override val nonGetMethodAsProperty: Int
  get() {
   return super<KTopLevel>.nonGetMethodAsProperty
  }

 override val renamedMethodAsProperty: Int
  get() {
   return super<KTopLevel>.renamedMethodAsProperty
  }

 override val getRenamedMethodAsProperty: Int
  get() {
   return super<KTopLevel>.getRenamedMethodAsProperty
  }

 override val isMethodAsProperty: Boolean
  get() {
   return super<KTopLevel>.isMethodAsProperty
  }

 override val getstartingmethodAsProperty: Int
  get() {
   return super<KTopLevel>.getstartingmethodAsProperty
  }

 override fun interfaceMethod(v: V): Int {
  return 0
 }

 override fun renamedInterfaceMethod(v: V): Int {
  return 0
 }

 override val interfaceMethodAsProperty: Int
  get() {
   return 0
  }

 override val renamedInterfaceMethodAsProperty: Int
  get() {
   return 0
  }
}

open class Subsubclass<V>: Subclass<V> {
 internal constructor(v: V): super(v)

 override fun renamedMethod(): Int {
  return super<Subclass>.renamedMethod()
 }

 override val methodAsProperty: Int
  get() {
   return super<Subclass>.methodAsProperty
  }

 override val uppercaseprefixMethodAsProperty: Int
  get() {
   return super<Subclass>.uppercaseprefixMethodAsProperty
  }

 override val uppercasemethodasproperty: Int
  get() {
   return super<Subclass>.uppercasemethodasproperty
  }

 override val nonGetMethodAsProperty: Int
  get() {
   return super<Subclass>.nonGetMethodAsProperty
  }

 override val renamedMethodAsProperty: Int
  get() {
   return super<Subclass>.renamedMethodAsProperty
  }

 override val getRenamedMethodAsProperty: Int
  get() {
   return super<Subclass>.getRenamedMethodAsProperty
  }

 override val isMethodAsProperty: Boolean
  get() {
   return super<Subclass>.isMethodAsProperty
  }

 override val getstartingmethodAsProperty: Int
  get() {
   return super<Subclass>.getstartingmethodAsProperty
  }

 override fun interfaceMethod(v: V): Int {
  return 0
 }

 override fun renamedInterfaceMethod(v: V): Int {
  return 0
 }

 override val interfaceMethodAsProperty: Int
  get() {
   return 0
  }

 override val renamedInterfaceMethodAsProperty: Int
  get() {
   return 0
  }
}

open class BridgeSubclass internal constructor(): KBridge() {
 override fun method() {
  super<KBridge>.method()
 }
}
