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
BarProp
abstract
class
BarProp
Base64
Provides Base64 encoding and decoding functionality.
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.
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
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
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
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
ExportObjCClass
Makes Kotlin subclass of Objective-C class visible for runtime lookup
after Kotlin
main
function gets invoked.
annotation
class
ExportObjCClass
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.
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
>
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
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
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
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
data
class
Pinned
<
out
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
>
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