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?): BooleanhashCode
Returns a hash code value for the object. The general contract of hashCode is:
open fun hashCode(): InttoString
Returns a string representation of the object.
open fun toString(): StringExtension Properties
isFrozen
Checks if given object is null or frozen or permanent (i.e. instantiated at compile-time).
val Any?.isFrozen: BooleanExtension Functions
also
Calls the specified function block with this value as its argument and returns this value.
fun <T> T.also(block: (T) -> Unit): Tapply
Calls the specified function block with this value as its receiver and returns this value.
fun <T> T.apply(block: T.() -> Unit): TasDynamic
Reinterprets this value as a value of the dynamic type.
fun Any?.asDynamic(): dynamicensureNeverFrozen
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(): ThashCode
Returns a hash code value for the object or zero if the object is null.
fun Any?.hashCode(): IntidentityHashCode
Compute stable wrt potential object relocations by the memory manager identity hash code.
fun Any?.identityHashCode(): Intiterator
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): Rrun
Calls the specified function block with this value as its receiver and returns its result.
fun <T, R> T.run(block: T.() -> R): RrunCatching
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(): TReinterprets this dynamic value as a value of the specified type T without any actual type checking.
fun <T> dynamic.unsafeCast(): TInheritors
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 : ElementAbstractCoroutineContextKey
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> :
AbstractCollection<E>,
MutableCollection<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 AbstractWorkerAccessor
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 : EventListenerOptionsAnnotation
Base interface implicitly implemented by all annotation interfaces. See Kotlin language documentation for more information on annotations.
interface AnnotationAppendable
An object to which char sequences and values can be appended.
interface Appendabletypealias Appendable = AppendableAppendMode
interface AppendModeArenaManager
object ArenaManagerArray
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 : BufferDataSourceArrayBufferView
Exposes the JavaScript ArrayBufferView to Kotlin
interface ArrayBufferView : BufferDataSourceArrayList
Provides a MutableList implementation, which uses a resizable array as its backing storage.
class ArrayList<E> : MutableList<E>, RandomAccesstypealias ArrayList<E> = ArrayList<E>open class ArrayList<E> :
AbstractMutableList<E>,
MutableList<E>,
RandomAccessclass ArrayList<E> :
MutableList<E>,
RandomAccess,
AbstractMutableList<E>AssignedNodesOptions
interface AssignedNodesOptionsAssociatedObjectKey
Makes the annotated annotation class an associated object key.
annotation class AssociatedObjectKeyAtomicInt
An Int value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicIntAtomicInt
An Int value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicIntAtomicLong
A Long value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicLongAtomicLong
A Long value that is always updated atomically. For additional details about atomicity guarantees for reads and writes see kotlin.concurrent.Volatile.
class AtomicLongAtomicNativePtr
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 AtomicNativePtrAtomicNativePtr
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 AtomicNativePtrAtomicReference
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 :
UnionAudioTrackOrTextTrackOrVideoTrackAutoCloseable
A resource that can be closed or released.
interface AutoCloseableBarProp
abstract class BarPropBase64
Provides Base64 encoding and decoding functionality.
open class Base64BetaInteropApi
Marks Objective-C and Swift interoperability API as Beta.
annotation class BetaInteropApiBinaryType
interface BinaryTypeBitSet
A vector of bits growing if necessary and allowing one to set/clear/read bits from it by a bit index.
class BitSetBlob
Exposes the JavaScript Blob to Kotlin
open class Blob : MediaProvider, ImageBitmapSourceBlobPropertyBag
interface BlobPropertyBagBoolean
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 BooleanArrayBooleanIterator
An iterator over a sequence of values of type Boolean.
abstract class BooleanIterator : Iterator<Boolean>BoxQuadOptions
interface BoxQuadOptionsBufferDataSource
interface BufferDataSourceBuilderInference
Allows to infer generic type arguments of a function from the calls in the annotated function parameter of that function.
annotation class BuilderInferenceByteArray
An array of bytes. When targeting the JVM, instances of this class are represented as byte[].
class ByteArrayByteIterator
An iterator over a sequence of values of type Byte.
abstract class ByteIterator : Iterator<Byte>CacheBatchOperation
interface CacheBatchOperationCacheQueryOptions
interface CacheQueryOptionsCacheStorage
Exposes the JavaScript CacheStorage to Kotlin
abstract class CacheStorageCallsInPlace
An effect of calling a functional parameter in place.
interface CallsInPlace : EffectCanPlayTypeResult
interface CanPlayTypeResultCanvasCompositing
interface CanvasCompositingCanvasDirection
interface CanvasDirectionCanvasDrawImage
interface CanvasDrawImageCanvasDrawPath
interface CanvasDrawPathCanvasFillRule
interface CanvasFillRuleCanvasFillStrokeStyles
interface CanvasFillStrokeStylesCanvasFilters
interface CanvasFiltersCanvasGradient
Exposes the JavaScript CanvasGradient to Kotlin
abstract class CanvasGradientCanvasHitRegion
interface CanvasHitRegionCanvasImageData
interface CanvasImageDataCanvasImageSmoothing
interface CanvasImageSmoothingCanvasImageSource
interface CanvasImageSource : ImageBitmapSourceCanvasLineCap
interface CanvasLineCapCanvasLineJoin
interface CanvasLineJoinCanvasPath
interface CanvasPathCanvasPathDrawingStyles
interface CanvasPathDrawingStylesCanvasPattern
Exposes the JavaScript CanvasPattern to Kotlin
abstract class CanvasPatternCanvasRect
interface CanvasRectCanvasRenderingContext2D
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,
RenderingContextCanvasRenderingContext2DSettings
interface CanvasRenderingContext2DSettingsCanvasShadowStyles
interface CanvasShadowStylesCanvasState
interface CanvasStateCanvasText
interface CanvasTextCanvasTextAlign
interface CanvasTextAlignCanvasTextBaseline
interface CanvasTextBaselineCanvasTextDrawingStyles
interface CanvasTextDrawingStylesCanvasTransform
interface CanvasTransformCanvasUserInterface
interface CanvasUserInterfaceCapabilities
interface CapabilitiesCaretPosition
Exposes the JavaScript CaretPosition to Kotlin
abstract class CaretPositionCCall
annotation class CCallCEnum
interface CEnumCEnumEntryAlias
Denotes property that is an alias to some enum entry.
annotation class CEnumEntryAliasCEnumVarTypeSize
Stores instance size of the type T: CEnumVar.
annotation class CEnumVarTypeSizeChar
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 CharArrayCharIterator
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 CharSequenceCharsets
Constant definitions for the standard charsets. These charsets are guaranteed to be available on every implementation of the Java platform.
object CharsetsCleaner
The marker interface for objects that have a cleanup action associated with them.
sealed interface CleanerClient
Exposes the JavaScript Client to Kotlin
abstract class Client :
UnionClientOrMessagePortOrServiceWorkerClientQueryOptions
interface ClientQueryOptionsClientType
interface ClientTypeClipboardEventInit
interface ClipboardEventInit : EventInitClipboardPermissionDescriptor
interface ClipboardPermissionDescriptorClosedFloatingPointRange
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 : EventInitCName
Makes top level function available from C/C++ code with the given name.
annotation class CNameCollection
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 ColorSpaceConversionComparable
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 : UIEventInitConditionalEffect
An effect of some condition being true after observing another effect of a function.
interface ConditionalEffect : EffectConsole
Exposes the console API to Kotlin.
interface ConsoleConstantValue
Collection of annotations that allow to store constant values.
object ConstantValueConstrainablePattern
interface ConstrainablePatternConstrainBooleanParameters
Exposes the JavaScript ConstrainBooleanParameters to Kotlin
interface ConstrainBooleanParametersConstrainDOMStringParameters
Exposes the JavaScript ConstrainDOMStringParameters to Kotlin
interface ConstrainDOMStringParametersConstrainDoubleRange
interface ConstrainDoubleRange : DoubleRangeConstraints
interface Constraints : ConstraintSetConstraintSet
interface ConstraintSetConstrainULongRange
interface ConstrainULongRange : ULongRangeContextFunctionTypeParams
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 ContextFunctionTypeParamsContinuation
Interface representing a continuation after a suspension point that returns a value of type T.
interface Continuation<in T>Continuation0
class Continuation0 : () -> UnitContinuation1
class Continuation1<T1> : (T1) -> UnitContinuation2
class Continuation2<T1, T2> : (T1, T2) -> UnitContinuationInterceptor
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 : ElementContractBuilder
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 ContractBuilderConvertCoordinateOptions
interface ConvertCoordinateOptionsCopyActionContext
Context for the copyAction function passed to Path.copyToRecursively.
interface CopyActionContextCPlusPlusClass
interface CPlusPlusClassCSSBoxType
interface CSSBoxTypeCSSRuleList
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 CStructCustomElementRegistry
Exposes the JavaScript CustomElementRegistry to Kotlin
abstract class CustomElementRegistryCustomEventInit
interface CustomEventInit : EventInitDataTransfer
Exposes the JavaScript DataTransfer to Kotlin
abstract class DataTransferDataTransferItem
Exposes the JavaScript DataTransferItem to Kotlin
abstract class DataTransferItemDataTransferItemList
Exposes the JavaScript DataTransferItemList to Kotlin
abstract class DataTransferItemListDataView
Exposes the JavaScript DataView to Kotlin
open class DataView : ArrayBufferViewDebugging
Note: this API is unstable and may change in any release.
object DebuggingDeepRecursiveFunction
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 DeferScopeDelegates
Standard property delegates.
object DelegatesDeprecated
Marks the annotated declaration as deprecated.
annotation class DeprecatedDeprecatedSinceKotlin
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 DeprecatedSinceKotlinDetachedObjectGraph
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 DocumentAndElementEventHandlersDocumentOrShadowRoot
Exposes the JavaScript DocumentOrShadowRoot to Kotlin
interface DocumentOrShadowRootDocumentReadyState
interface DocumentReadyStateDOMImplementation
Exposes the JavaScript DOMImplementation to Kotlin
abstract class DOMImplementationDOMMatrixReadOnly
Exposes the JavaScript DOMMatrixReadOnly to Kotlin
open class DOMMatrixReadOnlyDOMPointInit
Exposes the JavaScript DOMPointInit to Kotlin
interface DOMPointInitDOMPointReadOnly
Exposes the JavaScript DOMPointReadOnly to Kotlin
open class DOMPointReadOnlyDOMRectInit
interface DOMRectInitDOMRectList
interface DOMRectList : ItemArrayLike<DOMRect>DOMRectReadOnly
Exposes the JavaScript DOMRectReadOnly to Kotlin
open class DOMRectReadOnlyDOMStringMap
Exposes the JavaScript DOMStringMap to Kotlin
abstract class DOMStringMapDOMTokenList
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 DoubleArrayDoubleIterator
An iterator over a sequence of values of type Double.
abstract class DoubleIterator : Iterator<Double>DoubleRange
Exposes the JavaScript DoubleRange to Kotlin
interface DoubleRangeDragEventInit
interface DragEventInit : MouseEventInitDslMarker
When applied to annotation class X specifies that X defines a DSL language
annotation class DslMarkerDuration
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 EagerInitializationEagerInitialization
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 EagerInitializationEffect
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 EffectElementContentEditable
interface ElementContentEditableElementCreationOptions
interface ElementCreationOptionsElementCSSInlineStyle
interface ElementCSSInlineStyleElementDefinitionOptions
interface ElementDefinitionOptionsEmptyCoroutineContext
An empty coroutine context.
object EmptyCoroutineContext : CoroutineContext, SerializableEndOfStreamError
interface EndOfStreamErrorEnum
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 : EventInitEventInit
interface EventInitEventListener
Exposes the JavaScript EventListener to Kotlin
interface EventListenerEventListenerOptions
interface EventListenerOptionsEventModifierInit
interface EventModifierInit : UIEventInitEventSourceInit
interface EventSourceInitEventTarget
Exposes the JavaScript EventTarget to Kotlin
abstract class EventTargetExperimentalAssociatedObjects
The experimental marker for associated objects API.
annotation class ExperimentalAssociatedObjectsExperimentalContracts
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 ExperimentalContractsExperimentalEncodingApi
This annotation marks the experimental API for encoding and decoding between binary data and printable ASCII character sequences.
annotation class ExperimentalEncodingApiExperimentalForeignApi
Marks foreign-memory-related API as experimental.
annotation class ExperimentalForeignApiExperimentalJsExport
Marks experimental JS export annotations.
annotation class ExperimentalJsExportExperimentalMultiplatform
The experimental multiplatform support API marker.
annotation class ExperimentalMultiplatformExperimentalNativeApi
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 ExperimentalNativeApiExperimentalObjCName
This annotation marks the experimental ObjCName annotation.
annotation class ExperimentalObjCNameExperimentalObjCRefinement
This annotation marks the experimental Objective-C export refinement annotations.
annotation class ExperimentalObjCRefinementExperimentalPathApi
This annotation marks the extensions and top-level functions for working with java.nio.file.Path considered experimental.
annotation class ExperimentalPathApiExperimentalReflectionOnLambdas
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 ExperimentalReflectionOnLambdasExperimentalStdlibApi
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 ExperimentalStdlibApiExperimentalSubclassOptIn
This annotation marks the experimental preview of the language feature SubclassOptInRequired.
annotation class ExperimentalSubclassOptInExperimentalTime
This annotation marks the experimental preview of the standard library API for measuring time and working with durations.
annotation class ExperimentalTimeExperimentalTypeInference
The experimental marker for type inference augmenting annotations.
annotation class ExperimentalTypeInferenceExperimentalUnsignedTypes
Marks the API that is dependent on the experimental unsigned types, including those types themselves.
annotation class ExperimentalUnsignedTypesExportObjCClass
Makes Kotlin subclass of Objective-C class visible for runtime lookup
after Kotlin main function gets invoked.
annotation class ExportObjCClassExtendableEventInit
interface ExtendableEventInit : EventInitExtendableMessageEventInit
interface ExtendableMessageEventInit : ExtendableEventInitExtensionFunctionType
Signifies that the annotated functional type represents an extension function.
annotation class ExtensionFunctionTypeExternal
interface ExternalExternalObjCClass
annotation class ExternalObjCClassFetchEventInit
interface FetchEventInit : ExtendableEventInitFileList
Exposes the JavaScript FileList to Kotlin
abstract class FileList : ItemArrayLike<File>FilePropertyBag
interface FilePropertyBag : BlobPropertyBagFileReaderSync
Exposes the JavaScript FileReaderSync to Kotlin
open class FileReaderSyncFileVisitorBuilder
The builder to provide implementation of the file visitor that fileVisitor builds.
sealed interface FileVisitorBuilderFloat32Array
Exposes the JavaScript Float32Array to Kotlin
open class Float32Array : ArrayBufferViewFloat64Array
Exposes the JavaScript Float64Array to Kotlin
open class Float64Array : ArrayBufferViewFloatArray
An array of floats. When targeting the JVM, instances of this class are represented as float[].
class FloatArrayFloatIterator
An iterator over a sequence of values of type Float.
abstract class FloatIterator : Iterator<Float>FocusEventInit
interface FocusEventInit : UIEventInitForeignFetchEventInit
interface ForeignFetchEventInit : ExtendableEventInitForeignFetchOptions
interface ForeignFetchOptionsForeignFetchResponse
interface ForeignFetchResponseFrameType
interface FrameTypeFreezableAtomicReference
Note: this class is useful only with legacy memory manager. Please use AtomicReference instead.
class FreezableAtomicReference<T>FreezingIsDeprecated
Freezing API is deprecated since 1.7.20.
annotation class FreezingIsDeprecatedFunction
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 GCGCInfo
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 GCInfoGeometryUtils
Exposes the JavaScript GeometryUtils to Kotlin
interface GeometryUtilsGetNotificationOptions
interface GetNotificationOptionsGetRootNodeOptions
interface GetRootNodeOptionsGetSVGDocument
interface GetSVGDocumentGetter
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>, () -> VGetter
Getter of the property is a get method declared alongside the property.
interface Getter<T, out V> : KProperty.Getter<V>, (T) -> VGetter
Getter of the property is a get method declared alongside the property.
interface Getter<D, E, out V> :
KProperty.Getter<V>,
(D, E) -> VGlobalEventHandlers
Exposes the JavaScript GlobalEventHandlers to Kotlin
interface GlobalEventHandlersGlobalPerformance
interface GlobalPerformanceGrouping
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 : EventInitHashMap
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 HashMap instance.
class HashSet<E> : MutableSet<E>typealias HashSet<E> = HashSet<E>open class HashSet<E> : AbstractMutableSet<E>, MutableSet<E>class HashSet<E> :
MutableSet<E>,
KonanSet<E>,
AbstractMutableSet<E>HexFormat
Represents hexadecimal format options.
class HexFormatHiddenFromObjC
Instructs the Kotlin compiler to remove this class, function or property from the public Objective-C API.
annotation class HiddenFromObjCHidesFromObjC
Meta-annotation that instructs the Kotlin compiler to remove the annotated class, function or property from the public Objective-C API.
annotation class HidesFromObjCHitRegionOptions
interface HitRegionOptionsHTMLAllCollection
abstract class HTMLAllCollectionHTMLCollection
Exposes the JavaScript HTMLCollection to Kotlin
abstract class HTMLCollection :
ItemArrayLike<Element>,
UnionElementOrHTMLCollectionHTMLHyperlinkElementUtils
Exposes the JavaScript HTMLHyperlinkElementUtils to Kotlin
interface HTMLHyperlinkElementUtilsHTMLOrSVGImageElement
interface HTMLOrSVGImageElement : CanvasImageSourceHTMLOrSVGScriptElement
interface HTMLOrSVGScriptElementIgnore
annotation class IgnoreImageBitmap
Exposes the JavaScript ImageBitmap to Kotlin
abstract class ImageBitmap :
CanvasImageSource,
TexImageSourceImageBitmapOptions
interface ImageBitmapOptionsImageBitmapRenderingContext
Exposes the JavaScript ImageBitmapRenderingContext to Kotlin
abstract class ImageBitmapRenderingContextImageBitmapRenderingContextSettings
interface ImageBitmapRenderingContextSettingsImageBitmapSource
interface ImageBitmapSourceImageData
Exposes the JavaScript ImageData to Kotlin
open class ImageData : ImageBitmapSource, TexImageSourceImageOrientation
interface ImageOrientationImageSmoothingQuality
interface ImageSmoothingQualityImmutableBlob
An immutable compile-time array of bytes.
class ImmutableBlobIndexedValue
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 : UIEventInitInt16Array
Exposes the JavaScript Int16Array to Kotlin
open class Int16Array : ArrayBufferViewInt32Array
Exposes the JavaScript Int32Array to Kotlin
open class Int32Array : ArrayBufferViewInt8Array
Exposes the JavaScript Int8Array to Kotlin
open class Int8Array : ArrayBufferViewIntArray
An array of ints. When targeting the JVM, instances of this class are represented as int[].
class IntArrayInteropStubs
annotation class InteropStubsIntIterator
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 JsExportJsExternalArgument
When placed on a function parameter, requires the type of the passed argument to be external.
annotation class JsExternalArgumentJsExternalInheritorsOnly
When placed on an external interface or class, requires all its child interfaces, classes, and objects to be external as well.
annotation class JsExternalInheritorsOnlyJsModule
Denotes an external declaration that must be imported from native JavaScript library.
annotation class JsModuleJsName
Gives a declaration (a function, a property or a class) specific name in JavaScript.
annotation class JsNameJsNonModule
Denotes an external declaration that can be used without module system.
annotation class JsNonModuleJSON
Exposes the JavaScript JSON object to Kotlin.
object JSONJsQualifier
Adds prefix to external declarations in a source file.
annotation class JsQualifierJsValue
open class JsValueJvmDefault
Specifies that a JVM default method should be generated for non-abstract Kotlin interface member.
annotation class JvmDefaultJvmDefaultWithCompatibility
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 JvmDefaultWithCompatibilityJvmDefaultWithoutCompatibility
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 JvmDefaultWithoutCompatibilityJvmField
Instructs the Kotlin compiler not to generate getters/setters for this property and expose it as a field.
annotation class JvmFieldJvmInline
Specifies that given value class is inline class.
annotation class JvmInlineJvmMultifileClass
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 JvmMultifileClassJvmName
Specifies the name for the Java class or method which is generated from this element.
annotation class JvmNameJvmOverloads
Instructs the Kotlin compiler to generate overloads for this function that substitute default parameter values.
annotation class JvmOverloadsJvmRecord
Instructs compiler to mark the class as a record and generate relevant toString/equals/hashCode methods
annotation class JvmRecordJvmSerializableLambda
Makes the annotated lambda function implement java.io.Serializable,
generates a pretty toString implementation and adds reflection metadata.
annotation class JvmSerializableLambdaJvmStatic
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 JvmStaticJvmSuppressWildcards
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 JvmSuppressWildcardsJvmSynthetic
Sets ACC_SYNTHETIC flag on the annotated target in the Java bytecode.
annotation class JvmSyntheticJvmWildcard
Instructs compiler to generate wildcard for annotated type arguments corresponding to parameters with declaration-site variance.
annotation class JvmWildcardKAnnotatedElement
Represents an annotated element and allows to obtain its annotations. See the Kotlin language documentation for more information.
interface KAnnotatedElementKCallable
Represents a callable entity, such as a function or a property.
interface KCallable<out R>interface KCallable<out R> : KAnnotatedElementKClass
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> : KClassifierinterface KClass<T : Any> :
KDeclarationContainer,
KAnnotatedElement,
KClassifierKClassifier
A classifier is either a class or a type parameter.
interface KClassifierKDeclarationContainer
Represents an entity which may contain declarations of any other entities, such as a class or a package.
interface KDeclarationContainerKeyboardEventInit
interface KeyboardEventInit : EventModifierInitKMutableProperty
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 : KAnnotatedElementKProperty
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>, () -> VKProperty1
Represents a property, operations on which take one receiver as a parameter.
interface KProperty1<T, out V> : KProperty<V>, (T) -> VKProperty2
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) -> VKType
Represents a type. Type is usually either a class with optional type arguments, or a type parameter of some declaration, plus nullability.
interface KTypeinterface KType : KAnnotatedElementKTypeParameter
Represents a declaration of a type parameter of a class or a callable. See the Kotlin language documentation for more information.
interface KTypeParameter : KClassifierKTypeProjection
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 KTypeProjectionLazy
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 LinkedHashMap instance.
class LinkedHashSet<E> : MutableSet<E>typealias LinkedHashSet<E> = LinkedHashSet<E>open class LinkedHashSet<E> : HashSet<E>, MutableSet<E>typealias LinkedHashSet<V> = HashSet<V>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 LongArrayLongIterator
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 MatchGroupdata class MatchGroupMatchGroupCollection
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 : MatchGroupCollectionMatchResult
Represents the results from a single regular expression match.
interface MatchResultMediaDeviceInfo
Exposes the JavaScript MediaDeviceInfo to Kotlin
abstract class MediaDeviceInfoMediaDeviceKind
interface MediaDeviceKindMediaEncryptedEventInit
interface MediaEncryptedEventInit : EventInitMediaError
Exposes the JavaScript MediaError to Kotlin
abstract class MediaErrorMediaKeyMessageEventInit
interface MediaKeyMessageEventInit : EventInitMediaKeyMessageType
interface MediaKeyMessageTypeMediaKeySessionType
interface MediaKeySessionTypeMediaKeysRequirement
interface MediaKeysRequirementMediaKeyStatus
interface MediaKeyStatusMediaKeyStatusMap
Exposes the JavaScript MediaKeyStatusMap to Kotlin
abstract class MediaKeyStatusMapMediaKeySystemAccess
Exposes the JavaScript MediaKeySystemAccess to Kotlin
abstract class MediaKeySystemAccessMediaKeySystemConfiguration
Exposes the JavaScript MediaKeySystemConfiguration to Kotlin
interface MediaKeySystemConfigurationMediaKeySystemMediaCapability
interface MediaKeySystemMediaCapabilityMediaList
abstract class MediaList : ItemArrayLike<String>MediaProvider
interface MediaProviderMediaQueryListEventInit
interface MediaQueryListEventInit : EventInitMediaStreamConstraints
Exposes the JavaScript MediaStreamConstraints to Kotlin
interface MediaStreamConstraintsMediaStreamTrackEventInit
interface MediaStreamTrackEventInit : EventInitMediaStreamTrackState
interface MediaStreamTrackStateMediaTrackCapabilities
interface MediaTrackCapabilitiesMediaTrackConstraints
Exposes the JavaScript MediaTrackConstraints to Kotlin
interface MediaTrackConstraints : MediaTrackConstraintSetMediaTrackConstraintSet
interface MediaTrackConstraintSetMediaTrackSettings
Exposes the JavaScript MediaTrackSettings to Kotlin
interface MediaTrackSettingsMediaTrackSupportedConstraints
Exposes the JavaScript MediaTrackSupportedConstraints to Kotlin
interface MediaTrackSupportedConstraintsMemoryUsage
This class represents statistics of memory usage in one memory pool.
class MemoryUsageMessageChannel
Exposes the JavaScript MessageChannel to Kotlin
open class MessageChannelMessageEventInit
interface MessageEventInit : EventInitMetadata
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 MetadataMimeTypeArray
Exposes the JavaScript MimeTypeArray to Kotlin
abstract class MimeTypeArray : ItemArrayLike<MimeType>MouseEventInit
interface MouseEventInit : EventModifierInitMustBeDocumented
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 MustBeDocumentedMutableCollection
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 MutableDataMutableEntry
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 MutationObserverMutationObserverInit
Exposes the JavaScript MutationObserverInit to Kotlin
interface MutationObserverInitMutationRecord
Exposes the JavaScript MutationRecord to Kotlin
abstract class MutationRecordNamedNodeMap
Exposes the JavaScript NamedNodeMap to Kotlin
abstract class NamedNodeMap : ItemArrayLike<Attr>NativeFreeablePlacement
interface NativeFreeablePlacement : NativePlacementnativeGetter
annotation class nativeGetternativeHeap
object nativeHeap : NativeFreeablePlacementnativeInvoke
annotation class nativeInvokeNativePlacement
interface NativePlacementNativePointed
The entity which has an associated native pointer. Subtypes are supposed to represent interpretations of the pointed data or code.
open class NativePointedNativeRuntimeApi
This annotation marks the Kotlin/Native standard library API that tweaks or otherwise accesses the Kotlin runtime behavior.
annotation class NativeRuntimeApinativeSetter
annotation class nativeSetterNavigator
Exposes the JavaScript Navigator to Kotlin
abstract class Navigator :
NavigatorID,
NavigatorLanguage,
NavigatorOnLine,
NavigatorContentUtils,
NavigatorCookies,
NavigatorPlugins,
NavigatorConcurrentHardwareNavigatorConcurrentHardware
Exposes the JavaScript NavigatorConcurrentHardware to Kotlin
interface NavigatorConcurrentHardwareNavigatorContentUtils
interface NavigatorContentUtilsNavigatorCookies
interface NavigatorCookiesNavigatorID
Exposes the JavaScript NavigatorID to Kotlin
interface NavigatorIDNavigatorLanguage
Exposes the JavaScript NavigatorLanguage to Kotlin
interface NavigatorLanguageNavigatorOnLine
Exposes the JavaScript NavigatorOnLine to Kotlin
interface NavigatorOnLineNavigatorPlugins
Exposes the JavaScript NavigatorPlugins to Kotlin
interface NavigatorPluginsNodeFilter
Exposes the JavaScript NodeFilter to Kotlin
interface NodeFilterNodeIterator
Exposes the JavaScript NodeIterator to Kotlin
abstract class NodeIteratorNodeList
Exposes the JavaScript NodeList to Kotlin
abstract class NodeList : ItemArrayLike<Node>NonDocumentTypeChildNode
Exposes the JavaScript NonDocumentTypeChildNode to Kotlin
interface NonDocumentTypeChildNodeNonElementParentNode
interface NonElementParentNodeNothing
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 NothingNotificationAction
interface NotificationActionNotificationDirection
interface NotificationDirectionNotificationEventInit
interface NotificationEventInit : ExtendableEventInitNotificationOptions
interface NotificationOptionsNotificationPermission
interface NotificationPermissionNumber
Superclass for all platform classes representing numeric values.
abstract class NumberObjCAction
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 ObjCActionObjCClass
interface ObjCClass : ObjCObjectObjCClassOf
interface ObjCClassOf<T : ObjCObject> : ObjCClassObjCConstructor
annotation class ObjCConstructorObjCDirect
annotation class ObjCDirectObjCFactory
annotation class ObjCFactoryObjCMethod
annotation class ObjCMethodObjCName
Instructs the Kotlin compiler to use a custom Objective-C and/or Swift name for this class, property, parameter or function.
annotation class ObjCNameObjCObject
interface ObjCObjectObjCObjectBase
abstract class ObjCObjectBase : ObjCObjectObjCOutlet
Makes Kotlin property in Objective-C class settable through Objective-C dispatch to be used as IB outlet.
annotation class ObjCOutletObjCProtocol
interface ObjCProtocol : ObjCObjectObservableProperty
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 ObsoleteNativeApiObsoleteWorkersApi
Marks all Worker-related API as obsolete.
annotation class ObsoleteWorkersApiOpenEndRange
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 OptInOptionalExpectation
Marks an expected annotation class that it isn't required to have actual counterparts in all platforms.
annotation class OptionalExpectationOverconstrainedErrorEventInit
interface OverconstrainedErrorEventInit : EventInitOverloadResolutionByLambdaReturnType
Enables overload selection based on the type of the value returned from lambda argument.
annotation class OverloadResolutionByLambdaReturnTypePageTransitionEventInit
interface PageTransitionEventInit : EventInitPair
Represents a generic pair of two values.
data class Pair<out A, out B> : SerializableParameterName
Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).
annotation class ParameterNameParentNode
Exposes the JavaScript ParentNode to Kotlin
interface ParentNodePath2D
Exposes the JavaScript Path2D to Kotlin
open class Path2D : CanvasPathPerformanceNavigation
Exposes the JavaScript PerformanceNavigation to Kotlin
abstract class PerformanceNavigationPerformanceTiming
Exposes the JavaScript PerformanceTiming to Kotlin
abstract class PerformanceTimingPinned
data class Pinned<out T : Any>Platform
Object describing the current platform program executes upon.
object PlatformPlugin
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 : MouseEventInitPopStateEventInit
interface PopStateEventInit : EventInitPremultiplyAlpha
interface PremultiplyAlphaProgressEventInit
interface ProgressEventInit : EventInitPromise
Exposes the JavaScript Promise object to Kotlin.
open class Promise<out T>PromiseRejectionEventInit
interface PromiseRejectionEventInit : EventInitPropertyDelegateProvider
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 PublishedApiPurelyImplements
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 PurelyImplementsRandom
An abstract class that is implemented by random number generator algorithms.
abstract class RandomRandomAccess
Marker interface indicating that the List implementation supports fast indexed access.
interface RandomAccesstypealias RandomAccess = RandomAccessReadOnlyProperty
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 ReadyStateRefinesInSwift
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 RefinesInSwiftRegex
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 Regexclass Regex : SerializableRegExp
Exposes the JavaScript RegExp object to Kotlin.
class RegExpRegExpMatch
Represents the return value of RegExp.exec.
interface RegExpMatchRegistrationOptions
interface RegistrationOptionsRelatedEventInit
interface RelatedEventInit : EventInitRenderingContext
interface RenderingContextRepeatable
This meta-annotation determines that an annotation is applicable twice or more on a single code element
annotation class RepeatableReplaceWith
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 ReplaceWithRequestCache
interface RequestCacheRequestCredentials
interface RequestCredentialsRequestDestination
interface RequestDestinationRequestInit
interface RequestInitRequestMode
interface RequestModeRequestRedirect
interface RequestRedirectRequestType
interface RequestTypeRequiresOptIn
Signals that the annotated annotation class is a marker of an API that requires an explicit opt-in.
annotation class RequiresOptInResizeQuality
interface ResizeQualityResponseInit
interface ResponseInitResponseType
interface ResponseTypeRestrictsSuspension
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 RestrictsSuspensionRetain
Preserve the function entry point during global optimizations.
annotation class RetainRetainForTarget
Preserve the function entry point during global optimizations, only for the given target.
annotation class RetainForTargetRetention
This meta-annotation determines whether an annotation is stored in binary output and visible for reflection. By default, both are true.
annotation class RetentionReturns
Describes a situation when a function returns normally with a given return value.
interface Returns : SimpleEffectReturnsNotNull
Describes a situation when a function returns normally with any non-null return value.
interface ReturnsNotNull : SimpleEffectRootSetStatistics
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 RootSetStatisticsScrollBehavior
interface ScrollBehaviorScrollIntoViewOptions
interface ScrollIntoViewOptions : ScrollOptionsScrollLogicalPosition
interface ScrollLogicalPositionScrollOptions
interface ScrollOptionsScrollRestoration
interface ScrollRestorationScrollToOptions
Exposes the JavaScript ScrollToOptions to Kotlin
interface ScrollToOptions : ScrollOptionsSelectionMode
interface SelectionModeSequence
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 : EventInitServiceWorkerState
interface ServiceWorkerStateSet
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) -> UnitSetter
Setter of the property is a set method declared alongside the property.
interface Setter<T, V> :
KMutableProperty.Setter<V>,
(T, V) -> UnitSetter
Setter of the property is a set method declared alongside the property.
interface Setter<D, E, V> :
KMutableProperty.Setter<V>,
(D, E, V) -> UnitSettings
interface SettingsShadowAnimation
open class ShadowAnimationShadowRootInit
interface ShadowRootInitShadowRootMode
interface ShadowRootModeSharedImmutable
Note: this annotation has effect only in Kotlin/Native with legacy memory manager.
annotation class SharedImmutableShortArray
An array of shorts. When targeting the JVM, instances of this class are represented as short[].
class ShortArrayShortIterator
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 ShouldRefineInSwiftSimpleEffect
An effect that can be observed after a function invocation.
interface SimpleEffect : EffectSinceKotlin
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 SinceKotlinSkiaRefCnt
interface SkiaRefCntStableRef
class StableRef<out T : Any>StorageEventInit
interface StorageEventInit : EventInitStrictfp
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 StrictfpString
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>, CharSequenceStringBuilder
A mutable sequence of characters.
class StringBuilder : Appendable, CharSequencetypealias StringBuilder = StringBuilderclass StringBuilder : CharSequence, AppendableStyleSheet
Exposes the JavaScript StyleSheet to Kotlin
abstract class StyleSheetStyleSheetList
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 SubclassOptInRequiredSuppress
Suppresses the given compilation warnings in the annotated element.
annotation class SuppressSuspendFunction
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 SVGAnimatedAngleSVGAnimatedBoolean
Exposes the JavaScript SVGAnimatedBoolean to Kotlin
abstract class SVGAnimatedBooleanSVGAnimatedEnumeration
Exposes the JavaScript SVGAnimatedEnumeration to Kotlin
abstract class SVGAnimatedEnumerationSVGAnimatedInteger
Exposes the JavaScript SVGAnimatedInteger to Kotlin
abstract class SVGAnimatedIntegerSVGAnimatedLength
Exposes the JavaScript SVGAnimatedLength to Kotlin
abstract class SVGAnimatedLengthSVGAnimatedLengthList
Exposes the JavaScript SVGAnimatedLengthList to Kotlin
abstract class SVGAnimatedLengthListSVGAnimatedNumber
Exposes the JavaScript SVGAnimatedNumber to Kotlin
abstract class SVGAnimatedNumberSVGAnimatedNumberList
Exposes the JavaScript SVGAnimatedNumberList to Kotlin
abstract class SVGAnimatedNumberListSVGAnimatedPoints
Exposes the JavaScript SVGAnimatedPoints to Kotlin
interface SVGAnimatedPointsSVGAnimatedPreserveAspectRatio
Exposes the JavaScript SVGAnimatedPreserveAspectRatio to Kotlin
abstract class SVGAnimatedPreserveAspectRatioSVGAnimatedRect
Exposes the JavaScript SVGAnimatedRect to Kotlin
abstract class SVGAnimatedRectSVGAnimatedString
Exposes the JavaScript SVGAnimatedString to Kotlin
abstract class SVGAnimatedStringSVGAnimatedTransformList
Exposes the JavaScript SVGAnimatedTransformList to Kotlin
abstract class SVGAnimatedTransformListSVGBoundingBoxOptions
interface SVGBoundingBoxOptionsSVGElementInstance
interface SVGElementInstanceSVGFitToViewBox
interface SVGFitToViewBox
SVGLengthList
Exposes the JavaScript SVGLengthList to Kotlin
abstract class SVGLengthListSVGNameList
abstract class SVGNameList
SVGNumberList
Exposes the JavaScript SVGNumberList to Kotlin
abstract class SVGNumberListSVGPointList
abstract class SVGPointListSVGPreserveAspectRatio
Exposes the JavaScript SVGPreserveAspectRatio to Kotlin
abstract class SVGPreserveAspectRatioSVGStringList
Exposes the JavaScript SVGStringList to Kotlin
abstract class SVGStringList
SVGTransform
Exposes the JavaScript SVGTransform to Kotlin
abstract class SVGTransformSVGTransformList
Exposes the JavaScript SVGTransformList to Kotlin
abstract class SVGTransformListSVGUnitTypes
Exposes the JavaScript SVGUnitTypes to Kotlin
interface SVGUnitTypesSVGURIReference
Exposes the JavaScript SVGURIReference to Kotlin
interface SVGURIReferenceSVGZoomAndPan
Exposes the JavaScript SVGZoomAndPan to Kotlin
interface SVGZoomAndPanSweepStatistics
This class represents statistics of sweeping in one memory pool.
class SweepStatisticsSymbolName
This is a dangerous deprecated and internal annotation. Please avoid using it.
annotation class SymbolNameSynchronized
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 Synchronizedannotation class SynchronizedTarget
This meta-annotation indicates the kinds of code elements which are possible targets of an annotation.
annotation class TargetTexImageSource
interface TexImageSourceTextMetrics
Exposes the JavaScript TextMetrics to Kotlin
abstract class TextMetricsTextTrackCueList
abstract class TextTrackCueListTextTrackKind
interface TextTrackKindTextTrackMode
interface TextTrackModeThreadLocal
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 ThreadLocalThrowable
The base class for all errors and exceptions. Only instances of this class can be thrown or caught.
open class ThrowableThrows
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 Throwstypealias Throws = ThrowsThrows
This annotation indicates what exceptions should be declared by a function when compiled to a JVM method.
annotation class ThrowsTimedValue
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 TimeMarkTimeRanges
Exposes the JavaScript TimeRanges to Kotlin
abstract class TimeRangesTimeSource
A source of time for measuring time intervals.
interface TimeSourceTouchList
abstract class TouchList : ItemArrayLike<Touch>TrackEventInit
interface TrackEventInit : EventInitTransient
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 TransientTreeWalker
Exposes the JavaScript TreeWalker to Kotlin
abstract class TreeWalkerTriple
Represents a triad of values
data class Triple<out A, out B, out C> : SerializableTypography
Defines names for Unicode symbols used in proper Typography.
object TypographyUByte
class UByte : Comparable<UByte>UByteArray
class UByteArray : Collection<UByte>UIEventInit
interface UIEventInit : EventInitUInt
class UInt : Comparable<UInt>Uint16Array
Exposes the JavaScript Uint16Array to Kotlin
open class Uint16Array : ArrayBufferViewUint32Array
Exposes the JavaScript Uint32Array to Kotlin
open class Uint32Array : ArrayBufferViewUint8Array
Exposes the JavaScript Uint8Array to Kotlin
open class Uint8Array : ArrayBufferViewUint8ClampedArray
Exposes the JavaScript Uint8ClampedArray to Kotlin
open class Uint8ClampedArray : ArrayBufferViewUIntArray
class UIntArray : Collection<UInt>ULong
class ULong : Comparable<ULong>ULongArray
class ULongArray : Collection<ULong>ULongRange
interface ULongRangeUnionAudioTrackOrTextTrackOrVideoTrack
interface UnionAudioTrackOrTextTrackOrVideoTrackUnionClientOrMessagePortOrServiceWorker
interface UnionClientOrMessagePortOrServiceWorkerUnionElementOrHTMLCollection
interface UnionElementOrHTMLCollectionUnionElementOrMouseEvent
interface UnionElementOrMouseEventUnionElementOrProcessingInstruction
interface UnionElementOrProcessingInstructionUnionElementOrRadioNodeList
interface UnionElementOrRadioNodeListUnionHTMLOptGroupElementOrHTMLOptionElement
interface UnionHTMLOptGroupElementOrHTMLOptionElementUnionMessagePortOrServiceWorker
interface UnionMessagePortOrServiceWorkerUnionMessagePortOrWindowProxy
interface UnionMessagePortOrWindowProxyUnit
The type with only one value: the Unit object. This type corresponds to the void type in Java.
object UnitUnsafeNumber
Marker for declarations that depend on numeric types of different bit width on at least two platforms.
annotation class UnsafeNumberUnsafeVariance
Suppresses errors about variance conflict
annotation class UnsafeVarianceURLSearchParams
Exposes the JavaScript URLSearchParams to Kotlin
open class URLSearchParamsUShort
class UShort : Comparable<UShort>UShortArray
class UShortArray : Collection<UShort>ValidityState
Exposes the JavaScript ValidityState to Kotlin
abstract class ValidityStateVector128
class Vector128VideoFacingModeEnum
interface VideoFacingModeEnumVideoResizeModeEnum
interface VideoResizeModeEnumVideoTrack
Exposes the JavaScript VideoTrack to Kotlin
abstract class VideoTrack :
UnionAudioTrackOrTextTrackOrVideoTrackVolatile
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 Volatileannotation class VolatileVolatile
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 Volatiletypealias Volatile = VolatileWeakReference
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 WebGLActiveInfoWebGLContextAttributes
interface WebGLContextAttributesWebGLContextEventInit
interface WebGLContextEventInit : EventInitWebGLObject
abstract class WebGLObjectWebGLRenderingContext
Exposes the JavaScript WebGLRenderingContext to Kotlin
abstract class WebGLRenderingContext :
WebGLRenderingContextBase,
RenderingContextWebGLRenderingContextBase
interface WebGLRenderingContextBaseWebGLShaderPrecisionFormat
Exposes the JavaScript WebGLShaderPrecisionFormat to Kotlin
abstract class WebGLShaderPrecisionFormatWebGLUniformLocation
Exposes the JavaScript WebGLUniformLocation to Kotlin
abstract class WebGLUniformLocationWheelEventInit
interface WheelEventInit : MouseEventInitWindowEventHandlers
Exposes the JavaScript WindowEventHandlers to Kotlin
interface WindowEventHandlersWindowLocalStorage
Exposes the JavaScript WindowLocalStorage to Kotlin
interface WindowLocalStorageWindowOrWorkerGlobalScope
Exposes the JavaScript WindowOrWorkerGlobalScope to Kotlin
interface WindowOrWorkerGlobalScopeWindowSessionStorage
Exposes the JavaScript WindowSessionStorage to Kotlin
interface WindowSessionStorageWorker
class WorkerWorkerBoundReference
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 WorkerLocationWorkerNavigator
Exposes the JavaScript WorkerNavigator to Kotlin
abstract class WorkerNavigator :
NavigatorID,
NavigatorLanguage,
NavigatorOnLine,
NavigatorConcurrentHardwareWorkerOptions
interface WorkerOptionsWorkerType
interface WorkerTypeXMLHttpRequestResponseType
interface XMLHttpRequestResponseTypeXMLSerializer
Exposes the JavaScript XMLSerializer to Kotlin
open class XMLSerializer