Any
The root of the Kotlin class hierarchy. Every Kotlin class has Any as a superclass.
Constructors
Functions
equals
Indicates whether some other object is "equal to" this one. Implementations must fulfil the following requirements:
open operator fun equals(other: Any?): Boolean
hashCode
Returns a hash code value for the object. The general contract of hashCode
is:
open fun hashCode(): Int
toString
Returns a string representation of the object.
open fun toString(): String
Extension Properties
isFrozen
Checks if given object is null or frozen or permanent (i.e. instantiated at compile-time).
val Any?.isFrozen: Boolean
Extension Functions
also
Calls the specified function block with this
value as its argument and returns this
value.
fun <T> T.also(block: (T) -> Unit): T
apply
Calls the specified function block with this
value as its receiver and returns this
value.
fun <T> T.apply(block: T.() -> Unit): T
asDynamic
Reinterprets this value as a value of the dynamic type.
fun Any?.asDynamic(): dynamic
ensureNeverFrozen
This function ensures that if we see such an object during freezing attempt - freeze fails and FreezingException is thrown.
fun Any.ensureNeverFrozen()
freeze
Freezes object subgraph reachable from this object. Frozen objects can be freely shared between threads/workers.
fun <T> T.freeze(): T
hashCode
Returns a hash code value for the object or zero if the object is null
.
fun Any?.hashCode(): Int
identityHashCode
Compute stable wrt potential object relocations by the memory manager identity hash code.
fun Any?.identityHashCode(): Int
iterator
Allows to iterate this dynamic
object in the following cases:
operator fun dynamic.iterator(): Iterator<dynamic>
let
Calls the specified function block with this
value as its argument and returns its result.
fun <T, R> T.let(block: (T) -> R): R
run
Calls the specified function block with this
value as its receiver and returns its result.
fun <T, R> T.run(block: T.() -> R): R
runCatching
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>
takeIf
Returns this
value if it satisfies the given predicate or null
, if it doesn't.
fun <T> T.takeIf(predicate: (T) -> Boolean): T?
takeUnless
Returns this
value if it does not satisfy the given predicate or null
, if it does.
fun <T> T.takeUnless(predicate: (T) -> Boolean): T?
unsafeCast
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
Inheritors
AbstractCollection
Provides a skeletal implementation of the read-only Collection interface.
abstract class AbstractCollection<out E> : Collection<E>
AbstractCoroutineContextElement
Base class for CoroutineContext.Element implementations.
abstract class AbstractCoroutineContextElement : Element
AbstractCoroutineContextKey
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>
AbstractIterator
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>
AbstractMutableCollection
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> :
MutableCollection<E>,
AbstractCollection<E>
AbstractMutableList
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>
AbstractMutableMap
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>
AbstractMutableSet
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>
AbstractWorker
Exposes the JavaScript AbstractWorker to Kotlin
interface AbstractWorker
Accessor
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>
AddEventListenerOptions
interface AddEventListenerOptions : EventListenerOptions
Annotation
Base interface implicitly implemented by all annotation interfaces. See Kotlin language documentation for more information on annotations.
interface Annotation
Appendable
An object to which char sequences and values can be appended.
interface Appendable
typealias Appendable = Appendable
AppendMode
interface AppendMode
ArenaManager
object ArenaManager
Array
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>
ArrayBuffer
Exposes the JavaScript ArrayBuffer to Kotlin
open class ArrayBuffer : BufferDataSource
ArrayBufferView
Exposes the JavaScript ArrayBufferView to Kotlin
interface ArrayBufferView : BufferDataSource
ArrayList
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>
AssignedNodesOptions
interface AssignedNodesOptions
AssociatedObjectKey
Makes the annotated annotation class an associated object key.
annotation class AssociatedObjectKey
AtomicArray
An Array in which elements are always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicArray<T>
AtomicInt
An Int value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicInt
AtomicInt
An Int value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicInt
AtomicIntArray
An IntArray in which elements are always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicIntArray
AtomicLong
A Long value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicLong
AtomicLong
A Long value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicLong
AtomicLongArray
An LongArray in which elements are always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicLongArray
AtomicNativePtr
A kotlinx.cinterop.NativePtr value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicNativePtr
AtomicNativePtr
A kotlinx.cinterop.NativePtr value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicNativePtr
AtomicReference
An object reference that is always updated atomically.
class AtomicReference<T>
AtomicReference
An object reference that is always updated atomically.
class AtomicReference<T>
AudioTrack
Exposes the JavaScript AudioTrack to Kotlin
abstract class AudioTrack :
UnionAudioTrackOrTextTrackOrVideoTrack
AutoCloseable
A resource that can be closed or released.
interface AutoCloseable
typealias AutoCloseable = AutoCloseable
BarProp
abstract class BarProp
Base64
Provides Base64 encoding and decoding functionality.
Base64 encoding, as defined by the RFC 4648
and a few other RFCs,
transforms arbitrary binary data into a sequence of printable characters.
open class Base64
BetaInteropApi
Marks Objective-C and Swift interoperability API as Beta.
annotation class BetaInteropApi
BinaryType
interface BinaryType
BitSet
A vector of bits growing if necessary and allowing one to set/clear/read bits from it by a bit index.
class BitSet
Blob
Exposes the JavaScript Blob to Kotlin
open class Blob : MediaProvider, ImageBitmapSource
BlobPropertyBag
interface BlobPropertyBag
Boolean
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>
BooleanArray
An array of booleans. When targeting the JVM, instances of this class are represented as boolean[]
.
class BooleanArray
BooleanIterator
An iterator over a sequence of values of type Boolean
.
abstract class BooleanIterator : Iterator<Boolean>
BoxQuadOptions
interface BoxQuadOptions
BufferDataSource
interface BufferDataSource
BuilderInference
Allows to infer generic type arguments of a function from the calls in the annotated function parameter of that function.
annotation class BuilderInference
ByteArray
An array of bytes. When targeting the JVM, instances of this class are represented as byte[]
.
class ByteArray
ByteIterator
An iterator over a sequence of values of type Byte
.
abstract class ByteIterator : Iterator<Byte>
CacheBatchOperation
interface CacheBatchOperation
CacheQueryOptions
interface CacheQueryOptions
CacheStorage
Exposes the JavaScript CacheStorage to Kotlin
abstract class CacheStorage
CallsInPlace
An effect of calling a functional parameter in place.
interface CallsInPlace : Effect
CanPlayTypeResult
interface CanPlayTypeResult
CanvasCompositing
interface CanvasCompositing
CanvasDirection
interface CanvasDirection
CanvasDrawImage
interface CanvasDrawImage
CanvasDrawPath
interface CanvasDrawPath
CanvasFillRule
interface CanvasFillRule
CanvasFillStrokeStyles
interface CanvasFillStrokeStyles
CanvasFilters
interface CanvasFilters
CanvasGradient
Exposes the JavaScript CanvasGradient to Kotlin
abstract class CanvasGradient
CanvasHitRegion
interface CanvasHitRegion
CanvasImageData
interface CanvasImageData
CanvasImageSmoothing
interface CanvasImageSmoothing
CanvasImageSource
interface CanvasImageSource : ImageBitmapSource
CanvasLineCap
interface CanvasLineCap
CanvasLineJoin
interface CanvasLineJoin
CanvasPath
interface CanvasPath
CanvasPathDrawingStyles
interface CanvasPathDrawingStyles
CanvasPattern
Exposes the JavaScript CanvasPattern to Kotlin
abstract class CanvasPattern
CanvasRect
interface CanvasRect
CanvasRenderingContext2D
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
CanvasRenderingContext2DSettings
interface CanvasRenderingContext2DSettings
CanvasShadowStyles
interface CanvasShadowStyles
CanvasState
interface CanvasState
CanvasText
interface CanvasText
CanvasTextAlign
interface CanvasTextAlign
CanvasTextBaseline
interface CanvasTextBaseline
CanvasTextDrawingStyles
interface CanvasTextDrawingStyles
CanvasTransform
interface CanvasTransform
CanvasUserInterface
interface CanvasUserInterface
Capabilities
interface Capabilities
CaretPosition
Exposes the JavaScript CaretPosition to Kotlin
abstract class CaretPosition
CCall
annotation class CCall
CEnum
interface CEnum
CEnumEntryAlias
Denotes property that is an alias to some enum entry.
annotation class CEnumEntryAlias
CEnumVarTypeSize
Stores instance size of the type T: CEnumVar.
annotation class CEnumVarTypeSize
Char
Represents a 16-bit Unicode character.
On the JVM, non-nullable values of this type are represented as values of the primitive type char
.
class Char : Comparable<Char>
CharArray
An array of chars. When targeting the JVM, instances of this class are represented as char[]
.
class CharArray
CharIterator
An iterator over a sequence of values of type Char
.
abstract class CharIterator : Iterator<Char>
CharProgression
A progression of values of type Char
.
open class CharProgression : Iterable<Char>
CharSequence
Represents a readable sequence of Char values.
interface CharSequence
Charsets
Constant definitions for the standard charsets. These charsets are guaranteed to be available on every implementation of the Java platform.
object Charsets
Cleaner
The marker interface for objects that have a cleanup action associated with them.
sealed interface Cleaner
Client
Exposes the JavaScript Client to Kotlin
abstract class Client :
UnionClientOrMessagePortOrServiceWorker
ClientQueryOptions
interface ClientQueryOptions
ClientType
interface ClientType
ClipboardEventInit
interface ClipboardEventInit : EventInit
ClipboardPermissionDescriptor
interface ClipboardPermissionDescriptor
ClosedFloatingPointRange
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>
ClosedRange
Represents a range of values (for example, numbers or characters) where both the lower and upper bounds are included in the range. See the Kotlin language documentation for more information.
interface ClosedRange<T : Comparable<T>>
CloseEventInit
interface CloseEventInit : EventInit
CName
Makes top level function available from C/C++ code with the given name.
annotation class CName
Collection
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>
ColorSpaceConversion
interface ColorSpaceConversion
Comparable
Classes which inherit from this interface have a defined total ordering between their instances.
interface Comparable<in T>
ComparableTimeMark
A TimeMark that can be compared for difference with other time marks obtained from the same TimeSource.WithComparableMarks time source.
interface ComparableTimeMark :
TimeMark,
Comparable<ComparableTimeMark>
Comparator
Provides a comparison function for imposing a total ordering between instances of the type T.
fun interface Comparator<T>
typealias Comparator<T> = Comparator<T>
CompositionEventInit
interface CompositionEventInit : UIEventInit
ConditionalEffect
An effect of some condition being true after observing another effect of a function.
interface ConditionalEffect : Effect
ConsistentCopyVisibility
In previous versions of Kotlin, the generated 'copy' method of a data class always had public visibility, even if the primary constructor was non-public. That exposed the non-public constructor of the data class.
annotation class ConsistentCopyVisibility
Console
Exposes the console API to Kotlin.
interface Console
ConstantValue
Collection of annotations that allow to store constant values.
object ConstantValue
ConstrainablePattern
interface ConstrainablePattern
ConstrainBooleanParameters
Exposes the JavaScript ConstrainBooleanParameters to Kotlin
interface ConstrainBooleanParameters
ConstrainDOMStringParameters
Exposes the JavaScript ConstrainDOMStringParameters to Kotlin
interface ConstrainDOMStringParameters
ConstrainDoubleRange
interface ConstrainDoubleRange : DoubleRange
Constraints
interface Constraints : ConstraintSet
ConstraintSet
interface ConstraintSet
ConstrainULongRange
interface ConstrainULongRange : ULongRange
ContextFunctionTypeParams
Signifies that the annotated functional type has the prefix of size count
for context receivers.
Thus, @ContextFunctionTypeParams(2) @ExtensionFunctionType Function4<String, Int, Double, Byte, Unit>
is a normalized representation of
context(String, Int) Double.(Byte) -> Unit
.
annotation class ContextFunctionTypeParams
Continuation
Interface representing a continuation after a suspension point that returns a value of type T
.
interface Continuation<in T>
Continuation0
class Continuation0 : () -> Unit
Continuation1
class Continuation1<T1> : (T1) -> Unit
Continuation2
class Continuation2<T1, T2> : (T1, T2) -> Unit
ContinuationInterceptor
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
ContractBuilder
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
ConvertCoordinateOptions
interface ConvertCoordinateOptions
CopyActionContext
Context for the copyAction
function passed to Path.copyToRecursively.
interface CopyActionContext
CPlusPlusClass
interface CPlusPlusClass
CSSBoxType
interface CSSBoxType
CSSRuleList
Exposes the JavaScript CSSRuleList to Kotlin
abstract class CSSRuleList : ItemArrayLike<CSSRule>
CSSStyleDeclaration
Exposes the JavaScript CSSStyleDeclaration to Kotlin
abstract class CSSStyleDeclaration : ItemArrayLike<String>
CStruct
annotation class CStruct
CustomElementRegistry
Exposes the JavaScript CustomElementRegistry to Kotlin
abstract class CustomElementRegistry
CustomEventInit
interface CustomEventInit : EventInit
DataTransfer
Exposes the JavaScript DataTransfer to Kotlin
abstract class DataTransfer
DataTransferItem
Exposes the JavaScript DataTransferItem to Kotlin
abstract class DataTransferItem
DataTransferItemList
Exposes the JavaScript DataTransferItemList to Kotlin
abstract class DataTransferItemList
DataView
Exposes the JavaScript DataView to Kotlin
open class DataView : ArrayBufferView
Debugging
Note: this API is unstable and may change in any release.
object Debugging
DeepRecursiveFunction
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>
DeepRecursiveScope
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>
DeferScope
open class DeferScope
Delegates
Standard property delegates.
object Delegates
Deprecated
Marks the annotated declaration as deprecated.
annotation class Deprecated
DeprecatedSinceKotlin
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
DetachedObjectGraph
Detached object graph encapsulates transferrable detached subgraph which cannot be accessed externally, until it is attached with the attach extension function.
class DetachedObjectGraph<T>
DocumentAndElementEventHandlers
interface DocumentAndElementEventHandlers
DocumentOrShadowRoot
Exposes the JavaScript DocumentOrShadowRoot to Kotlin
interface DocumentOrShadowRoot
DocumentReadyState
interface DocumentReadyState
DOMImplementation
Exposes the JavaScript DOMImplementation to Kotlin
abstract class DOMImplementation
DOMMatrixReadOnly
Exposes the JavaScript DOMMatrixReadOnly to Kotlin
open class DOMMatrixReadOnly
DOMPointInit
Exposes the JavaScript DOMPointInit to Kotlin
interface DOMPointInit
DOMPointReadOnly
Exposes the JavaScript DOMPointReadOnly to Kotlin
open class DOMPointReadOnly
DOMRectInit
interface DOMRectInit
DOMRectList
interface DOMRectList : ItemArrayLike<DOMRect>
DOMRectReadOnly
Exposes the JavaScript DOMRectReadOnly to Kotlin
open class DOMRectReadOnly
DOMStringMap
Exposes the JavaScript DOMStringMap to Kotlin
abstract class DOMStringMap
DOMTokenList
Exposes the JavaScript DOMTokenList to Kotlin
abstract class DOMTokenList : ItemArrayLike<String>
DoubleArray
An array of doubles. When targeting the JVM, instances of this class are represented as double[]
.
class DoubleArray
DoubleIterator
An iterator over a sequence of values of type Double
.
abstract class DoubleIterator : Iterator<Double>
DoubleRange
Exposes the JavaScript DoubleRange to Kotlin
interface DoubleRange
DragEventInit
interface DragEventInit : MouseEventInit
DslMarker
When applied to annotation class X specifies that X defines a DSL language
annotation class DslMarker
Duration
Represents the amount of time one instant of time is away from another instant.
class Duration : Comparable<Duration>
EagerInitialization
Forces a top-level property to be initialized eagerly, opposed to lazily on the first access to file and/or property.
annotation class EagerInitialization
EagerInitialization
Forces a top-level property to be initialized eagerly, opposed to lazily on the first access to file and/or property. This annotation can be used as temporal migration assistance during the transition from the previous Kotlin/Native initialization scheme "eager by default" to the new one, "lazy by default".
annotation class EagerInitialization
Effect
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
ElementContentEditable
interface ElementContentEditable
ElementCreationOptions
interface ElementCreationOptions
ElementCSSInlineStyle
interface ElementCSSInlineStyle
ElementDefinitionOptions
interface ElementDefinitionOptions
EmptyCoroutineContext
An empty coroutine context.
object EmptyCoroutineContext : CoroutineContext, Serializable
EndOfStreamError
interface EndOfStreamError
Enum
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>
EnumEntries
A specialized immutable implementation of List interface that contains all enum entries of the specified enum type E. EnumEntries contains all enum entries in the order they are declared in the source code, consistently with the corresponding Enum.ordinal values.
ErrorEventInit
interface ErrorEventInit : EventInit
EventInit
interface EventInit
EventListener
Exposes the JavaScript EventListener to Kotlin
interface EventListener
EventListenerOptions
interface EventListenerOptions
EventModifierInit
interface EventModifierInit : UIEventInit
EventSourceInit
interface EventSourceInit
EventTarget
Exposes the JavaScript EventTarget to Kotlin
abstract class EventTarget
ExperimentalAssociatedObjects
The experimental marker for associated objects API.
annotation class ExperimentalAssociatedObjects
ExperimentalContracts
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
ExperimentalEncodingApi
This annotation marks the experimental API for encoding and decoding between binary data and printable ASCII character sequences.
annotation class ExperimentalEncodingApi
ExperimentalForeignApi
Marks foreign-language-related API as experimental.
annotation class ExperimentalForeignApi
ExperimentalJsCollectionsApi
This annotation marks the experimental JS-collections API that allows to manipulate with native JS-collections The API can be removed completely in any further release.
annotation class ExperimentalJsCollectionsApi
ExperimentalJsExport
Marks experimental JS export annotations.
annotation class ExperimentalJsExport
ExperimentalJsFileName
Marks experimental JsFileName annotation.
annotation class ExperimentalJsFileName
ExperimentalJsReflectionCreateInstance
This annotation marks the experimental Kotlin/JS reflection API that allows to create an instance of provided KClass The API can be removed completely in any further release.
annotation class ExperimentalJsReflectionCreateInstance
ExperimentalJsStatic
Marks the experimental JsStatic annotation.
annotation class ExperimentalJsStatic
ExperimentalMultiplatform
The experimental multiplatform support API marker.
annotation class ExperimentalMultiplatform
ExperimentalNativeApi
This annotation marks the Kotlin/Native-only 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 ExperimentalNativeApi
ExperimentalObjCName
This annotation marks the experimental ObjCName annotation.
annotation class ExperimentalObjCName
ExperimentalObjCRefinement
This annotation marks the experimental Objective-C export refinement annotations.
annotation class ExperimentalObjCRefinement
ExperimentalPathApi
This annotation marks the extensions and top-level functions for working with java.nio.file.Path considered experimental.
annotation class ExperimentalPathApi
ExperimentalReflectionOnLambdas
This annotation marks the experimental kotlin-reflect API that allows to approximate a Kotlin lambda or a function expression instance to a KFunction instance. The behavior of this API may be changed or the API may be removed completely in any further release.
annotation class ExperimentalReflectionOnLambdas
ExperimentalStdlibApi
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
ExperimentalSubclassOptIn
This annotation marks the experimental preview of the language feature SubclassOptInRequired.
annotation class ExperimentalSubclassOptIn
ExperimentalTime
This annotation marks the experimental preview of the standard library API for measuring time and working with durations.
annotation class ExperimentalTime
ExperimentalTypeInference
The experimental marker for type inference augmenting annotations.
annotation class ExperimentalTypeInference
ExperimentalUnsignedTypes
Marks the API that is dependent on the experimental unsigned types, including those types themselves.
annotation class ExperimentalUnsignedTypes
ExperimentalUuidApi
This annotation marks the experimental Kotlin Uuid API.
annotation class ExperimentalUuidApi
ExportObjCClass
Makes Kotlin subclass of Objective-C class visible for runtime lookup
after Kotlin main
function gets invoked.
annotation class ExportObjCClass
ExposedCopyVisibility
In previous versions of Kotlin, the generated 'copy' method of a data class always had public visibility, even if the primary constructor was non-public. That exposed the non-public constructor of the data class.
annotation class ExposedCopyVisibility
ExtendableEventInit
interface ExtendableEventInit : EventInit
ExtendableMessageEventInit
interface ExtendableMessageEventInit : ExtendableEventInit
ExtensionFunctionType
Signifies that the annotated functional type represents an extension function.
annotation class ExtensionFunctionType
External
interface External
ExternalObjCClass
annotation class ExternalObjCClass
FetchEventInit
interface FetchEventInit : ExtendableEventInit
FileList
Exposes the JavaScript FileList to Kotlin
abstract class FileList : ItemArrayLike<File>
FilePropertyBag
interface FilePropertyBag : BlobPropertyBag
FileReaderSync
Exposes the JavaScript FileReaderSync to Kotlin
open class FileReaderSync
FileVisitorBuilder
The builder to provide implementation of the file visitor that fileVisitor builds.
sealed interface FileVisitorBuilder
Float32Array
Exposes the JavaScript Float32Array to Kotlin
open class Float32Array : ArrayBufferView
Float64Array
Exposes the JavaScript Float64Array to Kotlin
open class Float64Array : ArrayBufferView
FloatArray
An array of floats. When targeting the JVM, instances of this class are represented as float[]
.
class FloatArray
FloatIterator
An iterator over a sequence of values of type Float
.
abstract class FloatIterator : Iterator<Float>
FocusEventInit
interface FocusEventInit : UIEventInit
ForeignFetchEventInit
interface ForeignFetchEventInit : ExtendableEventInit
ForeignFetchOptions
interface ForeignFetchOptions
ForeignFetchResponse
interface ForeignFetchResponse
FrameType
interface FrameType
FreezableAtomicReference
This class was useful only with legacy memory manager. Please use AtomicReference instead.
class FreezableAtomicReference<T>
FreezingIsDeprecated
Freezing API is deprecated since 1.7.20.
annotation class FreezingIsDeprecated
Function
Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.
interface Function<out R>
Future
class Future<T>
GC
Note: this API is unstable and may change in any release.
object GC
GCInfo
This class represents statistics about the single run of the garbage collector. It is supposed to be used for testing and debugging purposes only.
class GCInfo
GeometryUtils
Exposes the JavaScript GeometryUtils to Kotlin
interface GeometryUtils
GetNotificationOptions
interface GetNotificationOptions
GetRootNodeOptions
interface GetRootNodeOptions
GetSVGDocument
interface GetSVGDocument
Getter
Getter of the property is a get
method declared alongside the property.
interface Getter<out V> : KProperty.Accessor<V>, KFunction<V>
Getter
Getter of the property is a get
method declared alongside the property.
interface Getter<out V> : KProperty.Getter<V>, () -> V
Getter
Getter of the property is a get
method declared alongside the property.
interface Getter<T, out V> : KProperty.Getter<V>, (T) -> V
Getter
Getter of the property is a get
method declared alongside the property.
interface Getter<D, E, out V> :
KProperty.Getter<V>,
(D, E) -> V
GlobalEventHandlers
Exposes the JavaScript GlobalEventHandlers to Kotlin
interface GlobalEventHandlers
GlobalPerformance
interface GlobalPerformance
Grouping
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>
HashChangeEventInit
interface HashChangeEventInit : EventInit
HashMap
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>
HashSet
The implementation of the MutableSet interface, backed by a InternalMap implementation.
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>
HexFormat
Represents hexadecimal format options for formatting and parsing byte arrays and integer numeric values, both signed and unsigned.
class HexFormat
HiddenFromObjC
Instructs the Kotlin compiler to remove this class, function or property from the public Objective-C API.
annotation class HiddenFromObjC
HidesFromObjC
Meta-annotation that instructs the Kotlin compiler to remove the annotated class, function or property from the public Objective-C API.
annotation class HidesFromObjC
HitRegionOptions
interface HitRegionOptions
HTMLAllCollection
abstract class HTMLAllCollection
HTMLCollection
Exposes the JavaScript HTMLCollection to Kotlin
abstract class HTMLCollection :
ItemArrayLike<Element>,
UnionElementOrHTMLCollection
HTMLHyperlinkElementUtils
Exposes the JavaScript HTMLHyperlinkElementUtils to Kotlin
interface HTMLHyperlinkElementUtils
HTMLOrSVGImageElement
interface HTMLOrSVGImageElement : CanvasImageSource
HTMLOrSVGScriptElement
interface HTMLOrSVGScriptElement
Ignore
annotation class Ignore
ImageBitmap
Exposes the JavaScript ImageBitmap to Kotlin
abstract class ImageBitmap :
CanvasImageSource,
TexImageSource
ImageBitmapOptions
interface ImageBitmapOptions
ImageBitmapRenderingContext
Exposes the JavaScript ImageBitmapRenderingContext to Kotlin
abstract class ImageBitmapRenderingContext
ImageBitmapRenderingContextSettings
interface ImageBitmapRenderingContextSettings
ImageBitmapSource
interface ImageBitmapSource
ImageData
Exposes the JavaScript ImageData to Kotlin
open class ImageData : ImageBitmapSource, TexImageSource
ImageOrientation
interface ImageOrientation
ImageSmoothingQuality
interface ImageSmoothingQuality
ImmutableBlob
An immutable compile-time array of bytes.
class ImmutableBlob
ImplicitlyActualizedByJvmDeclaration
This annotation marks Kotlin expect
declarations that are implicitly actualized by Java.
annotation class ImplicitlyActualizedByJvmDeclaration
IndexedValue
Data class representing a value from a collection or sequence, along with its index in that collection or sequence.
data class IndexedValue<out T>
InputEventInit
interface InputEventInit : UIEventInit
Int16Array
Exposes the JavaScript Int16Array to Kotlin
open class Int16Array : ArrayBufferView
Int32Array
Exposes the JavaScript Int32Array to Kotlin
open class Int32Array : ArrayBufferView
Int8Array
Exposes the JavaScript Int8Array to Kotlin
open class Int8Array : ArrayBufferView
IntArray
An array of ints. When targeting the JVM, instances of this class are represented as int[]
.
class IntArray
InteropStubs
annotation class InteropStubs
IntIterator
An iterator over a sequence of values of type Int
.
abstract class IntIterator : Iterator<Int>
IntProgression
A progression of values of type Int
.
open class IntProgression : Iterable<Int>
ItemArrayLike
interface ItemArrayLike<out T>
Iterable
Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over.
interface Iterable<out T>
Iterator
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>
JsArray
Exposes the JavaScript Array to Kotlin.
open class JsArray<E> : JsReadonlyArray<E>
JsClass
Represents the constructor of a class. Instances of JsClass
can be passed to JavaScript APIs that expect a constructor reference.
interface JsClass<T : Any>
JsExport
Exports top-level declaration on JS platform.
annotation class JsExport
JsExternalArgument
When placed on a function parameter, requires the type of the passed argument to be external.
annotation class JsExternalArgument
JsExternalInheritorsOnly
When placed on an external interface or class, requires all its child interfaces, classes, and objects to be external as well.
annotation class JsExternalInheritorsOnly
JsFileName
Specifies the name of the compiled file produced from the annotated source file instead of the default one.
annotation class JsFileName
JsMap
Exposes the JavaScript Map to Kotlin.
open class JsMap<K, V> : JsReadonlyMap<K, V>
JsModule
Denotes an external
declaration that must be imported from native JavaScript library.
annotation class JsModule
JsName
Gives a declaration (a function, a property or a class) specific name in JavaScript.
annotation class JsName
JsNonModule
Denotes an external
declaration that can be used without module system.
annotation class JsNonModule
JSON
Exposes the JavaScript JSON object to Kotlin.
object JSON
JsQualifier
Adds prefix to external
declarations in a source file.
annotation class JsQualifier
JsReadonlyArray
Exposes the TypeScript ReadonlyArray to Kotlin.
interface JsReadonlyArray<out E>
JsReadonlyMap
Exposes the TypeScript ReadonlyMap to Kotlin.
interface JsReadonlyMap<K, out V>
JsReadonlySet
Exposes the TypeScript ReadonlySet to Kotlin.
interface JsReadonlySet<out E>
JsSet
Exposes the JavaScript Set to Kotlin.
open class JsSet<E> : JsReadonlySet<E>
JsStatic
Specifies that an additional static method is generated from the annotated companion object member if it's a function. If the member is a property, additional static getter/setter methods are generated.
annotation class JsStatic
JsValue
open class JsValue
JvmDefault
Specifies that a JVM default method should be generated for non-abstract Kotlin interface member.
annotation class JvmDefault
JvmDefaultWithCompatibility
Forces the compiler to generate compatibility accessors for the annotated interface in the DefaultImpls
class.
Please note that if an interface is annotated with this annotation for binary compatibility, public derived Kotlin interfaces should also be annotated with it,
because their DefaultImpls
methods will be used to access implementations from the DefaultImpls
class of the original interface.
annotation class JvmDefaultWithCompatibility
JvmDefaultWithoutCompatibility
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
JvmField
Instructs the Kotlin compiler not to generate getters/setters for this property and expose it as a field.
annotation class JvmField
JvmInline
Specifies that given value class is inline class.
annotation class JvmInline
JvmMultifileClass
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
JvmName
Specifies the name for the Java class or method which is generated from this element.
annotation class JvmName
JvmOverloads
Instructs the Kotlin compiler to generate overloads for this function that substitute default parameter values.
annotation class JvmOverloads
JvmRecord
Instructs compiler to mark the class as a record and generate relevant toString/equals/hashCode methods
annotation class JvmRecord
JvmSerializableLambda
Makes the annotated lambda function implement java.io.Serializable
,
generates a pretty toString
implementation and adds reflection metadata.
annotation class JvmSerializableLambda
JvmStatic
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
JvmSuppressWildcards
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
JvmSynthetic
Sets ACC_SYNTHETIC
flag on the annotated target in the Java bytecode.
annotation class JvmSynthetic
JvmWildcard
Instructs compiler to generate wildcard for annotated type arguments corresponding to parameters with declaration-site variance.
annotation class JvmWildcard
KAnnotatedElement
Represents an annotated element and allows to obtain its annotations. See the Kotlin language documentation for more information.
interface KAnnotatedElement
KCallable
Represents a callable entity, such as a function or a property.
interface KCallable<out R>
interface KCallable<out R> : KAnnotatedElement
KClass
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
KClassifier
A classifier is either a class or a type parameter.
interface KClassifier
KDeclarationContainer
Represents an entity which may contain declarations of any other entities, such as a class or a package.
interface KDeclarationContainer
KeyboardEventInit
interface KeyboardEventInit : EventModifierInit
KMutableProperty
Represents a property declared as a var
.
interface KMutableProperty<V> : KProperty<V>
KMutableProperty0
Represents a var
-property without any kind of receiver.
interface KMutableProperty0<V> :
KProperty0<V>,
KMutableProperty<V>
KMutableProperty1
Represents a var
-property, operations on which take one receiver as a parameter.
interface KMutableProperty1<T, V> :
KProperty1<T, V>,
KMutableProperty<V>
KMutableProperty2
Represents a var
-property, operations on which take two receivers as parameters.
interface KMutableProperty2<D, E, V> :
KProperty2<D, E, V>,
KMutableProperty<V>
KotlinVersion
Represents a version of the Kotlin standard library.
class KotlinVersion : Comparable<KotlinVersion>
KParameter
Represents a parameter passed to a function or a property getter/setter,
including this
and extension receiver parameters.
interface KParameter : KAnnotatedElement
KProperty
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>
KProperty0
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
KProperty1
Represents a property, operations on which take one receiver as a parameter.
interface KProperty1<T, out V> : KProperty<V>, (T) -> V
KProperty2
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
KType
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
KTypeParameter
Represents a declaration of a type parameter of a class or a callable. See the Kotlin language documentation for more information.
interface KTypeParameter : KClassifier
KTypeProjection
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
Lazy
Represents a value with lazy initialization.
interface Lazy<out T>
LinkedHashMap
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>
LinkedHashSet
The implementation of the MutableSet interface, backed by a InternalMap implementation.
class LinkedHashSet<E> : MutableSet<E>
typealias LinkedHashSet<E> = LinkedHashSet<E>
open class LinkedHashSet<E> : HashSet<E>, MutableSet<E>
typealias LinkedHashSet<V> = HashSet<V>
List
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>
ListIterator
An iterator over a collection that supports indexed access.
interface ListIterator<out T> : Iterator<T>
LongArray
An array of longs. When targeting the JVM, instances of this class are represented as long[]
.
class LongArray
LongIterator
An iterator over a sequence of values of type Long
.
abstract class LongIterator : Iterator<Long>
LongProgression
A progression of values of type Long
.
open class LongProgression : Iterable<Long>
ManagedType
abstract class ManagedType<T : CStructVar>
Map
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>
MatchGroup
Represents the results from a single capturing group within a MatchResult of Regex.
class MatchGroup
data class MatchGroup
MatchGroupCollection
Represents a collection of captured groups in a single match of a regular expression.
interface MatchGroupCollection : Collection<MatchGroup?>
MatchNamedGroupCollection
Extends MatchGroupCollection by introducing a way to get matched groups by name, when regex supports it.
interface MatchNamedGroupCollection : MatchGroupCollection
MatchResult
Represents the results from a single regular expression match.
interface MatchResult
MediaDeviceInfo
Exposes the JavaScript MediaDeviceInfo to Kotlin
abstract class MediaDeviceInfo
MediaDeviceKind
interface MediaDeviceKind
MediaEncryptedEventInit
interface MediaEncryptedEventInit : EventInit
MediaError
Exposes the JavaScript MediaError to Kotlin
abstract class MediaError
MediaKeyMessageEventInit
interface MediaKeyMessageEventInit : EventInit
MediaKeyMessageType
interface MediaKeyMessageType
MediaKeySessionType
interface MediaKeySessionType
MediaKeysRequirement
interface MediaKeysRequirement
MediaKeyStatus
interface MediaKeyStatus
MediaKeyStatusMap
Exposes the JavaScript MediaKeyStatusMap to Kotlin
abstract class MediaKeyStatusMap
MediaKeySystemAccess
Exposes the JavaScript MediaKeySystemAccess to Kotlin
abstract class MediaKeySystemAccess
MediaKeySystemConfiguration
Exposes the JavaScript MediaKeySystemConfiguration to Kotlin
interface MediaKeySystemConfiguration
MediaKeySystemMediaCapability
interface MediaKeySystemMediaCapability
MediaList
abstract class MediaList : ItemArrayLike<String>
MediaProvider
interface MediaProvider
MediaQueryListEventInit
interface MediaQueryListEventInit : EventInit
MediaStreamConstraints
Exposes the JavaScript MediaStreamConstraints to Kotlin
interface MediaStreamConstraints
MediaStreamTrackEventInit
interface MediaStreamTrackEventInit : EventInit
MediaStreamTrackState
interface MediaStreamTrackState
MediaTrackCapabilities
interface MediaTrackCapabilities
MediaTrackConstraints
Exposes the JavaScript MediaTrackConstraints to Kotlin
interface MediaTrackConstraints : MediaTrackConstraintSet
MediaTrackConstraintSet
interface MediaTrackConstraintSet
MediaTrackSettings
Exposes the JavaScript MediaTrackSettings to Kotlin
interface MediaTrackSettings
MediaTrackSupportedConstraints
Exposes the JavaScript MediaTrackSupportedConstraints to Kotlin
interface MediaTrackSupportedConstraints
MemoryUsage
This class represents statistics of memory usage in one memory pool.
class MemoryUsage
MessageChannel
Exposes the JavaScript MessageChannel to Kotlin
open class MessageChannel
MessageEventInit
interface MessageEventInit : EventInit
Metadata
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
MimeTypeArray
Exposes the JavaScript MimeTypeArray to Kotlin
abstract class MimeTypeArray : ItemArrayLike<MimeType>
MouseEventInit
interface MouseEventInit : EventModifierInit
MustBeDocumented
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
MutableCollection
A generic collection of elements that supports adding and removing elements.
interface MutableCollection<E> :
Collection<E>,
MutableIterable<E>
MutableData
Mutable concurrently accessible data buffer. Could be accessed from several workers simultaneously.
class MutableData
MutableEntry
Represents a key/value pair held by a MutableMap.
interface MutableEntry<K, V> : Entry<K, V>
MutableIterable
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>
MutableIterator
An iterator over a mutable collection. Provides the ability to remove elements while iterating.
interface MutableIterator<out T> : Iterator<T>
MutableList
A generic ordered collection of elements that supports adding and removing elements.
interface MutableList<E> : List<E>, MutableCollection<E>
MutableListIterator
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>
MutableMap
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>
MutableSet
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>
MutationObserver
Exposes the JavaScript MutationObserver to Kotlin
open class MutationObserver
MutationObserverInit
Exposes the JavaScript MutationObserverInit to Kotlin
interface MutationObserverInit
MutationRecord
Exposes the JavaScript MutationRecord to Kotlin
abstract class MutationRecord
NamedNodeMap
Exposes the JavaScript NamedNodeMap to Kotlin
abstract class NamedNodeMap : ItemArrayLike<Attr>
NativeFreeablePlacement
interface NativeFreeablePlacement : NativePlacement
nativeGetter
annotation class nativeGetter
nativeHeap
object nativeHeap : NativeFreeablePlacement
nativeInvoke
annotation class nativeInvoke
NativePlacement
interface NativePlacement
NativePointed
The entity which has an associated native pointer. Subtypes are supposed to represent interpretations of the pointed data or code.
open class NativePointed
NativeRuntimeApi
This annotation marks the Kotlin/Native standard library API that tweaks or otherwise accesses the Kotlin runtime behavior.
annotation class NativeRuntimeApi
nativeSetter
annotation class nativeSetter
Navigator
Exposes the JavaScript Navigator to Kotlin
abstract class Navigator :
NavigatorID,
NavigatorLanguage,
NavigatorOnLine,
NavigatorContentUtils,
NavigatorCookies,
NavigatorPlugins,
NavigatorConcurrentHardware
NavigatorConcurrentHardware
Exposes the JavaScript NavigatorConcurrentHardware to Kotlin
interface NavigatorConcurrentHardware
NavigatorContentUtils
interface NavigatorContentUtils
NavigatorCookies
interface NavigatorCookies
NavigatorID
Exposes the JavaScript NavigatorID to Kotlin
interface NavigatorID
NavigatorLanguage
Exposes the JavaScript NavigatorLanguage to Kotlin
interface NavigatorLanguage
NavigatorOnLine
Exposes the JavaScript NavigatorOnLine to Kotlin
interface NavigatorOnLine
NavigatorPlugins
Exposes the JavaScript NavigatorPlugins to Kotlin
interface NavigatorPlugins
NodeFilter
Exposes the JavaScript NodeFilter to Kotlin
interface NodeFilter
NodeIterator
Exposes the JavaScript NodeIterator to Kotlin
abstract class NodeIterator
NodeList
Exposes the JavaScript NodeList to Kotlin
abstract class NodeList : ItemArrayLike<Node>
NonDocumentTypeChildNode
Exposes the JavaScript NonDocumentTypeChildNode to Kotlin
interface NonDocumentTypeChildNode
NonElementParentNode
interface NonElementParentNode
Nothing
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
NotificationAction
interface NotificationAction
NotificationDirection
interface NotificationDirection
NotificationEventInit
interface NotificationEventInit : ExtendableEventInit
NotificationOptions
interface NotificationOptions
NotificationPermission
interface NotificationPermission
Number
Superclass for all platform classes representing numeric values.
abstract class Number
ObjCAction
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
ObjCClass
interface ObjCClass : ObjCObject
ObjCClassOf
interface ObjCClassOf<T : ObjCObject> : ObjCClass
ObjCConstructor
annotation class ObjCConstructor
ObjCDirect
annotation class ObjCDirect
ObjCFactory
annotation class ObjCFactory
ObjCMethod
annotation class ObjCMethod
ObjCName
Instructs the Kotlin compiler to use a custom Objective-C and/or Swift name for this class, property, parameter or function.
annotation class ObjCName
ObjCObject
interface ObjCObject
ObjCObjectBase
abstract class ObjCObjectBase : ObjCObject
ObjCOutlet
Makes Kotlin property in Objective-C class settable through Objective-C dispatch to be used as IB outlet.
annotation class ObjCOutlet
ObjCProtocol
interface ObjCProtocol : ObjCObject
ObjCSignatureOverride
Marks functions for which Objective-C rules should be used for determinating whether two functions are conflicting.
annotation class ObjCSignatureOverride
ObservableProperty
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>
ObsoleteNativeApi
This annotation marks the Kotlin/Native standard library API that is considered obsolete and is being phased out.
annotation class ObsoleteNativeApi
ObsoleteWorkersApi
Marks all Worker
-related API as obsolete.
annotation class ObsoleteWorkersApi
OpenEndRange
Represents a range of values (for example, numbers or characters) where the upper bound is not included in the range. See the Kotlin language documentation for more information.
interface OpenEndRange<T : Comparable<T>>
OptIn
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
OptionalExpectation
Marks an expected annotation class that it isn't required to have actual counterparts in all platforms.
annotation class OptionalExpectation
OverconstrainedErrorEventInit
interface OverconstrainedErrorEventInit : EventInit
OverloadResolutionByLambdaReturnType
Enables overload selection based on the type of the value returned from lambda argument.
annotation class OverloadResolutionByLambdaReturnType
PageTransitionEventInit
interface PageTransitionEventInit : EventInit
Pair
Represents a generic pair of two values.
data class Pair<out A, out B> : Serializable
ParameterName
Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).
annotation class ParameterName
ParentNode
Exposes the JavaScript ParentNode to Kotlin
interface ParentNode
Path2D
Exposes the JavaScript Path2D to Kotlin
open class Path2D : CanvasPath
PerformanceNavigation
Exposes the JavaScript PerformanceNavigation to Kotlin
abstract class PerformanceNavigation
PerformanceTiming
Exposes the JavaScript PerformanceTiming to Kotlin
abstract class PerformanceTiming
Pinned
class Pinned<T : Any>
Platform
Object describing the current platform program executes upon.
object Platform
Plugin
Exposes the JavaScript Plugin to Kotlin
abstract class Plugin : ItemArrayLike<MimeType>
PluginArray
Exposes the JavaScript PluginArray to Kotlin
abstract class PluginArray : ItemArrayLike<Plugin>
PointerEventInit
interface PointerEventInit : MouseEventInit
PopStateEventInit
interface PopStateEventInit : EventInit
PremultiplyAlpha
interface PremultiplyAlpha
ProgressEventInit
interface ProgressEventInit : EventInit
Promise
Exposes the JavaScript Promise object to Kotlin.
open class Promise<out T>
PromiseRejectionEventInit
interface PromiseRejectionEventInit : EventInit
PropertyDelegateProvider
Base interface that can be used for implementing property delegate providers.
fun interface PropertyDelegateProvider<in T, out D>
PublishedApi
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
PurelyImplements
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
Random
An abstract class that is implemented by random number generator algorithms.
abstract class Random
RandomAccess
Marker interface indicating that the List implementation supports fast indexed access.
interface RandomAccess
typealias RandomAccess = RandomAccess
ReadOnlyProperty
Base interface that can be used for implementing property delegates of read-only properties.
fun interface ReadOnlyProperty<in T, out V>
ReadWriteProperty
Base interface that can be used for implementing property delegates of read-write properties.
interface ReadWriteProperty<in T, V> : ReadOnlyProperty<T, V>
ReadyState
interface ReadyState
RefinesInSwift
Meta-annotation that instructs the Kotlin compiler to mark the annotated function or property as
swift_private
in the generated Objective-C API.
annotation class RefinesInSwift
Regex
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
RegExp
Exposes the JavaScript RegExp object to Kotlin.
class RegExp
RegExpMatch
Represents the return value of RegExp.exec.
interface RegExpMatch
RegistrationOptions
interface RegistrationOptions
RelatedEventInit
interface RelatedEventInit : EventInit
RenderingContext
interface RenderingContext
Repeatable
This meta-annotation determines that an annotation is applicable twice or more on a single code element
annotation class Repeatable
ReplaceWith
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
RequestCache
interface RequestCache
RequestCredentials
interface RequestCredentials
RequestDestination
interface RequestDestination
RequestInit
interface RequestInit
RequestMode
interface RequestMode
RequestRedirect
interface RequestRedirect
RequestType
interface RequestType
RequiresOptIn
Signals that the annotated annotation class is a marker of an API that requires an explicit opt-in.
annotation class RequiresOptIn
ResizeQuality
interface ResizeQuality
ResponseInit
interface ResponseInit
ResponseType
interface ResponseType
RestrictsSuspension
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
Retention
This meta-annotation determines whether an annotation is stored in binary output and visible for reflection. By default, both are true.
annotation class Retention
Returns
Describes a situation when a function returns normally with a given return value.
interface Returns : SimpleEffect
ReturnsNotNull
Describes a situation when a function returns normally with any non-null return value.
interface ReturnsNotNull : SimpleEffect
RootSetStatistics
This class represents statistics of the root set for garbage collector run, separated by root set pools. These nodes are assumed to be used, even if there are no references for them.
class RootSetStatistics
ScrollBehavior
interface ScrollBehavior
ScrollIntoViewOptions
interface ScrollIntoViewOptions : ScrollOptions
ScrollLogicalPosition
interface ScrollLogicalPosition
ScrollOptions
interface ScrollOptions
ScrollRestoration
interface ScrollRestoration
ScrollToOptions
Exposes the JavaScript ScrollToOptions to Kotlin
interface ScrollToOptions : ScrollOptions
SelectionMode
interface SelectionMode
Sequence
A sequence that returns values through its iterator. The values are evaluated lazily, and the sequence is potentially infinite.
interface Sequence<out T>
ServiceWorkerMessageEventInit
interface ServiceWorkerMessageEventInit : EventInit
ServiceWorkerState
interface ServiceWorkerState
Set
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
Setter of the property is a set
method declared alongside the property.
interface Setter<V> : KProperty.Accessor<V>, KFunction<Unit>
Setter
Setter of the property is a set
method declared alongside the property.
interface Setter<V> : KMutableProperty.Setter<V>, (V) -> Unit
Setter
Setter of the property is a set
method declared alongside the property.
interface Setter<T, V> :
KMutableProperty.Setter<V>,
(T, V) -> Unit
Setter
Setter of the property is a set
method declared alongside the property.
interface Setter<D, E, V> :
KMutableProperty.Setter<V>,
(D, E, V) -> Unit
Settings
interface Settings
ShadowAnimation
open class ShadowAnimation
ShadowRootInit
interface ShadowRootInit
ShadowRootMode
interface ShadowRootMode
SharedImmutable
Note: this annotation has effect only in Kotlin/Native with legacy memory manager.
annotation class SharedImmutable
ShortArray
An array of shorts. When targeting the JVM, instances of this class are represented as short[]
.
class ShortArray
ShortIterator
An iterator over a sequence of values of type Short
.
abstract class ShortIterator : Iterator<Short>
ShouldRefineInSwift
Instructs the Kotlin compiler to mark this function or property as swift_private
in the generated Objective-C API.
annotation class ShouldRefineInSwift
SimpleEffect
An effect that can be observed after a function invocation.
interface SimpleEffect : Effect
SinceKotlin
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
SkiaRefCnt
interface SkiaRefCnt
StableRef
class StableRef<out T : Any>
StorageEventInit
interface StorageEventInit : EventInit
Strictfp
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
String
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
StringBuilder
A mutable sequence of characters.
class StringBuilder : Appendable, CharSequence
typealias StringBuilder = StringBuilder
class StringBuilder : CharSequence, Appendable
StyleSheet
Exposes the JavaScript StyleSheet to Kotlin
abstract class StyleSheet
StyleSheetList
Exposes the JavaScript StyleSheetList to Kotlin
abstract class StyleSheetList : ItemArrayLike<StyleSheet>
SubclassOptInRequired
Annotation that marks open for subclassing classes and interfaces, and makes implementation and extension of such declarations as requiring an explicit opt-in.
annotation class SubclassOptInRequired
Suppress
Suppresses the given compilation warnings in the annotated element.
annotation class Suppress
SuspendFunction
Represents a value of a functional type, such as a lambda, an anonymous function or a function reference.
interface SuspendFunction<out R>
SVGAnimatedAngle
Exposes the JavaScript SVGAnimatedAngle to Kotlin
abstract class SVGAnimatedAngle
SVGAnimatedBoolean
Exposes the JavaScript SVGAnimatedBoolean to Kotlin
abstract class SVGAnimatedBoolean
SVGAnimatedEnumeration
Exposes the JavaScript SVGAnimatedEnumeration to Kotlin
abstract class SVGAnimatedEnumeration
SVGAnimatedInteger
Exposes the JavaScript SVGAnimatedInteger to Kotlin
abstract class SVGAnimatedInteger
SVGAnimatedLength
Exposes the JavaScript SVGAnimatedLength to Kotlin
abstract class SVGAnimatedLength
SVGAnimatedLengthList
Exposes the JavaScript SVGAnimatedLengthList to Kotlin
abstract class SVGAnimatedLengthList
SVGAnimatedNumber
Exposes the JavaScript SVGAnimatedNumber to Kotlin
abstract class SVGAnimatedNumber
SVGAnimatedNumberList
Exposes the JavaScript SVGAnimatedNumberList to Kotlin
abstract class SVGAnimatedNumberList
SVGAnimatedPoints
Exposes the JavaScript SVGAnimatedPoints to Kotlin
interface SVGAnimatedPoints
SVGAnimatedPreserveAspectRatio
Exposes the JavaScript SVGAnimatedPreserveAspectRatio to Kotlin
abstract class SVGAnimatedPreserveAspectRatio
SVGAnimatedRect
Exposes the JavaScript SVGAnimatedRect to Kotlin
abstract class SVGAnimatedRect
SVGAnimatedString
Exposes the JavaScript SVGAnimatedString to Kotlin
abstract class SVGAnimatedString
SVGAnimatedTransformList
Exposes the JavaScript SVGAnimatedTransformList to Kotlin
abstract class SVGAnimatedTransformList
SVGBoundingBoxOptions
interface SVGBoundingBoxOptions
SVGElementInstance
interface SVGElementInstance
SVGFitToViewBox
interface SVGFitToViewBox
SVGLengthList
Exposes the JavaScript SVGLengthList to Kotlin
abstract class SVGLengthList
SVGNameList
abstract class SVGNameList
SVGNumberList
Exposes the JavaScript SVGNumberList to Kotlin
abstract class SVGNumberList
SVGPointList
abstract class SVGPointList
SVGPreserveAspectRatio
Exposes the JavaScript SVGPreserveAspectRatio to Kotlin
abstract class SVGPreserveAspectRatio
SVGStringList
Exposes the JavaScript SVGStringList to Kotlin
abstract class SVGStringList
SVGTransform
Exposes the JavaScript SVGTransform to Kotlin
abstract class SVGTransform
SVGTransformList
Exposes the JavaScript SVGTransformList to Kotlin
abstract class SVGTransformList
SVGUnitTypes
Exposes the JavaScript SVGUnitTypes to Kotlin
interface SVGUnitTypes
SVGURIReference
Exposes the JavaScript SVGURIReference to Kotlin
interface SVGURIReference
SVGZoomAndPan
Exposes the JavaScript SVGZoomAndPan to Kotlin
interface SVGZoomAndPan
SweepStatistics
This class represents statistics of sweeping in one memory pool.
class SweepStatistics
SymbolName
This is a dangerous deprecated and internal annotation. Please avoid using it.
annotation class SymbolName
Synchronized
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
annotation class Synchronized
Target
This meta-annotation indicates the kinds of code elements which are possible targets of an annotation.
annotation class Target
TexImageSource
interface TexImageSource
TextMetrics
Exposes the JavaScript TextMetrics to Kotlin
abstract class TextMetrics
TextTrackCueList
abstract class TextTrackCueList
TextTrackKind
interface TextTrackKind
TextTrackMode
interface TextTrackMode
ThreadLocal
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
Throwable
The base class for all errors and exceptions. Only instances of this class can be thrown or caught.
open class Throwable
Throws
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
Throws
This annotation indicates what exceptions should be declared by a function when compiled to a JVM method.
annotation class Throws
TimedValue
Data class representing a result of executing an action, along with the duration of elapsed time interval.
data class TimedValue<T>
TimeMark
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).
interface TimeMark
TimeRanges
Exposes the JavaScript TimeRanges to Kotlin
abstract class TimeRanges
TimeSource
A source of time for measuring time intervals.
interface TimeSource
TouchList
abstract class TouchList : ItemArrayLike<Touch>
TrackEventInit
interface TrackEventInit : EventInit
Transient
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
TreeWalker
Exposes the JavaScript TreeWalker to Kotlin
abstract class TreeWalker
Triple
Represents a triad of values
data class Triple<out A, out B, out C> : Serializable
Typography
Defines names for Unicode symbols used in proper Typography.
object Typography
UByte
class UByte : Comparable<UByte>
UByteArray
class UByteArray : Collection<UByte>
UIEventInit
interface UIEventInit : EventInit
UInt
class UInt : Comparable<UInt>
Uint16Array
Exposes the JavaScript Uint16Array to Kotlin
open class Uint16Array : ArrayBufferView
Uint32Array
Exposes the JavaScript Uint32Array to Kotlin
open class Uint32Array : ArrayBufferView
Uint8Array
Exposes the JavaScript Uint8Array to Kotlin
open class Uint8Array : ArrayBufferView
Uint8ClampedArray
Exposes the JavaScript Uint8ClampedArray to Kotlin
open class Uint8ClampedArray : ArrayBufferView
UIntArray
class UIntArray : Collection<UInt>
ULong
class ULong : Comparable<ULong>
ULongArray
class ULongArray : Collection<ULong>
ULongRange
interface ULongRange
UnionAudioTrackOrTextTrackOrVideoTrack
interface UnionAudioTrackOrTextTrackOrVideoTrack
UnionClientOrMessagePortOrServiceWorker
interface UnionClientOrMessagePortOrServiceWorker
UnionElementOrHTMLCollection
interface UnionElementOrHTMLCollection
UnionElementOrMouseEvent
interface UnionElementOrMouseEvent
UnionElementOrProcessingInstruction
interface UnionElementOrProcessingInstruction
UnionElementOrRadioNodeList
interface UnionElementOrRadioNodeList
UnionHTMLOptGroupElementOrHTMLOptionElement
interface UnionHTMLOptGroupElementOrHTMLOptionElement
UnionMessagePortOrServiceWorker
interface UnionMessagePortOrServiceWorker
UnionMessagePortOrWindowProxy
interface UnionMessagePortOrWindowProxy
Unit
The type with only one value: the Unit
object. This type corresponds to the void
type in Java.
object Unit
UnsafeNumber
Marker for declarations that depend on numeric types of different bit width on at least two platforms.
annotation class UnsafeNumber
UnsafeVariance
Suppresses errors about variance conflict
annotation class UnsafeVariance
URLSearchParams
Exposes the JavaScript URLSearchParams to Kotlin
open class URLSearchParams
UShort
class UShort : Comparable<UShort>
UShortArray
class UShortArray : Collection<UShort>
Uuid
Represents a Universally Unique Identifier (UUID), also known as a Globally Unique Identifier (GUID).
class Uuid : Serializable
ValidityState
Exposes the JavaScript ValidityState to Kotlin
abstract class ValidityState
Vector128
class Vector128
VideoFacingModeEnum
interface VideoFacingModeEnum
VideoResizeModeEnum
interface VideoResizeModeEnum
VideoTrack
Exposes the JavaScript VideoTrack to Kotlin
abstract class VideoTrack :
UnionAudioTrackOrTextTrackOrVideoTrack
Volatile
Marks the JVM backing field of the annotated var
property as volatile
, meaning that reads and writes to this field
are atomic and writes are always made visible to other threads. If another thread reads the value of this field (e.g. through its accessor),
it sees not only that value, but all side effects that led to writing that value.
annotation class Volatile
annotation class Volatile
Volatile
Marks the backing field of the annotated var
property as volatile
, meaning that reads and writes to this field
are atomic and writes are always made visible to other threads. If another thread reads the value of this field (e.g. through its accessor),
it sees not only that value, but all side effects that led to writing that value.
annotation class Volatile
typealias Volatile = Volatile
WeakReference
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>
WebGLActiveInfo
Exposes the JavaScript WebGLActiveInfo to Kotlin
abstract class WebGLActiveInfo
WebGLContextAttributes
interface WebGLContextAttributes
WebGLContextEventInit
interface WebGLContextEventInit : EventInit
WebGLObject
abstract class WebGLObject
WebGLRenderingContext
Exposes the JavaScript WebGLRenderingContext to Kotlin
abstract class WebGLRenderingContext :
WebGLRenderingContextBase,
RenderingContext
WebGLRenderingContextBase
interface WebGLRenderingContextBase
WebGLShaderPrecisionFormat
Exposes the JavaScript WebGLShaderPrecisionFormat to Kotlin
abstract class WebGLShaderPrecisionFormat
WebGLUniformLocation
Exposes the JavaScript WebGLUniformLocation to Kotlin
abstract class WebGLUniformLocation
WheelEventInit
interface WheelEventInit : MouseEventInit
WindowEventHandlers
Exposes the JavaScript WindowEventHandlers to Kotlin
interface WindowEventHandlers
WindowLocalStorage
Exposes the JavaScript WindowLocalStorage to Kotlin
interface WindowLocalStorage
WindowOrWorkerGlobalScope
Exposes the JavaScript WindowOrWorkerGlobalScope to Kotlin
interface WindowOrWorkerGlobalScope
WindowSessionStorage
Exposes the JavaScript WindowSessionStorage to Kotlin
interface WindowSessionStorage
Worker
class Worker
WorkerBoundReference
A shared reference to a Kotlin object that doesn't freeze the referred object when it gets frozen itself.
class WorkerBoundReference<out T : Any>
WorkerLocation
Exposes the JavaScript WorkerLocation to Kotlin
abstract class WorkerLocation
WorkerNavigator
Exposes the JavaScript WorkerNavigator to Kotlin
abstract class WorkerNavigator :
NavigatorID,
NavigatorLanguage,
NavigatorOnLine,
NavigatorConcurrentHardware
WorkerOptions
interface WorkerOptions
WorkerType
interface WorkerType
XMLHttpRequestResponseType
interface XMLHttpRequestResponseType
XMLSerializer
Exposes the JavaScript XMLSerializer to Kotlin
open class XMLSerializer