Options
All
  • Public
  • Public/Protected
  • All
Menu

Module <internal>

Index

Namespaces

Enumerations

Enumeration Members

Classes

Interfaces

Type Aliases

Variables

Enumeration Members

NullEvent: ""

Type Aliases

Action<TContext, TEvent>: ActionType | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent>

Type Parameters

ActionFunction<TContext, TEvent>: ((context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent>) => void)

Type Parameters

Type declaration

    • (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent>): void
    • Parameters

      • context: TContext
      • event: TEvent
      • meta: ActionMeta<TContext, TEvent>

      Returns void

ActionType: string
Activity<TContext, TEvent>: string | ActivityDefinition<TContext, TEvent>

Type Parameters

ActivityConfig<TContext, TEvent>: ((ctx: TContext, activity: ActivityDefinition<TContext, TEvent>) => DisposeActivityFunction | void)

Type Parameters

Type declaration

AlgorithmIdentifier: string | Algorithm
AnimationPlayState: "finished" | "idle" | "paused" | "running"
AppendMode: "segments" | "sequence"
ArrayBufferLike: ArrayBufferTypes[keyof ArrayBufferTypes]
AuthErrorParams: { code: UniversalAPIAuthErrorCode; originalError?: unknown }

Constructor parameters of the {@link UniversalAPIAuthError} class.

Type declaration

AvailableKeyOf<T>: ValueOf<{ [ K in keyof T]: [T[K]] extends [never] ? never : K }>

Same as keyof T, but omitting keys of properties with values resolving to never.

Type Parameters

  • T

BackendAPIInit: { base?: URL; cache?: Storage; clientId: string; clientSecret: string; level?: LogLevel; refreshToken: string; storage?: Storage; version?: BackendAPIVersion }

Contructor parameters of the {@link BackendAPI} class.

Type declaration

BackendAPIVersion: "1"

In order to facilitate any major, unforeseen breaking changes in the future, we require each request to include API version. We hope to rarely (never?) change it but by requiring it up front, we can ensure what you get today is what you’ll get tomorrow.

BinaryData: ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array
BufferEncoding: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "latin1" | "binary" | "hex"
BufferSource: ArrayBufferView | ArrayBuffer
CanPlayTypeResult: "" | "maybe" | "probably"
CanvasDirection: "inherit" | "ltr" | "rtl"
CanvasLineCap: "butt" | "round" | "square"
CanvasLineJoin: "bevel" | "miter" | "round"
CanvasTextAlign: "center" | "end" | "left" | "right" | "start"
CanvasTextBaseline: "alphabetic" | "bottom" | "hanging" | "ideographic" | "middle" | "top"
CeaseCallback: (() => void)

Type declaration

    • (): void
    • Returns void

Child<TGraph, TQuery>: TGraph extends With<Core.Graph, "child"> ? ReadonlyArray<Child<TGraph["child"], ChildQuery<TGraph, TQuery>>> : Links<TGraph> & Props<TGraph, TQuery> & Embeds<TGraph, TQuery>

Constructs a resource record for an embedded (child) graph node and query.

Type Parameters

ChildFields<TGraph, TQuery>: TQuery extends With<Query<TGraph["child"]>, "fields"> ? { fields: TQuery["fields"] } : unknown

Type Parameters

ChildQuery<TGraph, TQuery>: Record<string, unknown> & ChildZoom<TGraph, TQuery> & ChildFields<TGraph, TQuery>

Type Parameters

ChildZoom<TGraph, TQuery>: TQuery extends With<Query<TGraph["child"]>, "zoom"> ? { zoom: TQuery["zoom"] } : unknown

Type Parameters

CodesDict: {}

Type declaration

  • [key: number]: { code: string; parent: string }
    • code: string
    • parent: string
Collection: Resource & { _links: { first: { href: string } } }
CollectionGraphLinks<TGraph>: { first: TGraph; last: TGraph; next: TGraph; prev: TGraph; self: TGraph }

Type Parameters

Type declaration

  • first: TGraph

    First page of this collection.

  • last: TGraph

    Last page of this collection.

  • next: TGraph

    Next page of this collection.

  • prev: TGraph

    Previous page of this collection.

  • self: TGraph

    This collection.

CollectionGraphProps: { limit: number; offset: number; returned_items: number; total_items: number }

Type declaration

  • limit: number

    Maximum allowed number of items for this query.

  • offset: number

    Number of skipped items.

  • returned_items: number

    Number of items returned with this response.

  • total_items: number

    Total number of resources in this collection.

CompositeOperationOrAuto: "accumulate" | "add" | "auto" | "replace"
ConditionPredicate<TContext, TEvent>: ((context: TContext, event: TEvent, meta: GuardMeta<TContext, TEvent>) => boolean)

Type Parameters

Type declaration

    • (context: TContext, event: TEvent, meta: GuardMeta<TContext, TEvent>): boolean
    • Parameters

      • context: TContext
      • event: TEvent
      • meta: GuardMeta<TContext, TEvent>

      Returns boolean

Config: Backend.Rels.CustomerPortalSettings["props"]["subscriptions"]["allowNextDateModification"]
Config: Customer.Rels.CustomerPortalSettings["props"]["subscriptions"]["allow_next_date_modification"]
ConsolaMock: ((...args: any) => void)

Type declaration

    • (...args: any): void
    • Parameters

      • Rest ...args: any

      Returns void

ConsolaMockFn: ((type: logType, defaults: ConsolaLogObject) => ConsolaMock)

Type declaration

Constraints: { allowedDaysOfMonth?: number[]; allowedDaysOfWeek?: number[]; disallowedDates?: string[]; max?: string; min?: string }

Type declaration

  • Optional allowedDaysOfMonth?: number[]
  • Optional allowedDaysOfWeek?: number[]
  • Optional disallowedDates?: string[]
  • Optional max?: string
  • Optional min?: string
Constraints: { allowedDaysOfMonth?: number[]; allowedDaysOfWeek?: number[]; disallowedDates?: string[]; max?: string; min?: string }

Type declaration

  • Optional allowedDaysOfMonth?: number[]
  • Optional allowedDaysOfWeek?: number[]
  • Optional disallowedDates?: string[]
  • Optional max?: string
  • Optional min?: string
CurieChain: [URL, ...string[]]

Chain of curies leading to a hAPI resource starting with a base URL.

Data: Record<string, unknown>

Nucleon state machine data.

DelayConfig<TContext, TEvent>: number | DelayExpr<TContext, TEvent>

Type Parameters

DelayExpr<TContext, TEvent>: ExprWithMeta<TContext, TEvent, number>

Type Parameters

DisposeActivityFunction: (() => void)

Type declaration

    • (): void
    • Returns void

DocumentReadyState: "complete" | "interactive" | "loading"
Embeds<TGraph, TQuery>: ExcludeNever<{ _embedded: TGraph extends With<Core.Graph, "child" | "curie"> ? Record<TGraph["curie"], Child<TGraph, TQuery>> : TGraph extends With<Core.Graph, "zooms"> ? ResourceEmbed<TGraph, TQuery> : never }>

Constructs part of the resource record with the embedded content.

Type Parameters

Event<TEvent>: TEvent["type"] | TEvent

The specified string event types or the specified event objects.

Type Parameters

EventListenerOrEventListenerObject: EventListener | EventListenerObject
Exclude<T, U>: T extends U ? never : T

Exclude from T those types that are assignable to U

Type Parameters

  • T

  • U

ExcludeNever<T>: { [ K in AvailableKeyOf<T>]: T[K] }

From T, pick a set of properties whose values are not never.

Type Parameters

  • T

Expr<TContext, TEvent, T>: ((context: TContext, event: TEvent) => T)

Type Parameters

Type declaration

    • (context: TContext, event: TEvent): T
    • Parameters

      • context: TContext
      • event: TEvent

      Returns T

ExprWithMeta<TContext, TEvent, T>: ((context: TContext, event: TEvent, meta: SCXMLEventMeta<TEvent>) => T)

Type Parameters

Type declaration

    • Parameters

      Returns T

Extract<T, U>: T extends U ? T : never

Extract from T those types that are assignable to U

Type Parameters

  • T

  • U

Fields<TGraph>: TGraph extends With<Core.Graph, "props"> ? ReadonlyArray<keyof TGraph["props"]> : never

Type Parameters

Float32List: Float32Array | GLfloat[]
FollowableChild<TGraph, TQuery>: TGraph extends With<Core.Graph, "child"> ? ReadonlyArray<FollowableChild<TGraph["child"], FollowableChildQuery<TGraph, TQuery>>> : FollowableLinks<TGraph> & Props<TGraph, TQuery> & FollowableEmbeds<TGraph, TQuery>

Constructs a resource record for an embedded (child) graph node and query.

Type Parameters

FollowableChildFields<TGraph, TQuery>: TQuery extends With<Query<TGraph["child"]>, "fields"> ? { fields: TQuery["fields"] } : unknown

Type Parameters

FollowableChildQuery<TGraph, TQuery>: Record<string, unknown> & FollowableChildZoom<TGraph, TQuery> & FollowableChildFields<TGraph, TQuery>

Type Parameters

FollowableChildZoom<TGraph, TQuery>: TQuery extends With<Query<TGraph["child"]>, "zoom"> ? { zoom: TQuery["zoom"] } : unknown

Type Parameters

FollowableEmbed<TGraph, TQuery>: IntersectionValueOf<{ [ Rel in Zooms<TGraph, TQuery>]: Required<TGraph["zooms"]>[Rel] extends With<Core.Graph, "curie"> ? { [ Curie in Required<TGraph["zooms"]>[Rel]["curie"]]: FollowableChild<Required<TGraph["zooms"]>[Rel], Record<"zoom", ZoomOn<TGraph, TQuery, Rel>>> } : never }>

For each zoomed rel that has a curie, creates a record like { [curie]: APIResponseJSONChild } and returns the intersection of those records.

Type Parameters

FollowableEmbeds<TGraph, TQuery>: ExcludeNever<{ _embedded: TGraph extends With<Core.Graph, "child" | "curie"> ? Record<TGraph["curie"], FollowableChild<TGraph, TQuery>> : TGraph extends With<Core.Graph, "zooms"> ? FollowableEmbed<TGraph, TQuery> : never }>

Constructs part of the resource record with the embedded content.

Type Parameters

FollowableLinks<TGraph>: TGraph extends With<Core.Graph, "links"> ? { _links: { [ TLink in keyof TGraph["links"]]: Link & Pick<Node<TGraph["links"][TLink]>, NodeMethods> } } : unknown

Constructs part of the resource record that includes hAPI links.

Type Parameters

GLfloat: number
GLint: number
GLuint: number
GamepadHand: "" | "left" | "right"
GamepadMappingType: "" | "standard"
GrantOpts: ({ code: string } | { refreshToken: string }) & { base?: URL; clientId: string; clientSecret: string; version?: BackendAPIVersion }
Guard<TContext, TEvent>: GuardPredicate<TContext, TEvent> | Record<string, any> & { type: string }

Type Parameters

HTMLOrSVGImageElement: HTMLImageElement | SVGImageElement
IDBCursorDirection: "next" | "nextunique" | "prev" | "prevunique"
IDBRequestReadyState: "done" | "pending"
IDBTransactionMode: "readonly" | "readwrite" | "versionchange"
IDBValidKey: number | string | Date | BufferSource | IDBArrayKey
ImageBitmapSource: CanvasImageSource | Blob | ImageData
ImageSmoothingQuality: "high" | "low" | "medium"
Init: { base: URL; cache?: Storage; fetch?: Window["fetch"]; level?: LogLevel; storage?: Storage }

API constructor parameters.

Type declaration

  • base: URL

    Bookmark URL for this API. This is where the tree traversal begins. We also use this URL as a base for relative paths.

  • Optional cache?: Storage

    Resolver cache implementing Web Storage API. Every resolved path will be stored here for future use. Defaults to in-memory storage.

  • Optional fetch?: Window["fetch"]

    Request handler implementing Fetch API. This function will be called whenever a resource is requested. Defaults to native fetch or a custom implementation of Fetch API for Node.

  • Optional level?: LogLevel

    Numeric Consola log level. If omitted, Consola defaults will be used.

  • Optional storage?: Storage

    Credentials storage implementing Web Storage API. Access tokens and other related info will be stored here. Defaults to in-memory storage.

InsertPosition: "beforebegin" | "afterbegin" | "beforeend" | "afterend"
Int32List: Int32Array | GLint[]
IntersectionValueOf<T>: UnionToIntersection<ValueOf<T>>

Creates intersection type out of a record values union.

Type Parameters

  • T

InvokeCallback: ((callback: Sender<any>, onReceive: Receiver<EventObject>) => any)

Type declaration

InvokeCreator<TContext, TEvent, TFinalContext>: ((context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<any> | InvokeCallback)

Type Parameters

Type declaration

    • Returns either a Promises or a callback handler (for streams of events) given the machine's current context and event that invoked the service.

      For Promises, the only events emitted to the parent will be:

      • done.invoke.<id> with the data containing the resolved payload when the promise resolves, or:
      • error.platform.<id> with the data containing the caught error, and src containing the service id.

      For callback handlers, the callback will be provided, which will send events to the parent service.

      Parameters

      • context: TContext

        The current machine context

      • event: TEvent

        The event that invoked the service

      • meta: InvokeMeta

      Returns PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<any> | InvokeCallback

IteratorResult<T, TReturn>: IteratorYieldResult<T> | IteratorReturnResult<TReturn>

Type Parameters

  • T

  • TReturn = any

KeyOf<T>: [T] extends [never] ? never : keyof T

Same as keyof T, but creates an alias of never when given never.

Type Parameters

  • T

KeyType: "private" | "public" | "secret"
KeyUsage: "decrypt" | "deriveBits" | "deriveKey" | "encrypt" | "sign" | "unwrapKey" | "verify" | "wrapKey"
Link: { href: string; name?: string; templated?: boolean; title?: string }

Represents a hAPI relation link.

Type declaration

  • href: string

    URL of the resource this link points to.

  • Optional name?: string

    For named links, this property will include link name.

  • Optional templated?: boolean

    True if this is a template link (example: https://api.foxy.io/rels/{rel})

  • Optional title?: string

    Short description of this link.

Links<TGraph>: TGraph extends With<Core.Graph, "links"> ? { _links: { [ TLink in keyof TGraph["links"]]: Link } } : unknown

Constructs part of the resource record that includes hAPI links.

Type Parameters

ListeningState: "active" | "disambiguation" | "inactive"
MSWebViewPermissionState: "allow" | "defer" | "deny" | "unknown"
MSWebViewPermissionType: "geolocation" | "media" | "pointerlock" | "unlimitedIndexedDBQuota" | "webnotifications"
Mapper<TContext, TEvent, TParams>: ((context: TContext, event: TEvent) => TParams)

Type Parameters

Type declaration

    • (context: TContext, event: TEvent): TParams
    • Parameters

      • context: TContext
      • event: TEvent

      Returns TParams

MediaKeyMessageType: "individualization-request" | "license-release" | "license-renewal" | "license-request"
MediaStreamTrackState: "ended" | "live"
NavigationReason: "down" | "left" | "right" | "up"
NodeInit: { cache: Storage; console: Consola; fetch: Window["fetch"]; path: CurieChain }

Options of {@link APINode} constructor.

Type declaration

  • cache: Storage

    Resolver cache implementing Web Storage API.

  • console: Consola

    Shared Consola instance.

  • fetch: Window["fetch"]

    Custom Fetch API implementation for making authenticated requests.

  • path: CurieChain

    Path to this resource node as base URL followed by a list of curies.

NodeMethods: "delete" | "follow" | "get" | "patch" | "post" | "put"
OffscreenRenderingContextId: "2d" | "bitmaprenderer" | "webgl" | "webgl2"
Omit<T, K>: Pick<T, Exclude<keyof T, K>>

Construct a type with the properties of T except for those in type K.

Type Parameters

  • T

  • K extends keyof any

OnErrorEventHandler: OnErrorEventHandlerNonNull | null
OptionalKeyOf<T>: Exclude<ValueOf<{ [ K in keyof T]: T extends Record<K, T[K]> ? never : K }>, undefined>

Creates a union of optional property keys.

Type Parameters

  • T

Options: { settings: { subscriptions: { allowFrequencyModification: any[] } }; subscription: Omit<Core.Resource<Backend.Rels.Subscription>, "_links" | "_embedded"> }

Type declaration

  • settings: { subscriptions: { allowFrequencyModification: any[] } }
    • subscriptions: { allowFrequencyModification: any[] }
      • allowFrequencyModification: any[]
  • subscription: Omit<Core.Resource<Backend.Rels.Subscription>, "_links" | "_embedded">
Options: { settings: { subscriptions: { allowNextDateModification: Config } }; subscription: Omit<Core.Resource<Backend.Rels.Subscription>, "_links" | "_embedded">; value: string }

Type declaration

Options: { settings: { subscriptions: { allow_frequency_modification: any[] } }; subscription: Omit<Core.Resource<Customer.Rels.Subscription>, "_links" | "_embedded"> }

Type declaration

  • settings: { subscriptions: { allow_frequency_modification: any[] } }
    • subscriptions: { allow_frequency_modification: any[] }
      • allow_frequency_modification: any[]
  • subscription: Omit<Core.Resource<Customer.Rels.Subscription>, "_links" | "_embedded">
Options: { settings: { subscriptions: { allow_next_date_modification: Config } }; subscription: Omit<Core.Resource<Customer.Rels.Subscription>, "_links" | "_embedded">; value: string }

Type declaration

Order<TGraph>: TGraph extends With<Core.Graph, "props"> ? keyof TGraph["props"] | ReadonlyArray<keyof TGraph["props"] | OrderRecord<keyof TGraph["props"]>> | OrderRecord<keyof TGraph["props"]> : never

Type Parameters

OrderRecord<TPropertyKey>: { readonly [ Key in TPropertyKey]?: "asc" | "desc" }

Type Parameters

OrientationLockType: "any" | "landscape" | "landscape-primary" | "landscape-secondary" | "natural" | "portrait" | "portrait-primary" | "portrait-secondary"
OrientationType: "landscape-primary" | "landscape-secondary" | "portrait-primary" | "portrait-secondary"
Partial<T>: { [ P in keyof T]?: T[P] }

Make all properties in T optional

Type Parameters

  • T

Patch: Map<string, Record<string, unknown> | null>
PerformanceEntryList: PerformanceEntry[]
PermissionState: "denied" | "granted" | "prompt"
Pick<T, K>: { [ P in K]: T[P] }

From T, pick a set of properties whose keys are in the union K

Type Parameters

  • T

  • K extends keyof T

PropertyKey: string | number | symbol
PropertyMapper<TContext, TEvent, TParams>: { [ K in keyof TParams]?: ((context: TContext, event: TEvent) => TParams[K]) | TParams[K] }

Type Parameters

Props<TGraph, TQuery>: TGraph extends With<Core.Graph, "props"> ? TGraph extends With<Core.Graph, "child"> ? TGraph["props"] : TQuery extends Query<TGraph> ? TQuery["fields"] extends ReadonlyArray<infer Fields> ? Pick<TGraph["props"], Extract<Fields, keyof TGraph["props"]>> : TGraph["props"] : TGraph["props"] : unknown

Constructs part of the resource record with all requested properties.

Type Parameters

RTCDataChannelState: "closed" | "closing" | "connecting" | "open"
RTCDtlsTransportState: "closed" | "connected" | "connecting" | "failed" | "new"
RTCErrorDetailType: "data-channel-failure" | "dtls-failure" | "fingerprint-failure" | "hardware-encoder-error" | "hardware-encoder-not-available" | "idp-bad-script-failure" | "idp-execution-failure" | "idp-load-failure" | "idp-need-login" | "idp-timeout" | "idp-tls-failure" | "idp-token-expired" | "idp-token-invalid" | "sctp-failure" | "sdp-syntax-error"
RTCIceComponent: "rtcp" | "rtp"
RTCIceGathererState: "complete" | "gathering" | "new"
RTCIceRole: "controlled" | "controlling" | "unknown"
RTCIceTransportState: "checking" | "closed" | "completed" | "connected" | "disconnected" | "failed" | "new"
RTCPriorityType: "high" | "low" | "medium" | "very-low"
ReadableStreamReadResult<T>: ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>

Type Parameters

  • T

Readonly<T>: { readonly [ P in keyof T]: T[P] }

Make all properties in T readonly

Type Parameters

  • T

ReadyState: "closed" | "ended" | "open"
Receiver<TEvent>: ((listener: ((event: TEvent) => void)) => void)

Type Parameters

Type declaration

    • (listener: ((event: TEvent) => void)): void
    • Parameters

      • listener: ((event: TEvent) => void)
          • (event: TEvent): void
          • Parameters

            • event: TEvent

            Returns void

      Returns void

Record<K, T>: { [ P in K]: T }

Construct a type with a set of properties K of type T

Type Parameters

  • K extends keyof any

  • T

ReferrerPolicy: "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url"
RequestCache: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload"
RequestCredentials: "include" | "omit" | "same-origin"
RequestDestination: "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt"
RequestInfo: Request | string
RequestMode: "cors" | "navigate" | "no-cors" | "same-origin"
RequestRedirect: "error" | "follow" | "manual"
Required<T>: { [ P in keyof T]-?: T[P] }

Make all properties in T required

Type Parameters

  • T

RequiredKeyOf<T>: Exclude<ValueOf<{ [ K in keyof T]: T extends Record<K, T[K]> ? K : never }>, undefined>

Creates a union of required property keys.

Type Parameters

  • T

Resource: { _links: { self: { href: string } } }

Type declaration

  • Readonly _links: { self: { href: string } }
    • Readonly self: { href: string }
      • Readonly href: string
ResourceEmbed<TGraph, TQuery>: IntersectionValueOf<{ [ Rel in Zooms<TGraph, TQuery>]: Required<TGraph["zooms"]>[Rel] extends With<Core.Graph, "curie"> ? { [ Curie in Required<TGraph["zooms"]>[Rel]["curie"]]: Child<Required<TGraph["zooms"]>[Rel], Record<"zoom", ZoomOn<TGraph, TQuery, Rel>>> } : never }>

For each zoomed rel that has a curie, creates a record like { [curie]: APIResponseJSONChild } and returns the intersection of those records.

Type Parameters

ResponseType: "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"
ScrollRestoration: "auto" | "manual"
Sender<TEvent>: ((event: Event<TEvent>) => void)

Type Parameters

Type declaration

    • (event: Event<TEvent>): void
    • Parameters

      Returns void

ServiceConfig<TContext, TEvent>: string | StateMachine<any, any, any> | InvokeCreator<TContext, TEvent>

Type Parameters

ServiceWorkerState: "activated" | "activating" | "installed" | "installing" | "parsed" | "redundant"
ShadowRootMode: "closed" | "open"
Share<T>: { data: T | null; related?: ReadonlyArray<string>; source: string }

Type Parameters

Type declaration

  • Readonly data: T | null

    Updated resource or null if it's deleted.

  • Optional Readonly related?: ReadonlyArray<string>

    URIs of resources affected by this update.

  • Readonly source: string

    URI of the updated resource.

SingleOrArray<T>: T[] | T

Type Parameters

  • T

SpeechSynthesisErrorCode: "audio-busy" | "audio-hardware" | "canceled" | "interrupted" | "invalid-argument" | "language-unavailable" | "network" | "not-allowed" | "synthesis-failed" | "synthesis-unavailable" | "text-too-long" | "voice-unavailable"
StateNodesConfig<TContext, TStateSchema, TEvent>: { [ K in keyof TStateSchema["states"]]: StateNode<TContext, TStateSchema["states"][K], TEvent> }

Type Parameters

StateValue: string | StateValueMap

The string or object representing the state value relative to the parent state node.

  • For a child atomic state node, this is a string, e.g., "pending".
  • For complex state nodes, this is an object, e.g., { success: "someChildState" }.
StatesConfig<TContext, TStateSchema, TEvent>: { [ K in keyof TStateSchema["states"]]: StateNodeConfig<TContext, TStateSchema["states"][K], TEvent> }

Type Parameters

StatesDefinition<TContext, TStateSchema, TEvent>: { [ K in keyof TStateSchema["states"]]: StateNodeDefinition<TContext, TStateSchema["states"][K], TEvent> }

Type Parameters

TextTrackKind: "captions" | "chapters" | "descriptions" | "metadata" | "subtitles"
TextTrackMode: "disabled" | "hidden" | "showing"
TimerHandler: string | Function
Token: { access_token: string; expires_in: number; refresh_token: string; scope: string; token_type: string }

Type declaration

  • access_token: string
  • expires_in: number
  • refresh_token: string
  • scope: string
  • token_type: string
TrackCallback: ((update: (<TData>(data: TData) => TData | null)) => void)

Type declaration

    • (update: (<TData>(data: TData) => TData | null)): void
    • Parameters

      • update: (<TData>(data: TData) => TData | null)
          • <TData>(data: TData): TData | null
          • Type Parameters

            Parameters

            • data: TData

            Returns TData | null

      Returns void

Transferable: ArrayBuffer | MessagePort | ImageBitmap | OffscreenCanvas
TransitionConfigOrTarget<TContext, TEvent>: SingleOrArray<TransitionConfigTarget<TContext, TEvent> | TransitionConfig<TContext, TEvent>>

Type Parameters

TransitionConfigTarget<TContext, TEvent>: string | undefined | StateNode<TContext, any, TEvent>

Type Parameters

TransitionDefinitionMap<TContext, TEvent>: { [ K in TEvent["type"] | NullEvent["type"] | "*"]: TransitionDefinition<TContext, K extends TEvent["type"] ? Extract<TEvent, { type: K }> : EventObject>[] }

Type Parameters

TransitionsConfigArray<TContext, TEvent>: ((TEvent extends EventObject ? TransitionConfig<TContext, TEvent> & { event: TEvent["type"] } : never) | TransitionConfig<TContext, TEvent> & { event: "" } | TransitionConfig<TContext, TEvent> & { event: "*" })[]

Type Parameters

TransitionsConfigMap<TContext, TEvent>: { [ K in TEvent["type"]]?: TransitionConfigOrTarget<TContext, TEvent extends { type: K } ? TEvent : never> } & { ?: TransitionConfigOrTarget<TContext, TEvent> } & { *?: TransitionConfigOrTarget<TContext, TEvent> }

Type Parameters

Tree: { include: Record<string, Tree | true> } | { exclude: Record<string, Tree | true> }
Uint32List: Uint32Array | GLuint[]
UnionToIntersection<U>: (U extends any ? ((k: U) => void) : never) extends ((k: infer I) => void) ? I : never

Converts union type to intersection type.

Type Parameters

  • U

UniversalAPIAuthErrorCode: typeof AuthError["NEW_PASSWORD_REQUIRED"] | typeof AuthError["INVALID_NEW_PASSWORD"] | typeof AuthError["UNAUTHORIZED"] | typeof AuthError["INVALID_FORM"] | typeof AuthError["UNAVAILABLE"] | typeof AuthError["UNKNOWN"]

Union of all possible auth error codes.

V8N: { check: any }

Type declaration

  • check:function
    • check(...args: any[]): boolean
ValueOf<T>: T[keyof T]

Creates a union of record values.

Type Parameters

  • T

VisibilityState: "hidden" | "visible"
With<T, K>: Pick<Required<T>, K>

From T, pick a set of properties whose keys are in the union K, and make them required.

Type Parameters

  • T

  • K extends keyof T

XPathNSResolver: ((prefix: string | null) => string | null) | { lookupNamespaceURI: any }
Zoom<TGraph>: TGraph extends With<Core.Graph, "zooms"> ? ZoomString<TGraph> | ZoomRecord<TGraph> | ZoomArray<TGraph> : never

Type Parameters

ZoomArray<TGraph>: ReadonlyArray<ZoomString<TGraph> | ZoomRecord<TGraph>>

Type Parameters

ZoomIn<TZoom, TRel>: TZoom extends (infer Items)[] ? ValueOf<Extract<Items, Record<TRel, unknown>>> : TZoom extends Record<TRel, infer NestedAPINodeQueryZoom> ? NestedAPINodeQueryZoom : never

Takes the existing zoom query parameter value and excludes all top-level zooms, zooming in on the given relation.

Type Parameters

ZoomOn<TGraph, TQuery, TRel>: TQuery extends With<Query<TGraph>, "zoom"> ? ZoomIn<TQuery["zoom"], TRel> extends Query<Required<TGraph["zooms"]>[TRel]>["zoom"] ? ZoomIn<TQuery["zoom"], TRel> : never : never

Zooms in on the given rel and constructs a type extending APINodeQueryZoom for use in a query.

Type Parameters

  • TGraph extends Core.Graph

  • TQuery extends Query<TGraph> | undefined

  • TRel extends keyof TGraph["zooms"]

ZoomRecord<TGraph>: { readonly [ Key in ZoomString<TGraph>]?: Zoom<Required<TGraph["zooms"]>[Key]> }

Type Parameters

ZoomString<TGraph>: OptionalKeyOf<TGraph["zooms"]>

Type Parameters

Zooms<TGraph, TQuery>: Extract<TGraph extends With<Core.Graph, "zooms"> ? RequiredKeyOf<TGraph["zooms"]> | (TQuery extends Query<TGraph> ? TQuery extends With<Query<TGraph>, "zoom"> ? TQuery["zoom"] extends string ? TQuery["zoom"] : TQuery["zoom"] extends (infer R)[] ? Extract<R, string> | KeyOf<Extract<R, Record<string, unknown>>> : TQuery["zoom"] extends Record<string, unknown> ? keyof TQuery["zoom"] : never : never : never) : never, string>

Creates an intersection of relations included in the top level of the zoom query parameter.

Type Parameters

logType: "silent" | "fatal" | "error" | "warn" | "log" | "info" | "success" | "debug" | "trace" | "verbose" | "ready" | "start"

Variables

AbortSignal: { prototype: AbortSignal }

Type declaration

AbstractRange: { prototype: AbstractRange }

Type declaration

Animation: { prototype: Animation }

Type declaration

AnimationEffect: { prototype: AnimationEffect }

Type declaration

AnimationEvent: { prototype: AnimationEvent }

Type declaration

AnimationPlaybackEvent: { prototype: AnimationPlaybackEvent }

Type declaration

AnimationTimeline: { prototype: AnimationTimeline }

Type declaration

ApplicationCache: { CHECKING: number; DOWNLOADING: number; IDLE: number; OBSOLETE: number; UNCACHED: number; UPDATEREADY: number; prototype: ApplicationCache }

Type declaration

  • Readonly CHECKING: number
  • Readonly DOWNLOADING: number
  • Readonly IDLE: number
  • Readonly OBSOLETE: number
  • Readonly UNCACHED: number
  • Readonly UPDATEREADY: number
  • prototype: ApplicationCache
Attr: { prototype: Attr }

Type declaration

AudioBuffer: { prototype: AudioBuffer }

Type declaration

AudioProcessingEvent: { prototype: AudioProcessingEvent }

Type declaration

BarProp: { prototype: BarProp }

Type declaration

BeforeUnloadEvent: { prototype: BeforeUnloadEvent }

Type declaration

Blob: { prototype: Blob }

Type declaration

CDATASection: { prototype: CDATASection }

Type declaration

CSSRule: { CHARSET_RULE: number; FONT_FACE_RULE: number; IMPORT_RULE: number; KEYFRAMES_RULE: number; KEYFRAME_RULE: number; MEDIA_RULE: number; NAMESPACE_RULE: number; PAGE_RULE: number; STYLE_RULE: number; SUPPORTS_RULE: number; prototype: CSSRule }

Type declaration

  • Readonly CHARSET_RULE: number
  • Readonly FONT_FACE_RULE: number
  • Readonly IMPORT_RULE: number
  • Readonly KEYFRAMES_RULE: number
  • Readonly KEYFRAME_RULE: number
  • Readonly MEDIA_RULE: number
  • Readonly NAMESPACE_RULE: number
  • Readonly PAGE_RULE: number
  • Readonly STYLE_RULE: number
  • Readonly SUPPORTS_RULE: number
  • prototype: CSSRule
CSSStyleSheet: { prototype: CSSStyleSheet }

Type declaration

CacheStorage: { prototype: CacheStorage }

Type declaration

CanvasGradient: { prototype: CanvasGradient }

Type declaration

CanvasPattern: { prototype: CanvasPattern }

Type declaration

CanvasRenderingContext2D: { prototype: CanvasRenderingContext2D }

Type declaration

CaretPosition: { prototype: CaretPosition }

Type declaration

CharacterData: { prototype: CharacterData }

Type declaration

ClipboardEvent: { prototype: ClipboardEvent }

Type declaration

CloseEvent: { prototype: CloseEvent }

Type declaration

Comment: { prototype: Comment }

Type declaration

CompositionEvent: { prototype: CompositionEvent }

Type declaration

Crypto: { prototype: Crypto }

Type declaration

CryptoKey: { prototype: CryptoKey }

Type declaration

CryptoKeyPair: { prototype: CryptoKeyPair }

Type declaration

CustomElementRegistry: { prototype: CustomElementRegistry }

Type declaration

CustomEvent: { prototype: CustomEvent<any> }

Type declaration

DOMException: { ABORT_ERR: number; DATA_CLONE_ERR: number; DOMSTRING_SIZE_ERR: number; HIERARCHY_REQUEST_ERR: number; INDEX_SIZE_ERR: number; INUSE_ATTRIBUTE_ERR: number; INVALID_ACCESS_ERR: number; INVALID_CHARACTER_ERR: number; INVALID_MODIFICATION_ERR: number; INVALID_NODE_TYPE_ERR: number; INVALID_STATE_ERR: number; NAMESPACE_ERR: number; NETWORK_ERR: number; NOT_FOUND_ERR: number; NOT_SUPPORTED_ERR: number; NO_DATA_ALLOWED_ERR: number; NO_MODIFICATION_ALLOWED_ERR: number; QUOTA_EXCEEDED_ERR: number; SECURITY_ERR: number; SYNTAX_ERR: number; TIMEOUT_ERR: number; TYPE_MISMATCH_ERR: number; URL_MISMATCH_ERR: number; VALIDATION_ERR: number; WRONG_DOCUMENT_ERR: number; prototype: DOMException }

Type declaration

  • Readonly ABORT_ERR: number
  • Readonly DATA_CLONE_ERR: number
  • Readonly DOMSTRING_SIZE_ERR: number
  • Readonly HIERARCHY_REQUEST_ERR: number
  • Readonly INDEX_SIZE_ERR: number
  • Readonly INUSE_ATTRIBUTE_ERR: number
  • Readonly INVALID_ACCESS_ERR: number
  • Readonly INVALID_CHARACTER_ERR: number
  • Readonly INVALID_MODIFICATION_ERR: number
  • Readonly INVALID_NODE_TYPE_ERR: number
  • Readonly INVALID_STATE_ERR: number
  • Readonly NAMESPACE_ERR: number
  • Readonly NETWORK_ERR: number
  • Readonly NOT_FOUND_ERR: number
  • Readonly NOT_SUPPORTED_ERR: number
  • Readonly NO_DATA_ALLOWED_ERR: number
  • Readonly NO_MODIFICATION_ALLOWED_ERR: number
  • Readonly QUOTA_EXCEEDED_ERR: number
  • Readonly SECURITY_ERR: number
  • Readonly SYNTAX_ERR: number
  • Readonly TIMEOUT_ERR: number
  • Readonly TYPE_MISMATCH_ERR: number
  • Readonly URL_MISMATCH_ERR: number
  • Readonly VALIDATION_ERR: number
  • Readonly WRONG_DOCUMENT_ERR: number
  • prototype: DOMException
DOMImplementation: { prototype: DOMImplementation }

Type declaration

DOMMatrix: { prototype: DOMMatrix; fromFloat32Array: any; fromFloat64Array: any; fromMatrix: any }

Type declaration

  • prototype: DOMMatrix
  • fromFloat32Array:function
    • fromFloat32Array(array32: Float32Array): DOMMatrix
    • Parameters

      • array32: Float32Array

      Returns DOMMatrix

  • fromFloat64Array:function
    • fromFloat64Array(array64: Float64Array): DOMMatrix
    • Parameters

      • array64: Float64Array

      Returns DOMMatrix

  • fromMatrix:function
    • Parameters

      Returns DOMMatrix

DOMMatrixReadOnly: { prototype: DOMMatrixReadOnly; fromFloat32Array: any; fromFloat64Array: any; fromMatrix: any; toString: any }

Type declaration

DOMPoint: { prototype: DOMPoint; fromPoint: any }

Type declaration

DOMPointReadOnly: { prototype: DOMPointReadOnly; fromPoint: any }

Type declaration

DOMRect: { prototype: DOMRect; fromRect: any }

Type declaration

DOMRectReadOnly: { prototype: DOMRectReadOnly; fromRect: any }

Type declaration

DOMStringMap: { prototype: DOMStringMap }

Type declaration

DataTransfer: { prototype: DataTransfer }

Type declaration

DeferredPermissionRequest: { prototype: DeferredPermissionRequest }

Type declaration

DeviceLightEvent: { prototype: DeviceLightEvent }

Type declaration

DeviceMotionEvent: { prototype: DeviceMotionEvent; requestPermission: any }

Type declaration

DeviceOrientationEvent: { prototype: DeviceOrientationEvent; requestPermission: any }

Type declaration

Document: { prototype: Document }

Type declaration

DocumentFragment: { prototype: DocumentFragment }

Type declaration

DocumentTimeline: { prototype: DocumentTimeline }

Type declaration

DocumentType: { prototype: DocumentType }

Type declaration

DragEvent: { prototype: DragEvent }

Type declaration

Element: { prototype: Element }

Type declaration

Error: ErrorConstructor
ErrorEvent: { prototype: ErrorEvent }

Type declaration

Event: { AT_TARGET: number; BUBBLING_PHASE: number; CAPTURING_PHASE: number; NONE: number; prototype: Event }

Type declaration

  • Readonly AT_TARGET: number
  • Readonly BUBBLING_PHASE: number
  • Readonly CAPTURING_PHASE: number
  • Readonly NONE: number
  • prototype: Event
EventTarget: { prototype: EventTarget }

Type declaration

ExtensionScriptApis: { prototype: ExtensionScriptApis }

Type declaration

External: { prototype: External }

Type declaration

FocusEvent: { prototype: FocusEvent }

Type declaration

FocusNavigationEvent: { prototype: FocusNavigationEvent }

Type declaration

Gamepad: { prototype: Gamepad }

Type declaration

GamepadButton: { prototype: GamepadButton }

Type declaration

GamepadEvent: { prototype: GamepadEvent }

Type declaration

GamepadHapticActuator: { prototype: GamepadHapticActuator }

Type declaration

GamepadPose: { prototype: GamepadPose }

Type declaration

HTMLAnchorElement: { prototype: HTMLAnchorElement }

Type declaration

HTMLAppletElement: { prototype: HTMLAppletElement }

Type declaration

HTMLAreaElement: { prototype: HTMLAreaElement }

Type declaration

HTMLAudioElement: { prototype: HTMLAudioElement }

Type declaration

HTMLBRElement: { prototype: HTMLBRElement }

Type declaration

HTMLBaseElement: { prototype: HTMLBaseElement }

Type declaration

HTMLBaseFontElement: { prototype: HTMLBaseFontElement }

Type declaration

HTMLBodyElement: { prototype: HTMLBodyElement }

Type declaration

HTMLButtonElement: { prototype: HTMLButtonElement }

Type declaration

HTMLCanvasElement: { prototype: HTMLCanvasElement }

Type declaration

HTMLCollection: { prototype: HTMLCollection }

Type declaration

HTMLDListElement: { prototype: HTMLDListElement }

Type declaration

HTMLDataElement: { prototype: HTMLDataElement }

Type declaration

HTMLDataListElement: { prototype: HTMLDataListElement }

Type declaration

HTMLDetailsElement: { prototype: HTMLDetailsElement }

Type declaration

HTMLDialogElement: { prototype: HTMLDialogElement }

Type declaration

HTMLDirectoryElement: { prototype: HTMLDirectoryElement }

Type declaration

HTMLDivElement: { prototype: HTMLDivElement }

Type declaration

HTMLElement: { prototype: HTMLElement }

Type declaration

HTMLEmbedElement: { prototype: HTMLEmbedElement }

Type declaration

HTMLFieldSetElement: { prototype: HTMLFieldSetElement }

Type declaration

HTMLFontElement: { prototype: HTMLFontElement }

Type declaration

HTMLFrameElement: { prototype: HTMLFrameElement }

Type declaration

HTMLFrameSetElement: { prototype: HTMLFrameSetElement }

Type declaration

HTMLHRElement: { prototype: HTMLHRElement }

Type declaration

HTMLHeadElement: { prototype: HTMLHeadElement }

Type declaration

HTMLHeadingElement: { prototype: HTMLHeadingElement }

Type declaration

HTMLHtmlElement: { prototype: HTMLHtmlElement }

Type declaration

HTMLIFrameElement: { prototype: HTMLIFrameElement }

Type declaration

HTMLImageElement: { prototype: HTMLImageElement }

Type declaration

HTMLInputElement: { prototype: HTMLInputElement }

Type declaration

HTMLLIElement: { prototype: HTMLLIElement }

Type declaration

HTMLLabelElement: { prototype: HTMLLabelElement }

Type declaration

HTMLLegendElement: { prototype: HTMLLegendElement }

Type declaration

HTMLLinkElement: { prototype: HTMLLinkElement }

Type declaration

HTMLMapElement: { prototype: HTMLMapElement }

Type declaration

HTMLMarqueeElement: { prototype: HTMLMarqueeElement }

Type declaration

HTMLMediaElement: { HAVE_CURRENT_DATA: number; HAVE_ENOUGH_DATA: number; HAVE_FUTURE_DATA: number; HAVE_METADATA: number; HAVE_NOTHING: number; NETWORK_EMPTY: number; NETWORK_IDLE: number; NETWORK_LOADING: number; NETWORK_NO_SOURCE: number; prototype: HTMLMediaElement }

Type declaration

  • Readonly HAVE_CURRENT_DATA: number
  • Readonly HAVE_ENOUGH_DATA: number
  • Readonly HAVE_FUTURE_DATA: number
  • Readonly HAVE_METADATA: number
  • Readonly HAVE_NOTHING: number
  • Readonly NETWORK_EMPTY: number
  • Readonly NETWORK_IDLE: number
  • Readonly NETWORK_LOADING: number
  • Readonly NETWORK_NO_SOURCE: number
  • prototype: HTMLMediaElement
HTMLMenuElement: { prototype: HTMLMenuElement }

Type declaration

HTMLMetaElement: { prototype: HTMLMetaElement }

Type declaration

HTMLMeterElement: { prototype: HTMLMeterElement }

Type declaration

HTMLModElement: { prototype: HTMLModElement }

Type declaration

HTMLOListElement: { prototype: HTMLOListElement }

Type declaration

HTMLObjectElement: { prototype: HTMLObjectElement }

Type declaration

HTMLOptGroupElement: { prototype: HTMLOptGroupElement }

Type declaration

HTMLOptionElement: { prototype: HTMLOptionElement }

Type declaration

HTMLOutputElement: { prototype: HTMLOutputElement }

Type declaration

HTMLParagraphElement: { prototype: HTMLParagraphElement }

Type declaration

HTMLParamElement: { prototype: HTMLParamElement }

Type declaration

HTMLPictureElement: { prototype: HTMLPictureElement }

Type declaration

HTMLPreElement: { prototype: HTMLPreElement }

Type declaration

HTMLProgressElement: { prototype: HTMLProgressElement }

Type declaration

HTMLQuoteElement: { prototype: HTMLQuoteElement }

Type declaration

HTMLScriptElement: { prototype: HTMLScriptElement }

Type declaration

HTMLSlotElement: { prototype: HTMLSlotElement }

Type declaration

HTMLSourceElement: { prototype: HTMLSourceElement }

Type declaration

HTMLSpanElement: { prototype: HTMLSpanElement }

Type declaration

HTMLStyleElement: { prototype: HTMLStyleElement }

Type declaration

HTMLTableCaptionElement: { prototype: HTMLTableCaptionElement }

Type declaration

HTMLTableCellElement: { prototype: HTMLTableCellElement }

Type declaration

HTMLTableColElement: { prototype: HTMLTableColElement }

Type declaration

HTMLTableDataCellElement: { prototype: HTMLTableDataCellElement }

Type declaration

HTMLTableElement: { prototype: HTMLTableElement }

Type declaration

HTMLTableHeaderCellElement: { prototype: HTMLTableHeaderCellElement }

Type declaration

HTMLTableRowElement: { prototype: HTMLTableRowElement }

Type declaration

HTMLTableSectionElement: { prototype: HTMLTableSectionElement }

Type declaration

HTMLTemplateElement: { prototype: HTMLTemplateElement }

Type declaration

HTMLTextAreaElement: { prototype: HTMLTextAreaElement }

Type declaration

HTMLTimeElement: { prototype: HTMLTimeElement }

Type declaration

HTMLTitleElement: { prototype: HTMLTitleElement }

Type declaration

HTMLTrackElement: { ERROR: number; LOADED: number; LOADING: number; NONE: number; prototype: HTMLTrackElement }

Type declaration

  • Readonly ERROR: number
  • Readonly LOADED: number
  • Readonly LOADING: number
  • Readonly NONE: number
  • prototype: HTMLTrackElement
HTMLUListElement: { prototype: HTMLUListElement }

Type declaration

HTMLVideoElement: { prototype: HTMLVideoElement }

Type declaration

HashChangeEvent: { prototype: HashChangeEvent }

Type declaration

History: { prototype: History }

Type declaration

IDBCursor: { prototype: IDBCursor }

Type declaration

IDBCursorWithValue: { prototype: IDBCursorWithValue }

Type declaration

IDBDatabase: { prototype: IDBDatabase }

Type declaration

IDBFactory: { prototype: IDBFactory }

Type declaration

IDBIndex: { prototype: IDBIndex }

Type declaration

IDBKeyRange: { prototype: IDBKeyRange; bound: any; lowerBound: any; only: any; upperBound: any }

Type declaration

  • prototype: IDBKeyRange
  • bound:function
    • bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange
    • Returns a new IDBKeyRange spanning from lower to upper. If lowerOpen is true, lower is not included in the range. If upperOpen is true, upper is not included in the range.

      Parameters

      • lower: any
      • upper: any
      • Optional lowerOpen: boolean
      • Optional upperOpen: boolean

      Returns IDBKeyRange

  • lowerBound:function
    • Returns a new IDBKeyRange starting at key with no upper bound. If open is true, key is not included in the range.

      Parameters

      • lower: any
      • Optional open: boolean

      Returns IDBKeyRange

  • only:function
    • Returns a new IDBKeyRange spanning only key.

      Parameters

      • value: any

      Returns IDBKeyRange

  • upperBound:function
    • Returns a new IDBKeyRange with no lower bound and ending at key. If open is true, key is not included in the range.

      Parameters

      • upper: any
      • Optional open: boolean

      Returns IDBKeyRange

IDBOpenDBRequest: { prototype: IDBOpenDBRequest }

Type declaration

IDBRequest: { prototype: IDBRequest<any> }

Type declaration

IDBTransaction: { prototype: IDBTransaction }

Type declaration

IDBVersionChangeEvent: { prototype: IDBVersionChangeEvent }

Type declaration

ImageBitmap: { prototype: ImageBitmap }

Type declaration

ImageBitmapRenderingContext: { prototype: ImageBitmapRenderingContext }

Type declaration

ImageData: { prototype: ImageData }

Type declaration

InputEvent: { prototype: InputEvent }

Type declaration

KeyboardEvent: { DOM_KEY_LOCATION_LEFT: number; DOM_KEY_LOCATION_NUMPAD: number; DOM_KEY_LOCATION_RIGHT: number; DOM_KEY_LOCATION_STANDARD: number; prototype: KeyboardEvent }

Type declaration

  • Readonly DOM_KEY_LOCATION_LEFT: number
  • Readonly DOM_KEY_LOCATION_NUMPAD: number
  • Readonly DOM_KEY_LOCATION_RIGHT: number
  • Readonly DOM_KEY_LOCATION_STANDARD: number
  • prototype: KeyboardEvent
ListeningStateChangedEvent: { prototype: ListeningStateChangedEvent }

Type declaration

Location: { prototype: Location }

Type declaration

MSGestureEvent: { MSGESTURE_FLAG_BEGIN: number; MSGESTURE_FLAG_CANCEL: number; MSGESTURE_FLAG_END: number; MSGESTURE_FLAG_INERTIA: number; MSGESTURE_FLAG_NONE: number; prototype: MSGestureEvent }

Type declaration

  • Readonly MSGESTURE_FLAG_BEGIN: number
  • Readonly MSGESTURE_FLAG_CANCEL: number
  • Readonly MSGESTURE_FLAG_END: number
  • Readonly MSGESTURE_FLAG_INERTIA: number
  • Readonly MSGESTURE_FLAG_NONE: number
  • prototype: MSGestureEvent
MSMediaKeyMessageEvent: { prototype: MSMediaKeyMessageEvent }

Type declaration

MSMediaKeyNeededEvent: { prototype: MSMediaKeyNeededEvent }

Type declaration

MSPointerEvent: { prototype: MSPointerEvent }

Type declaration

MediaEncryptedEvent: { prototype: MediaEncryptedEvent }

Type declaration

MediaError: { MEDIA_ERR_ABORTED: number; MEDIA_ERR_DECODE: number; MEDIA_ERR_NETWORK: number; MEDIA_ERR_SRC_NOT_SUPPORTED: number; prototype: MediaError }

Type declaration

  • Readonly MEDIA_ERR_ABORTED: number
  • Readonly MEDIA_ERR_DECODE: number
  • Readonly MEDIA_ERR_NETWORK: number
  • Readonly MEDIA_ERR_SRC_NOT_SUPPORTED: number
  • prototype: MediaError
MediaKeyMessageEvent: { prototype: MediaKeyMessageEvent }

Type declaration

MediaKeySession: { prototype: MediaKeySession }

Type declaration

MediaKeys: { prototype: MediaKeys }

Type declaration

MediaQueryList: { prototype: MediaQueryList }

Type declaration

MediaQueryListEvent: { prototype: MediaQueryListEvent }

Type declaration

MediaSource: { prototype: MediaSource; isTypeSupported: any }

Type declaration

  • prototype: MediaSource
  • isTypeSupported:function
    • isTypeSupported(type: string): boolean
    • Parameters

      • type: string

      Returns boolean

MediaStream: { prototype: MediaStream }

Type declaration

MediaStreamError: { prototype: MediaStreamError }

Type declaration

MediaStreamErrorEvent: { prototype: MediaStreamErrorEvent }

Type declaration

MediaStreamEvent: { prototype: MediaStreamEvent }

Type declaration

MediaStreamTrack: { prototype: MediaStreamTrack }

Type declaration

MediaStreamTrackEvent: { prototype: MediaStreamTrackEvent }

Type declaration

MessageChannel: { prototype: MessageChannel }

Type declaration

MessageEvent: { prototype: MessageEvent<any> }

Type declaration

MessagePort: { prototype: MessagePort }

Type declaration

MouseEvent: { prototype: MouseEvent }

Type declaration

MutationEvent: { ADDITION: number; MODIFICATION: number; REMOVAL: number; prototype: MutationEvent }

Type declaration

  • Readonly ADDITION: number
  • Readonly MODIFICATION: number
  • Readonly REMOVAL: number
  • prototype: MutationEvent
Node: { ATTRIBUTE_NODE: number; CDATA_SECTION_NODE: number; COMMENT_NODE: number; DOCUMENT_FRAGMENT_NODE: number; DOCUMENT_NODE: number; DOCUMENT_POSITION_CONTAINED_BY: number; DOCUMENT_POSITION_CONTAINS: number; DOCUMENT_POSITION_DISCONNECTED: number; DOCUMENT_POSITION_FOLLOWING: number; DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number; DOCUMENT_POSITION_PRECEDING: number; DOCUMENT_TYPE_NODE: number; ELEMENT_NODE: number; ENTITY_NODE: number; ENTITY_REFERENCE_NODE: number; NOTATION_NODE: number; PROCESSING_INSTRUCTION_NODE: number; TEXT_NODE: number; prototype: Node }

Type declaration

  • Readonly ATTRIBUTE_NODE: number
  • Readonly CDATA_SECTION_NODE: number

    node is a CDATASection node.

  • Readonly COMMENT_NODE: number

    node is a Comment node.

  • Readonly DOCUMENT_FRAGMENT_NODE: number

    node is a DocumentFragment node.

  • Readonly DOCUMENT_NODE: number

    node is a document.

  • Readonly DOCUMENT_POSITION_CONTAINED_BY: number

    Set when other is a descendant of node.

  • Readonly DOCUMENT_POSITION_CONTAINS: number

    Set when other is an ancestor of node.

  • Readonly DOCUMENT_POSITION_DISCONNECTED: number

    Set when node and other are not in the same tree.

  • Readonly DOCUMENT_POSITION_FOLLOWING: number

    Set when other is following node.

  • Readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number
  • Readonly DOCUMENT_POSITION_PRECEDING: number

    Set when other is preceding node.

  • Readonly DOCUMENT_TYPE_NODE: number

    node is a doctype.

  • Readonly ELEMENT_NODE: number

    node is an element.

  • Readonly ENTITY_NODE: number
  • Readonly ENTITY_REFERENCE_NODE: number
  • Readonly NOTATION_NODE: number
  • Readonly PROCESSING_INSTRUCTION_NODE: number

    node is a ProcessingInstruction node.

  • Readonly TEXT_NODE: number

    node is a Text node.

  • prototype: Node
NodeFilter: { FILTER_ACCEPT: number; FILTER_REJECT: number; FILTER_SKIP: number; SHOW_ALL: number; SHOW_ATTRIBUTE: number; SHOW_CDATA_SECTION: number; SHOW_COMMENT: number; SHOW_DOCUMENT: number; SHOW_DOCUMENT_FRAGMENT: number; SHOW_DOCUMENT_TYPE: number; SHOW_ELEMENT: number; SHOW_ENTITY: number; SHOW_ENTITY_REFERENCE: number; SHOW_NOTATION: number; SHOW_PROCESSING_INSTRUCTION: number; SHOW_TEXT: number }

Type declaration

  • Readonly FILTER_ACCEPT: number
  • Readonly FILTER_REJECT: number
  • Readonly FILTER_SKIP: number
  • Readonly SHOW_ALL: number
  • Readonly SHOW_ATTRIBUTE: number
  • Readonly SHOW_CDATA_SECTION: number
  • Readonly SHOW_COMMENT: number
  • Readonly SHOW_DOCUMENT: number
  • Readonly SHOW_DOCUMENT_FRAGMENT: number
  • Readonly SHOW_DOCUMENT_TYPE: number
  • Readonly SHOW_ELEMENT: number
  • Readonly SHOW_ENTITY: number
  • Readonly SHOW_ENTITY_REFERENCE: number
  • Readonly SHOW_NOTATION: number
  • Readonly SHOW_PROCESSING_INSTRUCTION: number
  • Readonly SHOW_TEXT: number
NodeIterator: { prototype: NodeIterator }

Type declaration

OfflineAudioCompletionEvent: { prototype: OfflineAudioCompletionEvent }

Type declaration

OffscreenCanvas: { prototype: OffscreenCanvas }

Type declaration

OffscreenCanvasRenderingContext2D: { prototype: OffscreenCanvasRenderingContext2D }

Type declaration

OverflowEvent: { BOTH: number; HORIZONTAL: number; VERTICAL: number; prototype: OverflowEvent }

Type declaration

  • Readonly BOTH: number
  • Readonly HORIZONTAL: number
  • Readonly VERTICAL: number
  • prototype: OverflowEvent
PageTransitionEvent: { prototype: PageTransitionEvent }

Type declaration

Path2D: { prototype: Path2D }

Type declaration

PaymentRequestUpdateEvent: { prototype: PaymentRequestUpdateEvent }

Type declaration

Performance: { prototype: Performance }

Type declaration

PerformanceEntry: { prototype: PerformanceEntry }

Type declaration

PerformanceNavigation: { TYPE_BACK_FORWARD: number; TYPE_NAVIGATE: number; TYPE_RELOAD: number; TYPE_RESERVED: number; prototype: PerformanceNavigation }

Type declaration

  • Readonly TYPE_BACK_FORWARD: number
  • Readonly TYPE_NAVIGATE: number
  • Readonly TYPE_RELOAD: number
  • Readonly TYPE_RESERVED: number
  • prototype: PerformanceNavigation
PerformanceTiming: { prototype: PerformanceTiming }

Type declaration

PermissionRequest: { prototype: PermissionRequest }

Type declaration

PermissionRequestedEvent: { prototype: PermissionRequestedEvent }

Type declaration

PointerEvent: { prototype: PointerEvent }

Type declaration

PopStateEvent: { prototype: PopStateEvent }

Type declaration

ProcessingInstruction: { prototype: ProcessingInstruction }

Type declaration

ProgressEvent: { prototype: ProgressEvent<EventTarget> }

Type declaration

PromiseRejectionEvent: { prototype: PromiseRejectionEvent }

Type declaration

RTCDTMFToneChangeEvent: { prototype: RTCDTMFToneChangeEvent }

Type declaration