open class Any
The root of the Kotlin class hierarchy. Every Kotlin class has Any as a superclass.
Indicates whether some other object is "equal to" this one. Implementations must fulfil the following requirements:
open operator fun equals(other: Any?): Boolean
Returns a hash code value for the object. The general contract of hashCode
is:
open fun hashCode(): Int
Returns a string representation of the object.
open fun toString(): String
Checks if given object is null or frozen or permanent (i.e. instantiated at compile-time).
val Any?.isFrozen: Boolean
Returns the runtime Java class of this object.
val <T : Any> T.javaClass: Class<T>
Calls the specified function block with this
value as its argument and returns this
value.
fun <T> T.also(block: (T) -> Unit): T
Calls the specified function block with this
value as its receiver and returns this
value.
fun <T> T.apply(block: T.() -> Unit): T
Reinterprets this value as a value of the dynamic type.
fun Any?.asDynamic(): dynamic
This function ensures that if we see such an object during freezing attempt - freeze fails and FreezingException is thrown.
fun Any.ensureNeverFrozen()
Freezes object subgraph reachable from this object. Frozen objects can be freely shared between threads/workers.
fun <T> T.freeze(): T
Returns a hash code value for the object or zero if the object is null
.
fun Any?.hashCode(): Int
Compute stable wrt potential object relocations by the memory manager identity hash code.
fun Any?.identityHashCode(): Int
Allows to iterate this dynamic
object in the following cases:
operator fun dynamic.iterator(): Iterator<dynamic>
Calls the specified function block with this
value as its argument and returns its result.
fun <T, R> T.let(block: (T) -> R): R
fun Any?.objcPtr(): NativePtr
fun <T : Any> T.pin(): Pinned<T>
Calls the specified function block with this
value as its receiver and returns its result.
fun <T, R> T.run(block: T.() -> R): R
Calls the specified function block with this
value as its receiver and returns its encapsulated result if invocation was successful, catching any Throwable exception that was thrown from the block function execution and encapsulating it as a failure.
fun <T, R> T.runCatching(block: T.() -> R): Result<R>
Returns this
value if it satisfies the given predicate or null
, if it doesn't.
fun <T> T.takeIf(predicate: (T) -> Boolean): T?
Returns this
value if it does not satisfy the given predicate or null
, if it does.
fun <T> T.takeUnless(predicate: (T) -> Boolean): T?
Reinterprets this value as a value of the specified type T without any actual type checking.
fun <T> Any?.unsafeCast(): T
Reinterprets this dynamic
value as a value of the specified type T without any actual type checking.
fun <T> dynamic.unsafeCast(): T
fun <T : Any, R> T.usePinned(block: (Pinned<T>) -> R): R
Provides a skeletal implementation of the read-only Collection interface.
abstract class AbstractCollection<out E> : Collection<E>
Base class for CoroutineContext.Element implementations.
abstract class AbstractCoroutineContextElement : Element
Base class for CoroutineContext.Key associated with polymorphic CoroutineContext.Element implementation. Polymorphic element implementation implies delegating its get and minusKey to getPolymorphicElement and minusPolymorphicKey respectively.
abstract class AbstractCoroutineContextKey<B : Element, E : B> : Key<E>
A base class to simplify implementing iterators so that implementations only have to implement computeNext to implement the iterator, calling done when the iteration is complete.
abstract class AbstractIterator<T> : Iterator<T>
Provides a skeletal implementation of the read-only Map interface.
abstract class AbstractMap<K, out V> : Map<K, V>
Provides a skeletal implementation of the MutableCollection interface.
abstract class AbstractMutableCollection<E> : MutableCollection<E>
abstract class AbstractMutableCollection<E> : MutableCollection<E>, AbstractCollection<E>
abstract class AbstractMutableCollection<E> : AbstractCollection<E>, MutableCollection<E>
abstract class AbstractMutableCollection<E> : MutableCollection<E>, AbstractCollection<E>
Provides a skeletal implementation of the MutableList interface.
abstract class AbstractMutableList<E> : MutableList<E>
abstract class AbstractMutableList<E> : MutableList<E>, AbstractList<E>
abstract class AbstractMutableList<E> : AbstractMutableCollection<E>, MutableList<E>
Provides a skeletal implementation of the MutableMap interface.
abstract class AbstractMutableMap<K, V> : MutableMap<K, V>
abstract class AbstractMutableMap<K, V> : MutableMap<K, V>, AbstractMap<K, V>
abstract class AbstractMutableMap<K, V> : AbstractMap<K, V>, MutableMap<K, V>
Provides a skeletal implementation of the MutableSet interface.
abstract class AbstractMutableSet<E> : MutableSet<E>
abstract class AbstractMutableSet<E> : MutableSet<E>, AbstractSet<E>
abstract class AbstractMutableSet<E> : AbstractMutableCollection<E>, MutableSet<E>
Exposes the JavaScript AbstractWorker to Kotlin
interface AbstractWorker
Represents a property accessor, which is a get
or set
method declared alongside the property. See the Kotlin language documentation for more information.
interface Accessor<out V>
interface AddEventListenerOptions : EventListenerOptions
Base interface implicitly implemented by all annotation interfaces. See Kotlin language documentation for more information on annotations.
interface Annotation
An object to which char sequences and values can be appended.
interface Appendable
typealias Appendable = Appendable
interface AppendMode
object ArenaManager
Represents an array (specifically, a Java array when targeting the JVM platform). Array instances can be created using the arrayOf, arrayOfNulls and emptyArray standard library functions. See Kotlin language documentation for more information on arrays.
class Array<T>
Exposes the JavaScript ArrayBuffer to Kotlin
open class ArrayBuffer : BufferDataSource
Exposes the JavaScript ArrayBufferView to Kotlin
interface ArrayBufferView : BufferDataSource
Provides a MutableList implementation, which uses a resizable array as its backing storage.
class ArrayList<E> : MutableList<E>, RandomAccess
typealias ArrayList<E> = ArrayList<E>
open class ArrayList<E> : AbstractMutableList<E>, MutableList<E>, RandomAccess
class ArrayList<E> : MutableList<E>, RandomAccess, AbstractMutableList<E>
interface AssignedNodesOptions
Makes the annotated annotation class an associated object key.
annotation class AssociatedObjectKey
Atomic values and freezing: atomics AtomicInt, AtomicLong, AtomicNativePtr and AtomicReference are unique types with regard to freezing. Namely, they provide mutating operations, while can participate in frozen subgraphs. So shared frozen objects can have fields of atomic types.
class AtomicInt
class AtomicLong
class AtomicNativePtr
An atomic reference to a frozen Kotlin object. Can be used in concurrent scenarious but frequently shall be of nullable type and be zeroed out once no longer needed. Otherwise memory leak could happen if the atomic reference is a part of a reference cycle.
class AtomicReference<T>
Exposes the JavaScript AudioTrack to Kotlin
abstract class AudioTrack : UnionAudioTrackOrTextTrackOrVideoTrack
abstract class BarProp
interface BinaryType
A vector of bits growing if necessary and allowing one to set/clear/read bits from it by a bit index.
class BitSet
Exposes the JavaScript Blob to Kotlin
open class Blob : MediaProvider, ImageBitmapSource
interface BlobPropertyBag
Exposes the JavaScript Body to Kotlin
interface Body
Represents a value which is either true
or false
. On the JVM, non-nullable values of this type are represented as values of the primitive type boolean
.
class Boolean : Comparable<Boolean>
An array of booleans. When targeting the JVM, instances of this class are represented as boolean[]
.
class BooleanArray
An iterator over a sequence of values of type Boolean
.
abstract class BooleanIterator : Iterator<Boolean>
interface BoxQuadOptions
interface BufferDataSource
Allows to infer generic type arguments of a function from the calls in the annotated function parameter of that function.
annotation class BuilderInference
An array of bytes. When targeting the JVM, instances of this class are represented as byte[]
.
class ByteArray
An iterator over a sequence of values of type Byte
.
abstract class ByteIterator : Iterator<Byte>
Exposes the JavaScript Cache to Kotlin
abstract class Cache
interface CacheBatchOperation
interface CacheQueryOptions
Exposes the JavaScript CacheStorage to Kotlin
abstract class CacheStorage
An effect of calling a functional parameter in place.
interface CallsInPlace : Effect
interface CanPlayTypeResult
interface CanvasCompositing
interface CanvasDirection
interface CanvasDrawImage
interface CanvasDrawPath
interface CanvasFillRule
interface CanvasFillStrokeStyles
interface CanvasFilters
Exposes the JavaScript CanvasGradient to Kotlin
abstract class CanvasGradient
interface CanvasHitRegion
interface CanvasImageData
interface CanvasImageSmoothing
interface CanvasImageSource : ImageBitmapSource
interface CanvasLineCap
interface CanvasLineJoin
interface CanvasPath
interface CanvasPathDrawingStyles
Exposes the JavaScript CanvasPattern to Kotlin
abstract class CanvasPattern
interface CanvasRect
Exposes the JavaScript CanvasRenderingContext2D to Kotlin
abstract class CanvasRenderingContext2D : CanvasState, CanvasTransform, CanvasCompositing, CanvasImageSmoothing, CanvasFillStrokeStyles, CanvasShadowStyles, CanvasFilters, CanvasRect, CanvasDrawPath, CanvasUserInterface, CanvasText, CanvasDrawImage, CanvasHitRegion, CanvasImageData, CanvasPathDrawingStyles, CanvasTextDrawingStyles, CanvasPath, RenderingContext
interface CanvasRenderingContext2DSettings
interface CanvasShadowStyles
interface CanvasState
interface CanvasText
interface CanvasTextAlign
interface CanvasTextBaseline
interface CanvasTextDrawingStyles
interface CanvasTransform
interface CanvasUserInterface
interface Capabilities
Exposes the JavaScript CaretPosition to Kotlin
abstract class CaretPosition
annotation class CCall
interface CEnum
Denotes property that is an alias to some enum entry.
annotation class CEnumEntryAlias
Stores instance size of the type T: CEnumVar.
annotation class CEnumVarTypeSize
Represents a 16-bit Unicode character.
class Char : Comparable<Char>
An array of chars. When targeting the JVM, instances of this class are represented as char[]
.
class CharArray
An iterator over a sequence of values of type Char
.
abstract class CharIterator : Iterator<Char>
A progression of values of type Char
.
open class CharProgression : Iterable<Char>
Represents a readable sequence of Char values.
interface CharSequence
Constant definitions for the standard charsets. These charsets are guaranteed to be available on every implementation of the Java platform.
object Charsets
Exposes the JavaScript ChildNode to Kotlin
interface ChildNode
Exposes the JavaScript Client to Kotlin
abstract class Client : UnionClientOrMessagePortOrServiceWorker
interface ClientQueryOptions
Exposes the JavaScript Clients to Kotlin
abstract class Clients
interface ClientType
interface ClipboardEventInit : EventInit
interface ClipboardPermissionDescriptor
Represents a range of floating point numbers. Extends ClosedRange interface providing custom operation lessThanOrEquals for comparing values of range domain type.
interface ClosedFloatingPointRange<T : Comparable<T>> : ClosedRange<T>
Represents a range of values (for example, numbers or characters). See the Kotlin language documentation for more information.
interface ClosedRange<T : Comparable<T>>
interface CloseEventInit : EventInit
Makes top level function available from C/C++ code with the given name.
annotation class CName
A generic collection of elements. Methods in this interface support only read-only access to the collection; read/write access is supported through the MutableCollection interface.
interface Collection<out E> : Iterable<E>
interface ColorSpaceConversion
Classes which inherit from this interface have a defined total ordering between their instances.
interface Comparable<in T>
Provides a comparison function for imposing a total ordering between instances of the type T.
fun interface Comparator<T>
typealias Comparator<T> = Comparator<T>
interface CompositionEventInit : UIEventInit
An effect of some condition being true after observing another effect of a function.
interface ConditionalEffect : Effect
Exposes the console API to Kotlin.
interface Console
Collection of annotations that allow to store constant values.
object ConstantValue
interface ConstrainablePattern
Exposes the JavaScript ConstrainBooleanParameters to Kotlin
interface ConstrainBooleanParameters
Exposes the JavaScript ConstrainDOMStringParameters to Kotlin
interface ConstrainDOMStringParameters
interface ConstrainDoubleRange : DoubleRange
interface Constraints : ConstraintSet
interface ConstraintSet
interface ConstrainULongRange : ULongRange
Interface representing a continuation after a suspension point that returns a value of type T
.
interface Continuation<in T>
class Continuation0 : () -> Unit
class Continuation1<T1> : (T1) -> Unit
class Continuation2<T1, T2> : (T1, T2) -> Unit
Marks coroutine context element that intercepts coroutine continuations. The coroutines framework uses ContinuationInterceptor.Key to retrieve the interceptor and intercepts all coroutine continuations with interceptContinuation invocations.
interface ContinuationInterceptor : Element
Provides a scope, where the functions of the contract DSL, such as returns, callsInPlace, etc., can be used to describe the contract of a function.
interface ContractBuilder
interface ConvertCoordinateOptions
Exposes the JavaScript CSS to Kotlin
abstract class CSS
interface CSSBoxType
Exposes the JavaScript CSSRule to Kotlin
abstract class CSSRule
Exposes the JavaScript CSSRuleList to Kotlin
abstract class CSSRuleList : ItemArrayLike<CSSRule>
Exposes the JavaScript CSSStyleDeclaration to Kotlin
abstract class CSSStyleDeclaration : ItemArrayLike<String>
annotation class CStruct
Exposes the JavaScript CustomElementRegistry to Kotlin
abstract class CustomElementRegistry
interface CustomEventInit : EventInit
Exposes the JavaScript DataTransfer to Kotlin
abstract class DataTransfer
Exposes the JavaScript DataTransferItem to Kotlin
abstract class DataTransferItem
Exposes the JavaScript DataTransferItemList to Kotlin
abstract class DataTransferItemList
Exposes the JavaScript DataView to Kotlin
open class DataView : ArrayBufferView
Defines deep recursive function that keeps its stack on the heap, which allows very deep recursive computations that do not use the actual call stack. To initiate a call to this deep recursive function use its invoke function. As a rule of thumb, it should be used if recursion goes deeper than a thousand calls.
class DeepRecursiveFunction<T, R>
A scope class for DeepRecursiveFunction function declaration that defines callRecursive methods to recursively call this function or another DeepRecursiveFunction putting the call activation frame on the heap.
sealed class DeepRecursiveScope<T, R>
open class DeferScope
Standard property delegates.
object Delegates
Marks the annotated declaration as deprecated.
annotation class Deprecated
Marks the annotated declaration as deprecated. In contrast to Deprecated, severity of the reported diagnostic is not a constant value, but differs depending on the API version of the usage (the value of the -api-version
argument when compiling the module where the usage is located). If the API version is greater or equal than hiddenSince, the declaration will not be accessible from the code (as if it was deprecated with level DeprecationLevel.HIDDEN), otherwise if the API version is greater or equal than errorSince, the usage will be marked as an error (as with DeprecationLevel.ERROR), otherwise if the API version is greater or equal than warningSince, the usage will be marked as a warning (as with DeprecationLevel.WARNING), otherwise the annotation is ignored.
annotation class DeprecatedSinceKotlin
Detached object graph encapsulates transferrable detached subgraph which cannot be accessed externally, until it is attached with the attach extension function.
class DetachedObjectGraph<T>
interface DocumentAndElementEventHandlers
Exposes the JavaScript DocumentOrShadowRoot to Kotlin
interface DocumentOrShadowRoot
interface DocumentReadyState
Exposes the JavaScript DOMImplementation to Kotlin
abstract class DOMImplementation
Exposes the JavaScript DOMMatrixReadOnly to Kotlin
open class DOMMatrixReadOnly
Exposes the JavaScript DOMParser to Kotlin
open class DOMParser
Exposes the JavaScript DOMPointInit to Kotlin
interface DOMPointInit
Exposes the JavaScript DOMPointReadOnly to Kotlin
open class DOMPointReadOnly
Exposes the JavaScript DOMQuad to Kotlin
open class DOMQuad
interface DOMRectInit
interface DOMRectList : ItemArrayLike<DOMRect>
Exposes the JavaScript DOMRectReadOnly to Kotlin
open class DOMRectReadOnly
Exposes the JavaScript DOMStringMap to Kotlin
abstract class DOMStringMap
Exposes the JavaScript DOMTokenList to Kotlin
abstract class DOMTokenList : ItemArrayLike<String>
An array of doubles. When targeting the JVM, instances of this class are represented as double[]
.
class DoubleArray
An iterator over a sequence of values of type Double
.
abstract class DoubleIterator : Iterator<Double>
Exposes the JavaScript DoubleRange to Kotlin
interface DoubleRange
interface DragEventInit : MouseEventInit
When applied to annotation class X specifies that X defines a DSL language
annotation class DslMarker
Represents the amount of time one instant of time is away from another instant.
class Duration : Comparable<Duration>
Represents an effect of a function invocation, either directly observable, such as the function returning normally, or a side-effect, such as the function's lambda parameter being called in place.
interface Effect
interface ElementContentEditable
interface ElementCreationOptions
interface ElementCSSInlineStyle
interface ElementDefinitionOptions
An empty coroutine context.
object EmptyCoroutineContext : CoroutineContext, Serializable
interface EndOfStreamError
Represents a key/value pair held by a Map.
interface Entry<out K, out V>
The common base class of all enum classes. See the Kotlin language documentation for more information on enum classes.
abstract class Enum<E : Enum<E>> : Comparable<E>
class Enum<T : Enum<T>> : Comparable<Enum<T>>
interface ErrorEventInit : EventInit
Exposes the JavaScript Event to Kotlin
open class Event
interface EventInit
Exposes the JavaScript EventListener to Kotlin
interface EventListener
interface EventListenerOptions
interface EventModifierInit : UIEventInit
interface EventSourceInit
Exposes the JavaScript EventTarget to Kotlin
abstract class EventTarget
Signals that the annotated annotation class is a marker of an experimental API.
annotation class Experimental
The experimental marker for associated objects API.
annotation class ExperimentalAssociatedObjects
This marker distinguishes the experimental contract declaration API and is used to opt-in for that feature when declaring contracts of user functions.
annotation class ExperimentalContracts
Marks experimental JS export annotations.
annotation class ExperimentalJsExport
The experimental multiplatform support API marker.
annotation class ExperimentalMultiplatform
This annotation marks the standard library API that is considered experimental and is not subject to the general compatibility guarantees given for the standard library: the behavior of such API may be changed or the API may be removed completely in any further release.
annotation class ExperimentalStdlibApi
This annotation marks the experimental preview of the standard library API for measuring time and working with durations.
annotation class ExperimentalTime
The experimental marker for type inference augmenting annotations.
annotation class ExperimentalTypeInference
Marks the API that is dependent on the experimental unsigned types, including those types themselves.
annotation class ExperimentalUnsignedTypes
Makes Kotlin subclass of Objective-C class visible for runtime lookup after Kotlin main
function gets invoked.
annotation class ExportObjCClass
interface ExtendableEventInit : EventInit
interface ExtendableMessageEventInit : ExtendableEventInit
Signifies that the annotated functional type represents an extension function.
annotation class ExtensionFunctionType
interface External
annotation class ExternalObjCClass
interface FetchEventInit : ExtendableEventInit
Exposes the JavaScript FileList to Kotlin
abstract class FileList : ItemArrayLike<File>
interface FilePropertyBag : BlobPropertyBag
Exposes the JavaScript FileReaderSync to Kotlin
open class FileReaderSync
This class is intended to implement different file traversal methods. It allows to iterate through all files inside a given directory.
class FileTreeWalk : Sequence<File>
Exposes the JavaScript Float32Array to Kotlin
open class Float32Array : ArrayBufferView
Exposes the JavaScript Float64Array to Kotlin
open class Float64Array : ArrayBufferView
An array of floats. When targeting the JVM, instances of this class are represented as float[]
.
class FloatArray
An iterator over a sequence of values of type Float
.
abstract class FloatIterator : Iterator<Float>
interface FocusEventInit : UIEventInit
interface ForeignFetchEventInit : ExtendableEventInit
interface ForeignFetchOptions
interface ForeignFetchResponse
Exposes the JavaScript FormData to Kotlin
open class FormData
interface FrameType
An atomic reference to a Kotlin object. Can be used in concurrent scenarious, but must be frozen first, otherwise behaves as regular box for the value. If frozen, shall be zeroed out once no longer needed. Otherwise memory leak could happen if atomic reference is a part of a reference cycle.
class FreezableAtomicReference<T>
Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.
interface Function<out R>
Class representing abstract computation, whose result may become available in the future.
class Future<T>
Exposes the JavaScript GeometryUtils to Kotlin
interface GeometryUtils
interface GetNotificationOptions
interface GetRootNodeOptions
interface GetSVGDocument
Getter of the property is a get
method declared alongside the property.
interface Getter<out V> : KProperty.Accessor<V>, KFunction<V>
Getter of the property is a get
method declared alongside the property.
interface Getter<out V> : KProperty.Getter<V>, () -> V
Getter of the property is a get
method declared alongside the property.
interface Getter<T, out V> : KProperty.Getter<V>, (T) -> V
Getter of the property is a get
method declared alongside the property.
interface Getter<D, E, out V> : KProperty.Getter<V>, (D, E) -> V
Exposes the JavaScript GlobalEventHandlers to Kotlin
interface GlobalEventHandlers
interface GlobalPerformance
Represents a source of elements with a keyOf function, which can be applied to each element to get its key.
interface Grouping<T, out K>
interface HashChangeEventInit : EventInit
Hash table based implementation of the MutableMap interface.
class HashMap<K, V> : MutableMap<K, V>
typealias HashMap<K, V> = HashMap<K, V>
open class HashMap<K, V> : AbstractMutableMap<K, V>, MutableMap<K, V>
The implementation of the MutableSet interface, backed by a HashMap instance.
class HashSet<E> : MutableSet<E>
typealias HashSet<E> = HashSet<E>
open class HashSet<E> : AbstractMutableSet<E>, MutableSet<E>
class HashSet<E> : MutableSet<E>, KonanSet<E>, AbstractMutableSet<E>
Exposes the JavaScript Headers to Kotlin
open class Headers
Exposes the JavaScript History to Kotlin
abstract class History
interface HitRegionOptions
abstract class HTMLAllCollection
Exposes the JavaScript HTMLCollection to Kotlin
abstract class HTMLCollection : ItemArrayLike<Element>, UnionElementOrHTMLCollection
Exposes the JavaScript HTMLHyperlinkElementUtils to Kotlin
interface HTMLHyperlinkElementUtils
interface HTMLOrSVGImageElement : CanvasImageSource
interface HTMLOrSVGScriptElement
Exposes the JavaScript ImageBitmap to Kotlin
abstract class ImageBitmap : CanvasImageSource, TexImageSource
interface ImageBitmapOptions
Exposes the JavaScript ImageBitmapRenderingContext to Kotlin
abstract class ImageBitmapRenderingContext
interface ImageBitmapRenderingContextSettings
interface ImageBitmapSource
Exposes the JavaScript ImageData to Kotlin
open class ImageData : ImageBitmapSource, TexImageSource
interface ImageOrientation
interface ImageSmoothingQuality
An immutable compile-time array of bytes.
class ImmutableBlob
Data class representing a value from a collection or sequence, along with its index in that collection or sequence.
data class IndexedValue<out T>
interface InputEventInit : UIEventInit
Exposes the JavaScript Int16Array to Kotlin
open class Int16Array : ArrayBufferView
Exposes the JavaScript Int32Array to Kotlin
open class Int32Array : ArrayBufferView
Exposes the JavaScript Int8Array to Kotlin
open class Int8Array : ArrayBufferView
An array of ints. When targeting the JVM, instances of this class are represented as int[]
.
class IntArray
annotation class InteropStubs
An iterator over a sequence of values of type Int
.
abstract class IntIterator : Iterator<Int>
A progression of values of type Int
.
open class IntProgression : Iterable<Int>
interface ItemArrayLike<out T>
Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over.
interface Iterable<out T>
An iterator over a collection or another entity that can be represented as a sequence of elements. Allows to sequentially access the elements.
interface Iterator<out T>
Represents the constructor of a class. Instances of JsClass
can be passed to JavaScript APIs that expect a constructor reference.
interface JsClass<T : Any>
Exports top-level declaration on JS platform.
annotation class JsExport
Denotes an external
declaration that must be imported from native JavaScript library.
annotation class JsModule
Gives a declaration (a function, a property or a class) specific name in JavaScript.
annotation class JsName
Denotes an external
declaration that can be used without module system.
annotation class JsNonModule
An interface for indexing access to a collection of key-value pairs, where type of key is String and type of value is Any?.
interface Json
Exposes the JavaScript JSON object to Kotlin.
object JSON
Adds prefix to external
declarations in a source file.
annotation class JsQualifier
open class JsValue
Specifies that a JVM default method should be generated for non-abstract Kotlin interface member.
annotation class JvmDefault
Prevents the compiler from generating compatibility accessors for the annotated class or interface, and suppresses any related compatibility warnings. In other words, this annotation makes the compiler generate the annotated class or interface in the -Xjvm-default=all
mode, where only JVM default methods are generated, without DefaultImpls
.
annotation class JvmDefaultWithoutCompatibility
Instructs the Kotlin compiler not to generate getters/setters for this property and expose it as a field.
annotation class JvmField
Instructs the Kotlin compiler to generate a multifile class with top-level functions and properties declared in this file as one of its parts. Name of the corresponding multifile class is provided by the JvmName annotation.
annotation class JvmMultifileClass
Specifies the name for the Java class or method which is generated from this element.
annotation class JvmName
Instructs the Kotlin compiler to generate overloads for this function that substitute default parameter values.
annotation class JvmOverloads
Specifies that an additional static method needs to be generated from this element if it's a function. If this element is a property, additional static getter/setter methods should be generated.
annotation class JvmStatic
Instructs compiler to generate or omit wildcards for type arguments corresponding to parameters with declaration-site variance, for example such as Collection<out T>
has.
annotation class JvmSuppressWildcards
Sets ACC_SYNTHETIC
flag on the annotated target in the Java bytecode.
annotation class JvmSynthetic
Instructs compiler to generate wildcard for annotated type arguments corresponding to parameters with declaration-site variance.
annotation class JvmWildcard
Represents an annotated element and allows to obtain its annotations. See the Kotlin language documentation for more information.
interface KAnnotatedElement
Represents a callable entity, such as a function or a property.
interface KCallable<out R>
interface KCallable<out R> : KAnnotatedElement
Represents a class and provides introspection capabilities. Instances of this class are obtainable by the ::class
syntax. See the Kotlin language documentation for more information.
interface KClass<T : Any> : KClassifier
interface KClass<T : Any> : KDeclarationContainer, KAnnotatedElement, KClassifier
A classifier is either a class or a type parameter.
interface KClassifier
Represents an entity which may contain declarations of any other entities, such as a class or a package.
interface KDeclarationContainer
interface KeyboardEventInit : EventModifierInit
Represents a function with introspection capabilities.
interface KFunction<out R> : KCallable<R>, Function<R>
Represents a property declared as a var
.
interface KMutableProperty<V> : KProperty<V>
Represents a var
-property without any kind of receiver.
interface KMutableProperty0<V> : KProperty0<V>, KMutableProperty<V>
Represents a var
-property, operations on which take one receiver as a parameter.
interface KMutableProperty1<T, V> : KProperty1<T, V>, KMutableProperty<V>
Represents a var
-property, operations on which take two receivers as parameters.
interface KMutableProperty2<D, E, V> : KProperty2<D, E, V>, KMutableProperty<V>
Represents a version of the Kotlin standard library.
class KotlinVersion : Comparable<KotlinVersion>
Represents a parameter passed to a function or a property getter/setter, including this
and extension receiver parameters.
interface KParameter : KAnnotatedElement
Represents a property, such as a named val
or var
declaration. Instances of this class are obtainable by the ::
operator.
interface KProperty<out V> : KCallable<V>
Represents a property without any kind of receiver. Such property is either originally declared in a receiverless context such as a package, or has the receiver bound to it.
interface KProperty0<out V> : KProperty<V>, () -> V
Represents a property, operations on which take one receiver as a parameter.
interface KProperty1<T, out V> : KProperty<V>, (T) -> V
Represents a property, operations on which take two receivers as parameters, such as an extension property declared in a class.
interface KProperty2<D, E, out V> : KProperty<V>, (D, E) -> V
Represents a type. Type is usually either a class with optional type arguments, or a type parameter of some declaration, plus nullability.
interface KType
interface KType : KAnnotatedElement
Represents a declaration of a type parameter of a class or a callable. See the Kotlin language documentation for more information.
interface KTypeParameter : KClassifier
Represents a type projection. Type projection is usually the argument to another type in a type usage. For example, in the type Array<out Number>
, out Number
is the covariant projection of the type represented by the class Number
.
data class KTypeProjection
Represents a value with lazy initialization.
interface Lazy<out T>
Hash table based implementation of the MutableMap interface, which additionally preserves the insertion order of entries during the iteration.
class LinkedHashMap<K, V> : MutableMap<K, V>
typealias LinkedHashMap<K, V> = LinkedHashMap<K, V>
open class LinkedHashMap<K, V> : HashMap<K, V>, MutableMap<K, V>
typealias LinkedHashMap<K, V> = HashMap<K, V>
The implementation of the MutableSet interface, backed by a LinkedHashMap instance.
class LinkedHashSet<E> : MutableSet<E>
typealias LinkedHashSet<E> = LinkedHashSet<E>
open class LinkedHashSet<E> : HashSet<E>, MutableSet<E>
typealias LinkedHashSet<V> = HashSet<V>
Exposes the JavaScript LinkStyle to Kotlin
interface LinkStyle
A generic ordered collection of elements. Methods in this interface support only read-only access to the list; read/write access is supported through the MutableList interface.
interface List<out E> : Collection<E>
An iterator over a collection that supports indexed access.
interface ListIterator<out T> : Iterator<T>
Exposes the JavaScript Location to Kotlin
abstract class Location
An array of longs. When targeting the JVM, instances of this class are represented as long[]
.
class LongArray
An iterator over a sequence of values of type Long
.
abstract class LongIterator : Iterator<Long>
A progression of values of type Long
.
open class LongProgression : Iterable<Long>
A collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key. Methods in this interface support only read-only access to the map; read-write access is supported through the MutableMap interface.
interface Map<K, out V>
Represents the results from a single capturing group within a MatchResult of Regex.
class MatchGroup
data class MatchGroup
Represents a collection of captured groups in a single match of a regular expression.
interface MatchGroupCollection : Collection<MatchGroup?>
Extends MatchGroupCollection by introducing a way to get matched groups by name, when regex supports it.
interface MatchNamedGroupCollection : MatchGroupCollection
Represents the results from a single regular expression match.
interface MatchResult
Exposes the JavaScript Math object to Kotlin.
object Math
Exposes the JavaScript MediaDeviceInfo to Kotlin
abstract class MediaDeviceInfo
interface MediaDeviceKind
interface MediaEncryptedEventInit : EventInit
Exposes the JavaScript MediaError to Kotlin
abstract class MediaError
interface MediaKeyMessageEventInit : EventInit
interface MediaKeyMessageType
abstract class MediaKeys
interface MediaKeySessionType
interface MediaKeysRequirement
interface MediaKeyStatus
abstract class MediaKeyStatusMap
abstract class MediaKeySystemAccess
interface MediaKeySystemConfiguration
interface MediaKeySystemMediaCapability
abstract class MediaList : ItemArrayLike<String>
interface MediaProvider
interface MediaQueryListEventInit : EventInit
Exposes the JavaScript MediaStreamConstraints to Kotlin
interface MediaStreamConstraints
interface MediaStreamTrackEventInit : EventInit
interface MediaStreamTrackState
interface MediaTrackCapabilities
Exposes the JavaScript MediaTrackConstraints to Kotlin
interface MediaTrackConstraints : MediaTrackConstraintSet
interface MediaTrackConstraintSet
Exposes the JavaScript MediaTrackSettings to Kotlin
interface MediaTrackSettings
Exposes the JavaScript MediaTrackSupportedConstraints to Kotlin
interface MediaTrackSupportedConstraints
Exposes the JavaScript MessageChannel to Kotlin
open class MessageChannel
interface MessageEventInit : EventInit
This annotation is present on any class file produced by the Kotlin compiler and is read by the compiler and reflection. Parameters have very short JVM names on purpose: these names appear in all generated class files, and we'd like to reduce their size.
annotation class Metadata
Exposes the JavaScript MimeType to Kotlin
abstract class MimeType
Exposes the JavaScript MimeTypeArray to Kotlin
abstract class MimeTypeArray : ItemArrayLike<MimeType>
interface MouseEventInit : EventModifierInit
This meta-annotation determines that an annotation is a part of public API and therefore should be included in the generated documentation for the element to which the annotation is applied.
annotation class MustBeDocumented
A generic collection of elements that supports adding and removing elements.
interface MutableCollection<E> : Collection<E>, MutableIterable<E>
Mutable concurrently accessible data buffer. Could be accessed from several workers simulteniously.
class MutableData
Represents a key/value pair held by a MutableMap.
interface MutableEntry<K, V> : Entry<K, V>
Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over and that supports removing elements during iteration.
interface MutableIterable<out T> : Iterable<T>
An iterator over a mutable collection. Provides the ability to remove elements while iterating.
interface MutableIterator<out T> : Iterator<T>
A generic ordered collection of elements that supports adding and removing elements.
interface MutableList<E> : List<E>, MutableCollection<E>
An iterator over a mutable collection that supports indexed access. Provides the ability to add, modify and remove elements while iterating.
interface MutableListIterator<T> : ListIterator<T>, MutableIterator<T>
A modifiable collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key.
interface MutableMap<K, V> : Map<K, V>
A generic unordered collection of elements that does not support duplicate elements, and supports adding and removing elements.
interface MutableSet<E> : Set<E>, MutableCollection<E>
Exposes the JavaScript MutationObserver to Kotlin
open class MutationObserver
Exposes the JavaScript MutationObserverInit to Kotlin
interface MutationObserverInit
Exposes the JavaScript MutationRecord to Kotlin
abstract class MutationRecord
Exposes the JavaScript NamedNodeMap to Kotlin
abstract class NamedNodeMap : ItemArrayLike<Attr>
interface NativeFreeablePlacement : NativePlacement
annotation class nativeGetter
object nativeHeap : NativeFreeablePlacement
annotation class nativeInvoke
interface NativePlacement
The entity which has an associated native pointer. Subtypes are supposed to represent interpretations of the pointed data or code.
open class NativePointed
annotation class nativeSetter
Exposes the JavaScript Navigator to Kotlin
abstract class Navigator : NavigatorID, NavigatorLanguage, NavigatorOnLine, NavigatorContentUtils, NavigatorCookies, NavigatorPlugins, NavigatorConcurrentHardware
Exposes the JavaScript NavigatorConcurrentHardware to Kotlin
interface NavigatorConcurrentHardware
interface NavigatorContentUtils
interface NavigatorCookies
Exposes the JavaScript NavigatorID to Kotlin
interface NavigatorID
Exposes the JavaScript NavigatorLanguage to Kotlin
interface NavigatorLanguage
Exposes the JavaScript NavigatorOnLine to Kotlin
interface NavigatorOnLine
Exposes the JavaScript NavigatorPlugins to Kotlin
interface NavigatorPlugins
Exposes the JavaScript NodeFilter to Kotlin
interface NodeFilter
Exposes the JavaScript NodeIterator to Kotlin
abstract class NodeIterator
Exposes the JavaScript NodeList to Kotlin
abstract class NodeList : ItemArrayLike<Node>
Exposes the JavaScript NonDocumentTypeChildNode to Kotlin
interface NonDocumentTypeChildNode
interface NonElementParentNode
Nothing has no instances. You can use Nothing to represent "a value that never exists": for example, if a function has the return type of Nothing, it means that it never returns (always throws an exception).
class Nothing
interface NotificationAction
interface NotificationDirection
interface NotificationEventInit : ExtendableEventInit
interface NotificationOptions
interface NotificationPermission
Superclass for all platform classes representing numeric values.
abstract class Number
Makes Kotlin method in Objective-C class accessible through Objective-C dispatch to be used as action sent by control in UIKit or AppKit.
annotation class ObjCAction
interface ObjCClass : ObjCObject
interface ObjCClassOf<T : ObjCObject> : ObjCClass
annotation class ObjCConstructor
annotation class ObjCFactory
annotation class ObjCMethod
interface ObjCObject
abstract class ObjCObjectBase : ObjCObject
Makes Kotlin property in Objective-C class settable through Objective-C dispatch to be used as IB outlet.
annotation class ObjCOutlet
interface ObjCProtocol : ObjCObject
Implements the core logic of a property delegate for a read/write property that calls callback functions when changed.
abstract class ObservableProperty<V> : ReadWriteProperty<Any?, V>
Allows to use the API denoted by the given markers in the annotated file, declaration, or expression. If a declaration is annotated with OptIn, its usages are not required to opt in to that API.
annotation class OptIn
Marks an expected annotation class that it isn't required to have actual counterparts in all platforms.
annotation class OptionalExpectation
interface OverconstrainedErrorEventInit : EventInit
Enables overload selection based on the type of the value returned from lambda argument.
annotation class OverloadResolutionByLambdaReturnType
interface PageTransitionEventInit : EventInit
Represents a generic pair of two values.
data class Pair<out A, out B> : Serializable
Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).
annotation class ParameterName
Exposes the JavaScript ParentNode to Kotlin
interface ParentNode
Exposes the JavaScript Path2D to Kotlin
open class Path2D : CanvasPath
Exposes the JavaScript PerformanceNavigation to Kotlin
abstract class PerformanceNavigation
Exposes the JavaScript PerformanceTiming to Kotlin
abstract class PerformanceTiming
data class Pinned<out T : Any>
Object describing the current platform program executes upon.
object Platform
Exposes the JavaScript Plugin to Kotlin
abstract class Plugin : ItemArrayLike<MimeType>
Exposes the JavaScript PluginArray to Kotlin
abstract class PluginArray : ItemArrayLike<Plugin>
interface PointerEventInit : MouseEventInit
interface PopStateEventInit : EventInit
interface PremultiplyAlpha
interface ProgressEventInit : EventInit
Exposes the JavaScript Promise object to Kotlin.
open class Promise<out T>
interface PromiseRejectionEventInit : EventInit
Base interface that can be used for implementing property delegate providers.
fun interface PropertyDelegateProvider<in T, out D>
When applied to a class or a member with internal visibility allows to use it from public inline functions and makes it effectively public.
annotation class PublishedApi
Instructs the Kotlin compiler to treat annotated Java class as pure implementation of given Kotlin interface. "Pure" means here that each type parameter of class becomes non-platform type argument of that interface.
annotation class PurelyImplements
An abstract class that is implemented by random number generator algorithms.
abstract class Random
Marker interface indicating that the List implementation supports fast indexed access.
interface RandomAccess
typealias RandomAccess = RandomAccess
Exposes the JavaScript Range to Kotlin
open class Range
Base interface that can be used for implementing property delegates of read-only properties.
fun interface ReadOnlyProperty<in T, out V>
Base interface that can be used for implementing property delegates of read-write properties.
interface ReadWriteProperty<in T, V> : ReadOnlyProperty<T, V>
interface ReadyState
Represents a compiled regular expression. Provides functions to match strings in text with a pattern, replace the found occurrences and split text around matches.
class Regex
class Regex : Serializable
Exposes the JavaScript RegExp object to Kotlin.
class RegExp
Represents the return value of RegExp.exec.
interface RegExpMatch
interface RegistrationOptions
interface RelatedEventInit : EventInit
interface RenderingContext
This meta-annotation determines that an annotation is applicable twice or more on a single code element
annotation class Repeatable
Specifies a code fragment that can be used to replace a deprecated function, property or class. Tools such as IDEs can automatically apply the replacements specified through this annotation.
annotation class ReplaceWith
Exposes the JavaScript Request to Kotlin
open class Request : Body
interface RequestCache
interface RequestCredentials
interface RequestDestination
interface RequestInit
interface RequestMode
interface RequestRedirect
interface RequestType
Signals that the annotated annotation class is a marker of an API that requires an explicit opt-in.
annotation class RequiresOptIn
interface ResizeQuality
Exposes the JavaScript Response to Kotlin
open class Response : Body
interface ResponseInit
interface ResponseType
Classes and interfaces marked with this annotation are restricted when used as receivers for extension suspend
functions. These suspend
extensions can only invoke other member or extension suspend
functions on this particular receiver and are restricted from calling arbitrary suspension functions.
annotation class RestrictsSuspension
Preserve the function entry point during global optimizations.
annotation class Retain
Preserve the function entry point during global optimizations, only for the given target.
annotation class RetainForTarget
This meta-annotation determines whether an annotation is stored in binary output and visible for reflection. By default, both are true.
annotation class Retention
Describes a situation when a function returns normally with a given return value.
interface Returns : SimpleEffect
Describes a situation when a function returns normally with any non-null return value.
interface ReturnsNotNull : SimpleEffect
Exposes the JavaScript Screen to Kotlin
abstract class Screen
interface ScrollBehavior
interface ScrollIntoViewOptions : ScrollOptions
interface ScrollLogicalPosition
interface ScrollOptions
interface ScrollRestoration
Exposes the JavaScript ScrollToOptions to Kotlin
interface ScrollToOptions : ScrollOptions
interface SelectionMode
A sequence that returns values through its iterator. The values are evaluated lazily, and the sequence is potentially infinite.
interface Sequence<out T>
interface ServiceWorkerMessageEventInit : EventInit
interface ServiceWorkerState
A generic unordered collection of elements that does not support duplicate elements. Methods in this interface support only read-only access to the set; read/write access is supported through the MutableSet interface.
interface Set<out E> : Collection<E>
Setter of the property is a set
method declared alongside the property.
interface Setter<V> : KProperty.Accessor<V>, KFunction<Unit>
Setter of the property is a set
method declared alongside the property.
interface Setter<V> : KMutableProperty.Setter<V>, (V) -> Unit
Setter of the property is a set
method declared alongside the property.
interface Setter<T, V> : KMutableProperty.Setter<V>, (T, V) -> Unit
Setter of the property is a set
method declared alongside the property.
interface Setter<D, E, V> : KMutableProperty.Setter<V>, (D, E, V) -> Unit
interface Settings
open class ShadowAnimation
interface ShadowRootInit
interface ShadowRootMode
Marks a top level property with a backing field as immutable. It is possible to share the value of such property between multiple threads, but it becomes deeply frozen, so no changes can be made to its state or the state of objects it refers to.
annotation class SharedImmutable
An array of shorts. When targeting the JVM, instances of this class are represented as short[]
.
class ShortArray
An iterator over a sequence of values of type Short
.
abstract class ShortIterator : Iterator<Short>
An effect that can be observed after a function invocation.
interface SimpleEffect : Effect
Specifies the first version of Kotlin where a declaration has appeared. Using the declaration and specifying an older API version (via the -api-version
command line option) will result in an error.
annotation class SinceKotlin
Exposes the JavaScript Slotable to Kotlin
interface Slotable
This class provides a way to create a stable handle to any Kotlin object. After converting to CPointer it can be safely passed to native code e.g. to be received in a Kotlin callback.
class StableRef<out T : Any>
Exposes the JavaScript Storage to Kotlin
abstract class Storage
interface StorageEventInit : EventInit
Marks the JVM method generated from the annotated function as strictfp
, meaning that the precision of floating point operations performed inside the method needs to be restricted in order to achieve better portability.
annotation class Strictfp
The String
class represents character strings. All string literals in Kotlin programs, such as "abc"
, are implemented as instances of this class.
class String : Comparable<String>, CharSequence
A mutable sequence of characters.
class StringBuilder : Appendable, CharSequence
typealias StringBuilder = StringBuilder
class StringBuilder : CharSequence, Appendable
Exposes the JavaScript StyleSheet to Kotlin
abstract class StyleSheet
Exposes the JavaScript StyleSheetList to Kotlin
abstract class StyleSheetList : ItemArrayLike<StyleSheet>
Suppresses the given compilation warnings in the annotated element.
annotation class Suppress
Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.
interface SuspendFunction<out R>
Exposes the JavaScript SVGAngle to Kotlin
abstract class SVGAngle
Exposes the JavaScript SVGAnimatedAngle to Kotlin
abstract class SVGAnimatedAngle
Exposes the JavaScript SVGAnimatedBoolean to Kotlin
abstract class SVGAnimatedBoolean
Exposes the JavaScript SVGAnimatedEnumeration to Kotlin
abstract class SVGAnimatedEnumeration
Exposes the JavaScript SVGAnimatedInteger to Kotlin
abstract class SVGAnimatedInteger
Exposes the JavaScript SVGAnimatedLength to Kotlin
abstract class SVGAnimatedLength
Exposes the JavaScript SVGAnimatedLengthList to Kotlin
abstract class SVGAnimatedLengthList
Exposes the JavaScript SVGAnimatedNumber to Kotlin
abstract class SVGAnimatedNumber
Exposes the JavaScript SVGAnimatedNumberList to Kotlin
abstract class SVGAnimatedNumberList
Exposes the JavaScript SVGAnimatedPoints to Kotlin
interface SVGAnimatedPoints
Exposes the JavaScript SVGAnimatedPreserveAspectRatio to Kotlin
abstract class SVGAnimatedPreserveAspectRatio
Exposes the JavaScript SVGAnimatedRect to Kotlin
abstract class SVGAnimatedRect
Exposes the JavaScript SVGAnimatedString to Kotlin
abstract class SVGAnimatedString
Exposes the JavaScript SVGAnimatedTransformList to Kotlin
abstract class SVGAnimatedTransformList
interface SVGBoundingBoxOptions
interface SVGElementInstance
interface SVGFitToViewBox
Exposes the JavaScript SVGLength to Kotlin
abstract class SVGLength
Exposes the JavaScript SVGLengthList to Kotlin
abstract class SVGLengthList
abstract class SVGNameList
Exposes the JavaScript SVGNumber to Kotlin
abstract class SVGNumber
Exposes the JavaScript SVGNumberList to Kotlin
abstract class SVGNumberList
abstract class SVGPointList
Exposes the JavaScript SVGPreserveAspectRatio to Kotlin
abstract class SVGPreserveAspectRatio
Exposes the JavaScript SVGStringList to Kotlin
abstract class SVGStringList
Exposes the JavaScript SVGTests to Kotlin
interface SVGTests
Exposes the JavaScript SVGTransform to Kotlin
abstract class SVGTransform
Exposes the JavaScript SVGTransformList to Kotlin
abstract class SVGTransformList
Exposes the JavaScript SVGUnitTypes to Kotlin
interface SVGUnitTypes
Exposes the JavaScript SVGURIReference to Kotlin
interface SVGURIReference
Exposes the JavaScript SVGZoomAndPan to Kotlin
interface SVGZoomAndPan
Forces the compiler to use specified symbol name for the target external
function.
annotation class SymbolName
Marks the JVM method generated from the annotated function as synchronized
, meaning that the method will be protected from concurrent execution by multiple threads by the monitor of the instance (or, for static methods, the class) on which the method is defined.
annotation class Synchronized
This meta-annotation indicates the kinds of code elements which are possible targets of an annotation.
annotation class Target
interface TexImageSource
Exposes the JavaScript TextMetrics to Kotlin
abstract class TextMetrics
abstract class TextTrackCueList
interface TextTrackKind
interface TextTrackMode
Marks a top level property with a backing field or an object as thread local. The object remains mutable and it is possible to change its state, but every thread will have a distinct copy of this object, so changes in one thread are not reflected in another.
annotation class ThreadLocal
The base class for all errors and exceptions. Only instances of this class can be thrown or caught.
open class Throwable
This annotation indicates what exceptions should be declared by a function when compiled to a platform method in Kotlin/JVM and Kotlin/Native.
annotation class Throws
typealias Throws = Throws
This annotation indicates what exceptions should be declared by a function when compiled to a JVM method.
annotation class Throws
Data class representing a result of executing an action, along with the duration of elapsed time interval.
data class TimedValue<T>
Represents a time point notched on a particular TimeSource. Remains bound to the time source it was taken from and allows querying for the duration of time elapsed from that point (see the function elapsedNow).
abstract class TimeMark
Exposes the JavaScript TimeRanges to Kotlin
abstract class TimeRanges
A source of time for measuring time intervals.
interface TimeSource
Exposes the JavaScript Touch to Kotlin
abstract class Touch
abstract class TouchList : ItemArrayLike<Touch>
interface TrackEventInit : EventInit
Marks the JVM backing field of the annotated property as transient
, meaning that it is not part of the default serialized form of the object.
annotation class Transient
Exposes the JavaScript TreeWalker to Kotlin
abstract class TreeWalker
Represents a triad of values
data class Triple<out A, out B, out C> : Serializable
Defines names for Unicode symbols used in proper Typography.
object Typography
class UByte : Comparable<UByte>
class UByteArray : Collection<UByte>
An iterator over a sequence of values of type UByte
.
abstract class UByteIterator : Iterator<UByte>
interface UIEventInit : EventInit
class UInt : Comparable<UInt>
Exposes the JavaScript Uint16Array to Kotlin
open class Uint16Array : ArrayBufferView
Exposes the JavaScript Uint32Array to Kotlin
open class Uint32Array : ArrayBufferView
Exposes the JavaScript Uint8Array to Kotlin
open class Uint8Array : ArrayBufferView
Exposes the JavaScript Uint8ClampedArray to Kotlin
open class Uint8ClampedArray : ArrayBufferView
class UIntArray : Collection<UInt>
An iterator over a sequence of values of type UInt
.
abstract class UIntIterator : Iterator<UInt>
A progression of values of type UInt
.
open class UIntProgression : Iterable<UInt>
class ULong : Comparable<ULong>
class ULongArray : Collection<ULong>
An iterator over a sequence of values of type ULong
.
abstract class ULongIterator : Iterator<ULong>
A progression of values of type ULong
.
open class ULongProgression : Iterable<ULong>
interface ULongRange
interface UnionAudioTrackOrTextTrackOrVideoTrack
interface UnionClientOrMessagePortOrServiceWorker
interface UnionElementOrHTMLCollection
interface UnionElementOrMouseEvent
interface UnionElementOrProcessingInstruction
interface UnionElementOrRadioNodeList
interface UnionHTMLOptGroupElementOrHTMLOptionElement
interface UnionMessagePortOrServiceWorker
interface UnionMessagePortOrWindowProxy
The type with only one value: the Unit
object. This type corresponds to the void
type in Java.
object Unit
Suppresses errors about variance conflict
annotation class UnsafeVariance
Exposes the JavaScript URLSearchParams to Kotlin
open class URLSearchParams
Allows to use experimental API denoted by the given markers in the annotated file, declaration, or expression. If a declaration is annotated with UseExperimental, its usages are not required to opt-in to that experimental API.
annotation class UseExperimental
class UShort : Comparable<UShort>
class UShortArray : Collection<UShort>
An iterator over a sequence of values of type UShort
.
abstract class UShortIterator : Iterator<UShort>
Exposes the JavaScript ValidityState to Kotlin
abstract class ValidityState
class Vector128
interface VideoFacingModeEnum
interface VideoResizeModeEnum
Exposes the JavaScript VideoTrack to Kotlin
abstract class VideoTrack : UnionAudioTrackOrTextTrackOrVideoTrack
Marks the JVM backing field of the annotated property as volatile
, meaning that writes to this field are immediately made visible to other threads.
annotation class Volatile
Class WeakReference encapsulates weak reference to an object, which could be used to either retrieve a strong reference to an object, or return null, if object was already destroyed by the memory manager.
class WeakReference<T : Any>
Exposes the JavaScript WebGLActiveInfo to Kotlin
abstract class WebGLActiveInfo
interface WebGLContextAttributes
interface WebGLContextEventInit : EventInit
abstract class WebGLObject
Exposes the JavaScript WebGLRenderingContext to Kotlin
abstract class WebGLRenderingContext : WebGLRenderingContextBase, RenderingContext
interface WebGLRenderingContextBase
Exposes the JavaScript WebGLShaderPrecisionFormat to Kotlin
abstract class WebGLShaderPrecisionFormat
Exposes the JavaScript WebGLUniformLocation to Kotlin
abstract class WebGLUniformLocation
interface WheelEventInit : MouseEventInit
Exposes the JavaScript WindowEventHandlers to Kotlin
interface WindowEventHandlers
Exposes the JavaScript WindowLocalStorage to Kotlin
interface WindowLocalStorage
Exposes the JavaScript WindowOrWorkerGlobalScope to Kotlin
interface WindowOrWorkerGlobalScope
Exposes the JavaScript WindowSessionStorage to Kotlin
interface WindowSessionStorage
Class representing worker.
class Worker
A frozen shared reference to a Kotlin object.
class WorkerBoundReference<out T : Any>
Exposes the JavaScript WorkerLocation to Kotlin
abstract class WorkerLocation
Exposes the JavaScript WorkerNavigator to Kotlin
abstract class WorkerNavigator : NavigatorID, NavigatorLanguage, NavigatorOnLine, NavigatorConcurrentHardware
interface WorkerOptions
interface WorkerType
interface XMLHttpRequestResponseType
Exposes the JavaScript XMLSerializer to Kotlin
open class XMLSerializer
© 2010–2020 JetBrains s.r.o. and Kotlin Programming Language contributors
Licensed under the Apache License, Version 2.0.
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/index.html