diff --git a/externs/es6.js b/externs/es6.js
index 364b60e2655..d5db9cecdde 100644
--- a/externs/es6.js
+++ b/externs/es6.js
@@ -406,8 +406,9 @@ ArrayBuffer.isView = function(arg) {};
 
 
 /**
- * @constructor
+ * @interface
  * @template TArrayBuffer (unused)
+ * @see https://webidl.spec.whatwg.org/#ArrayBufferView
  */
 function ArrayBufferView() {}
 
@@ -453,13 +454,15 @@ var AllowSharedBufferSource;
 
 
 /**
- * @constructor
- * @implements {IArrayLike<number>}
- * @implements {Iterable<number>}
+ * @interface
+ * @extends {IArrayLike<number>}
+ * @extends {Iterable<number>}
  * @extends {ArrayBufferView}
  * @template TArrayBuffer (unused)
+ * @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-typedarray-objects
+ * @see https://tc39.es/ecma262/multipage/ordinary-and-exotic-objects-behaviours.html#typedarray
  */
-function TypedArray() {};
+function TypedArray() {}
 
 /** @const {number} */
 TypedArray.prototype.BYTES_PER_ELEMENT;
@@ -771,7 +774,7 @@ TypedArray.prototype[Symbol.iterator] = function() {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments} If the user passes a backing array, then indexed
  *     accesses will modify the backing array. JSCompiler does not model
@@ -807,338 +810,412 @@ Int8Array.from = function(source, mapFn, thisArg) {};
  */
 Int8Array.of = function(var_args) {};
 
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+Int8Array.prototype.at = function(index) {};
 
 /**
- * Options to use when decoding base64 into a Uint8Array.
- * @record
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64#options
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
  */
-function Uint8ArrayBase64Options() {}
+Int8Array.prototype.copyWithin = function(target, start, opt_end) {};
 
 /**
- * Specifies the base64 alphabet to use. This can either be "base64", which will include the special characters `+`
- * and `/`, or "base64url", which will include the special characters `-` and `_`. If not specified, it defaults to
- * "base64".
- * @type {(undefined|string)}
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
  */
-Uint8ArrayBase64Options.prototype.alphabet;
+Int8Array.prototype.entries = function() {};
 
 /**
- * Specifies how to handle the last chunk of the base64 string if it is an incomplete chunk. The value "strict" requires
- * that any incomplete chunk be padded with `=` characters and any trailing bits must be zero. The value
- * "stop-before-partial" indicates that decoding should only handle complete chunks and ignore partial chunks, allowing
- * them to be handled separately if desired (such as in future calls). The default value is "loose", which will decode
- * an incomplete chunk even if not padded by `=`.
- * @type {(undefined|string)}
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
  */
-Uint8ArrayBase64Options.prototype.lastChunkHandling;
+Int8Array.prototype.every = function(callback, opt_thisArg) {};
 
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+Int8Array.prototype.fill = function(value, opt_begin, opt_end) {};
 
 /**
- * Results from Uint8Array.prototype.setFromBase64.
- * @record
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
  */
-function Uint8ArraySetFromBase64Results() {}
+Int8Array.prototype.filter = function(callback, opt_thisArg) {};
 
 /**
- * The number of characters read from the base64 string. If the entire string's contents fit into the Uint8Array,
- * this will be equal to string.length. Otherwise, this will be equal to the number of 4-character chunks that
- * fit into the array.
- * @type {number}
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
  */
-Uint8ArraySetFromBase64Results.prototype.read;
+Int8Array.prototype.find = function(callback, opt_thisArg) {};
 
 /**
- * The number of bytes written into the Uint8Array.
- * @type {number}
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
  */
-Uint8ArraySetFromBase64Results.prototype.written;
+Int8Array.prototype.findIndex = function(callback, opt_thisArg) {};
 
 /**
- * Options to use when invoking Uint8Array.prototype.toBase64.
- * @record
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64#options
+ * @param {function(this:S, number, number, !Int8Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
  */
-function Uint8ArrayToBase64Options() {}
+Int8Array.prototype.findLast = function(callback, opt_thisArg) {};
 
 /**
- * Specifies the base64 alphabet to use. This can either be "base64", which will include the special characters `+`
- * and `/`, or "base64url", which will include the special characters `-` and `_`. If not specified, it defaults to
- * "base64".
- * @type {(undefined|string)}
+ * @param {function(this:S, number, number, !Int8Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
  */
-Uint8ArrayToBase64Options.prototype.alphabet;
+Int8Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
 
 /**
- * If true, the output base64 string will omit any `=` padding characters at the end. Defaults to false.
- * @type {(undefined|boolean)}
+ * @param {function(this:S, number, number, !Int8Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
  */
-Uint8ArrayToBase64Options.prototype.omitPadding;
+Int8Array.prototype.forEach = function(callback, opt_thisArg) {};
 
 /**
- * Results from Uint8Array.prototype.setFromHex.
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/setFromHex#return_value
- * @interface
- * @struct
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
  */
-function Uint8ArraySetFromHexResults() {}
+Int8Array.prototype.includes = function(searchElement, opt_fromIndex) {};
 
 /**
- * The number of hex characters read from the input string. If the decoded data fits into the
- * array, it is the length of the input string; otherwise, it is the number of complete hex
- * characters that fit into the array.
- * @type {number}
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
  */
-Uint8ArraySetFromHexResults.prototype.read;
+Int8Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
 
 /**
- * The number of bytes written into the Uint8Array. Will never be greater than this Uint8Array's
- * length.
- * @type {number}
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
  */
-Uint8ArraySetFromHexResults.prototype.written;
+Int8Array.prototype.join = function(opt_separator) {};
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length or array or buffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} opt_byteOffset
- * @param {number=} opt_length
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
  */
-function Uint8Array(length, opt_byteOffset, opt_length) {}
+Int8Array.prototype.keys = function() {};
 
-/** @const {number} */
-Uint8Array.BYTES_PER_ELEMENT;
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+Int8Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
- * @template S
- * @return {!Uint8Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * @param {function(this:S, number, number, !Int8Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
  */
-Uint8Array.from = function(source, mapFn, thisArg) {};
+Int8Array.prototype.map = function(callback, opt_thisArg) {};
 
 /**
- * @param {...number} var_args
- * @return {!Uint8Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @param {function((number|INIT|RET), number, number, !Int8Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
  */
-Uint8Array.of = function(var_args) {};
+Int8Array.prototype.reduce = function(callback, opt_initialValue) {};
 
 /**
- * Creates a new Uint8Array from a base64 encoded string.
- * @param {string} string a base64 string encoded array
- * @param {?Uint8ArrayBase64Options=} options an object specifying how to read the base64 string
- * @return {!Uint8Array} a newly created array with the specified bytes
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64
+ * @param {function((number|INIT|RET), number, number, !Int8Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
  */
-Uint8Array.fromBase64 = function(string, options) {};
+Int8Array.prototype.reduceRight = function(callback, opt_initialValue) {};
 
 /**
- * Creates a new Uint8Array from a case-insensitive hex string with even length.
- * @param {string} string a hex string encoded array of bytes
- * @return {!Uint8Array} a newly created array with the specified bytes
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromHex
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
  */
-Uint8Array.fromHex = function(string) {};
+Int8Array.prototype.reverse = function() {};
 
 /**
- * Sets the contents of the Uint8Array from a base64 encoded string.
- * @param {string} string a base64 string encoded array to write into this array
- * @param {?Uint8ArrayBase64Options=} options an object specifying how to read the base64 string
- * @return {!Uint8ArraySetFromBase64Results} results about the operation
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/setFromBase64
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
  */
-Uint8Array.prototype.setFromBase64 = function(string, options) {};
+Int8Array.prototype.set = function(array, opt_offset) {};
 
 /**
- * Sets the contents of the Uint8Array from a hex encoded even length string. The string may
- * contain uppercase or lowercase hex characters.
- * @param {string} string a hex string of even length
- * @return {!Uint8ArraySetFromHexResults} results containing read and written stats
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
  */
-Uint8Array.prototype.setFromHex = function(string) {};
+Int8Array.prototype.slice = function(opt_begin, opt_end) {};
 
 /**
- * Encodes the contents of the Uint8Array into a base64 string.
- * @param {?Uint8ArrayToBase64Options=} options an object specifying how to encode the base64 string
- * @return {string} a base64 encoded string representing the contents of this array
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
  */
-Uint8Array.prototype.toBase64 = function(options) {};
+Int8Array.prototype.some = function(callback, opt_thisArg) {};
 
 /**
- * Encodes the contents of the Uint8Array into a hex string.
- * @return {string} a hex encoded string representing the contents of this array
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex
+ * @param {(function(number, number) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ * @override
  */
-Uint8Array.prototype.toHex = function() {};
+Int8Array.prototype.sort = function(opt_compareFunction) {};
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length or array or buffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} opt_byteOffset
- * @param {number=} opt_length
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
  */
-function Uint8ClampedArray(length, opt_byteOffset, opt_length) {}
-
-/** @const {number} */
-Uint8ClampedArray.BYTES_PER_ELEMENT;
+Int8Array.prototype.subarray = function(begin, opt_end) {};
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
- * @template S
- * @return {!Uint8ClampedArray}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
  */
-Uint8ClampedArray.from = function(source, mapFn, thisArg) {};
+Int8Array.prototype.values = function() {};
 
 /**
- * @param {...number} var_args
- * @return {!Uint8ClampedArray}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @return {THIS}y
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
  */
-Uint8ClampedArray.of = function(var_args) {};
+Int8Array.prototype.toReversed = function() {};
 
+/**
+ * @param {function(number, number): number=} compareFn
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ * @override
+ */
+Int8Array.prototype.toSorted = function(compareFn) {};
 
 /**
- * @typedef {Uint8ClampedArray}
- * @deprecated CanvasPixelArray has been replaced by Uint8ClampedArray
- *     in the latest spec.
- * @see http://www.w3.org/TR/2dcontext/#imagedata
+ * @param {number} index
+ * @param {number} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ * @override
  */
-var CanvasPixelArray;
+Int8Array.prototype.with = function(index, value) {};
 
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+Int8Array.prototype.toLocaleString = function() {};
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length or array or buffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} opt_byteOffset
- * @param {number=} opt_length
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
  */
-function Int16Array(length, opt_byteOffset, opt_length) {}
+Int8Array.prototype.toString = function() {};
+
+/** @override */
+Int8Array.prototype[Symbol.iterator] = function() {};
 
-/** @const {number} */
-Int16Array.BYTES_PER_ELEMENT;
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
- * @template S
- * @return {!Int16Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * Options to use when decoding base64 into a Uint8Array.
+ * @record
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64#options
  */
-Int16Array.from = function(source, mapFn, thisArg) {};
+function Uint8ArrayBase64Options() {}
 
 /**
- * @param {...number} var_args
- * @return {!Int16Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * Specifies the base64 alphabet to use. This can either be "base64", which will include the special characters `+`
+ * and `/`, or "base64url", which will include the special characters `-` and `_`. If not specified, it defaults to
+ * "base64".
+ * @type {(undefined|string)}
  */
-Int16Array.of = function(var_args) {};
-
+Uint8ArrayBase64Options.prototype.alphabet;
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length or array or buffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} opt_byteOffset
- * @param {number=} opt_length
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * Specifies how to handle the last chunk of the base64 string if it is an incomplete chunk. The value "strict" requires
+ * that any incomplete chunk be padded with `=` characters and any trailing bits must be zero. The value
+ * "stop-before-partial" indicates that decoding should only handle complete chunks and ignore partial chunks, allowing
+ * them to be handled separately if desired (such as in future calls). The default value is "loose", which will decode
+ * an incomplete chunk even if not padded by `=`.
+ * @type {(undefined|string)}
  */
-function Uint16Array(length, opt_byteOffset, opt_length) {}
+Uint8ArrayBase64Options.prototype.lastChunkHandling;
 
-/** @const {number} */
-Uint16Array.BYTES_PER_ELEMENT;
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
- * @template S
- * @return {!Uint16Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * Results from Uint8Array.prototype.setFromBase64.
+ * @record
  */
-Uint16Array.from = function(source, mapFn, thisArg) {};
+function Uint8ArraySetFromBase64Results() {}
 
 /**
- * @param {...number} var_args
- * @return {!Uint16Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * The number of characters read from the base64 string. If the entire string's contents fit into the Uint8Array,
+ * this will be equal to string.length. Otherwise, this will be equal to the number of 4-character chunks that
+ * fit into the array.
+ * @type {number}
  */
-Uint16Array.of = function(var_args) {};
+Uint8ArraySetFromBase64Results.prototype.read;
 
+/**
+ * The number of bytes written into the Uint8Array.
+ * @type {number}
+ */
+Uint8ArraySetFromBase64Results.prototype.written;
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length or array or buffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} opt_byteOffset
- * @param {number=} opt_length
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * Options to use when invoking Uint8Array.prototype.toBase64.
+ * @record
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64#options
  */
-function Int32Array(length, opt_byteOffset, opt_length) {}
+function Uint8ArrayToBase64Options() {}
 
-/** @const {number} */
-Int32Array.BYTES_PER_ELEMENT;
+/**
+ * Specifies the base64 alphabet to use. This can either be "base64", which will include the special characters `+`
+ * and `/`, or "base64url", which will include the special characters `-` and `_`. If not specified, it defaults to
+ * "base64".
+ * @type {(undefined|string)}
+ */
+Uint8ArrayToBase64Options.prototype.alphabet;
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
- * @template S
- * @return {!Int32Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * If true, the output base64 string will omit any `=` padding characters at the end. Defaults to false.
+ * @type {(undefined|boolean)}
  */
-Int32Array.from = function(source, mapFn, thisArg) {};
+Uint8ArrayToBase64Options.prototype.omitPadding;
 
 /**
- * @param {...number} var_args
- * @return {!Int32Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * Results from Uint8Array.prototype.setFromHex.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/setFromHex#return_value
+ * @interface
+ * @struct
  */
-Int32Array.of = function(var_args) {};
+function Uint8ArraySetFromHexResults() {}
+
+/**
+ * The number of hex characters read from the input string. If the decoded data fits into the
+ * array, it is the length of the input string; otherwise, it is the number of complete hex
+ * characters that fit into the array.
+ * @type {number}
+ */
+Uint8ArraySetFromHexResults.prototype.read;
 
+/**
+ * The number of bytes written into the Uint8Array. Will never be greater than this Uint8Array's
+ * length.
+ * @type {number}
+ */
+Uint8ArraySetFromHexResults.prototype.written;
 
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
@@ -1150,245 +1227,3226 @@ Int32Array.of = function(var_args) {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
-function Uint32Array(length, opt_byteOffset, opt_length) {}
+function Uint8Array(length, opt_byteOffset, opt_length) {}
 
 /** @const {number} */
-Uint32Array.BYTES_PER_ELEMENT;
+Uint8Array.BYTES_PER_ELEMENT;
 
 /**
  * @param {string|!IArrayLike<number>|!Iterable<number>} source
  * @param {function(this:S, ?, number): number=} mapFn
  * @param {S=} thisArg
  * @template S
- * @return {!Uint32Array}
+ * @return {!Uint8Array}
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
  */
-Uint32Array.from = function(source, mapFn, thisArg) {};
+Uint8Array.from = function(source, mapFn, thisArg) {};
 
 /**
  * @param {...number} var_args
- * @return {!Uint32Array}
+ * @return {!Uint8Array}
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
  */
-Uint32Array.of = function(var_args) {};
-
+Uint8Array.of = function(var_args) {};
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length
- * @param {number=} opt_byteOffset
- * @param {number=} opt_length
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float16Array
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
  */
-function Float16Array(length, opt_byteOffset, opt_length) {}
+Uint8Array.prototype.at = function(index) {};
 
-/** @const {number} */
-Float16Array.BYTES_PER_ELEMENT;
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+Uint8Array.prototype.copyWithin = function(target, start, opt_end) {};
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+Uint8Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+Uint8Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+Uint8Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+Uint8Array.prototype.filter = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
+ */
+Uint8Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
+ */
+Uint8Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
+ */
+Uint8Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
+ */
+Uint8Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
+ */
+Uint8Array.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
+ */
+Uint8Array.prototype.includes = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
+ */
+Uint8Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+Uint8Array.prototype.join = function(opt_separator) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
+ */
+Uint8Array.prototype.keys = function() {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+Uint8Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
+ */
+Uint8Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Uint8Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
+ */
+Uint8Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Uint8Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
+ */
+Uint8Array.prototype.reduceRight = function(callback, opt_initialValue) {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
+ */
+Uint8Array.prototype.reverse = function() {};
+
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+Uint8Array.prototype.set = function(array, opt_offset) {};
+
+/**
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
+ */
+Uint8Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
+ */
+Uint8Array.prototype.some = function(callback, opt_thisArg) {};
+
+/**
+ * @param {(function(number, number) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ * @override
+ */
+Uint8Array.prototype.sort = function(opt_compareFunction) {};
+
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+Uint8Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+Uint8Array.prototype.values = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+Uint8Array.prototype.toReversed = function() {};
+
+/**
+ * @param {function(number, number): number=} compareFn
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ * @override
+ */
+Uint8Array.prototype.toSorted = function(compareFn) {};
+
+/**
+ * @param {number} index
+ * @param {number} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ * @override
+ */
+Uint8Array.prototype.with = function(index, value) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+Uint8Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+Uint8Array.prototype.toString = function() {};
+
+/** @override */
+Uint8Array.prototype[Symbol.iterator] = function() {};
+
+/**
+ * Creates a new Uint8Array from a base64 encoded string.
+ * @param {string} string a base64 string encoded array
+ * @param {?Uint8ArrayBase64Options=} options an object specifying how to read the base64 string
+ * @return {!Uint8Array} a newly created array with the specified bytes
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromBase64
+ */
+Uint8Array.fromBase64 = function(string, options) {};
+
+/**
+ * Creates a new Uint8Array from a case-insensitive hex string with even length.
+ * @param {string} string a hex string encoded array of bytes
+ * @return {!Uint8Array} a newly created array with the specified bytes
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/fromHex
+ */
+Uint8Array.fromHex = function(string) {};
+
+/**
+ * Sets the contents of the Uint8Array from a base64 encoded string.
+ * @param {string} string a base64 string encoded array to write into this array
+ * @param {?Uint8ArrayBase64Options=} options an object specifying how to read the base64 string
+ * @return {!Uint8ArraySetFromBase64Results} results about the operation
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/setFromBase64
+ */
+Uint8Array.prototype.setFromBase64 = function(string, options) {};
+
+/**
+ * Sets the contents of the Uint8Array from a hex encoded even length string. The string may
+ * contain uppercase or lowercase hex characters.
+ * @param {string} string a hex string of even length
+ * @return {!Uint8ArraySetFromHexResults} results containing read and written stats
+ */
+Uint8Array.prototype.setFromHex = function(string) {};
+
+/**
+ * Encodes the contents of the Uint8Array into a base64 string.
+ * @param {?Uint8ArrayToBase64Options=} options an object specifying how to encode the base64 string
+ * @return {string} a base64 encoded string representing the contents of this array
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64
+ */
+Uint8Array.prototype.toBase64 = function(options) {};
+
+/**
+ * Encodes the contents of the Uint8Array into a hex string.
+ * @return {string} a hex encoded string representing the contents of this array
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex
+ */
+Uint8Array.prototype.toHex = function() {};
+
+/**
+ * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
+ *     length or array or buffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} opt_byteOffset
+ * @param {number=} opt_length
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function Uint8ClampedArray(length, opt_byteOffset, opt_length) {}
+
+/** @const {number} */
+Uint8ClampedArray.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<number>|!Iterable<number>} source
+ * @param {function(this:S, ?, number): number=} mapFn
+ * @param {S=} thisArg
+ * @template S
+ * @return {!Uint8ClampedArray}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+Uint8ClampedArray.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...number} var_args
+ * @return {!Uint8ClampedArray}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+Uint8ClampedArray.of = function(var_args) {};
+
+/** @override */
+Uint8ClampedArray.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @typedef {Uint8ClampedArray}
+ * @deprecated CanvasPixelArray has been replaced by Uint8ClampedArray
+ *     in the latest spec.
+ * @see http://www.w3.org/TR/2dcontext/#imagedata
+ */
+var CanvasPixelArray;
+
+
+/**
+ * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
+ *     length or array or buffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} opt_byteOffset
+ * @param {number=} opt_length
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function Int16Array(length, opt_byteOffset, opt_length) {}
+
+/** @const {number} */
+Int16Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<number>|!Iterable<number>} source
+ * @param {function(this:S, ?, number): number=} mapFn
+ * @param {S=} thisArg
+ * @template S
+ * @return {!Int16Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+Int16Array.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...number} var_args
+ * @return {!Int16Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+Int16Array.of = function(var_args) {};
+
+
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+Int8Array.prototype.at = function(index) {};
+
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+Int8Array.prototype.copyWithin = function(target, start, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+Int8Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+Int8Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+Int8Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+Int8Array.prototype.filter = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
+ */
+Int8Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
+ */
+Int8Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
+ */
+Int8Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
+ */
+Int8Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
+ */
+Int8Array.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
+ */
+Int8Array.prototype.includes = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
+ */
+Int8Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+Int8Array.prototype.join = function(opt_separator) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
+ */
+Int8Array.prototype.keys = function() {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+Int8Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
+ */
+Int8Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Int8Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
+ */
+Int8Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Int8Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
+ */
+Int8Array.prototype.reduceRight = function(callback, opt_initialValue) {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
+ */
+Int8Array.prototype.reverse = function() {};
+
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+Int8Array.prototype.set = function(array, opt_offset) {};
+
+/**
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
+ */
+Int8Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Int8Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
+ */
+Int8Array.prototype.some = function(callback, opt_thisArg) {};
+
+/**
+ * @param {(function(number, number) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ * @override
+ */
+Int8Array.prototype.sort = function(opt_compareFunction) {};
+
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+Int8Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+Int8Array.prototype.values = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+Int8Array.prototype.toReversed = function() {};
+
+/**
+ * @param {function(number, number): number=} compareFn
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ * @override
+ */
+Int8Array.prototype.toSorted = function(compareFn) {};
+
+/**
+ * @param {number} index
+ * @param {number} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ * @override
+ */
+Int8Array.prototype.with = function(index, value) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+Int8Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+Int8Array.prototype.toString = function() {};
+
+/** @override */
+Int16Array.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
+ *     length or array or buffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} opt_byteOffset
+ * @param {number=} opt_length
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function Uint16Array(length, opt_byteOffset, opt_length) {}
+
+/** @const {number} */
+Uint16Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<number>|!Iterable<number>} source
+ * @param {function(this:S, ?, number): number=} mapFn
+ * @param {S=} thisArg
+ * @template S
+ * @return {!Uint16Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+Uint16Array.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...number} var_args
+ * @return {!Uint16Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+Uint16Array.of = function(var_args) {};
+
+/** @override */
+Uint16Array.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
+ *     length or array or buffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} opt_byteOffset
+ * @param {number=} opt_length
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function Int32Array(length, opt_byteOffset, opt_length) {}
+
+/** @const {number} */
+Int32Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<number>|!Iterable<number>} source
+ * @param {function(this:S, ?, number): number=} mapFn
+ * @param {S=} thisArg
+ * @template S
+ * @return {!Int32Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+Int32Array.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...number} var_args
+ * @return {!Int32Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+Int32Array.of = function(var_args) {};
+
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+Int32Array.prototype.at = function(index) {};
+
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+Int32Array.prototype.copyWithin = function(target, start, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+Int32Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+Int32Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+Int32Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+Int32Array.prototype.filter = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
+ */
+Int32Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
+ */
+Int32Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
+ */
+Int32Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
+ */
+Int32Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
+ */
+Int32Array.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
+ */
+Int32Array.prototype.includes = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
+ */
+Int32Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+Int32Array.prototype.join = function(opt_separator) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
+ */
+Int32Array.prototype.keys = function() {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+Int32Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
+ */
+Int32Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Int32Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
+ */
+Int32Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Int32Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
+ */
+Int32Array.prototype.reduceRight = function(callback, opt_initialValue) {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
+ */
+Int32Array.prototype.reverse = function() {};
+
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+Int32Array.prototype.set = function(array, opt_offset) {};
+
+/**
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
+ */
+Int32Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Int32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
+ */
+Int32Array.prototype.some = function(callback, opt_thisArg) {};
+
+/**
+ * @param {(function(number, number) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ * @override
+ */
+Int32Array.prototype.sort = function(opt_compareFunction) {};
+
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+Int32Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+Int32Array.prototype.values = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+Int32Array.prototype.toReversed = function() {};
+
+/**
+ * @param {function(number, number): number=} compareFn
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ * @override
+ */
+Int32Array.prototype.toSorted = function(compareFn) {};
+
+/**
+ * @param {number} index
+ * @param {number} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ * @override
+ */
+Int32Array.prototype.with = function(index, value) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+Int32Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+Int32Array.prototype.toString = function() {};
+
+/** @override */
+Int32Array.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
+ *     length or array or buffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} opt_byteOffset
+ * @param {number=} opt_length
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function Uint32Array(length, opt_byteOffset, opt_length) {}
+
+/** @const {number} */
+Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<number>|!Iterable<number>} source
+ * @param {function(this:S, ?, number): number=} mapFn
+ * @param {S=} thisArg
+ * @template S
+ * @return {!Uint32Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+Uint32Array.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...number} var_args
+ * @return {!Uint32Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+Uint32Array.of = function(var_args) {};
+
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+Uint32Array.prototype.at = function(index) {};
+
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+Uint32Array.prototype.copyWithin = function(target, start, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+Uint32Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+Uint32Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+Uint32Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+Uint32Array.prototype.filter = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
+ */
+Uint32Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
+ */
+Uint32Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
+ */
+Uint32Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
+ */
+Uint32Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
+ */
+Uint32Array.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
+ */
+Uint32Array.prototype.includes = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
+ */
+Uint32Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+Uint32Array.prototype.join = function(opt_separator) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
+ */
+Uint32Array.prototype.keys = function() {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+Uint32Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
+ */
+Uint32Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Uint32Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
+ */
+Uint32Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Uint32Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
+ */
+Uint32Array.prototype.reduceRight = function(callback, opt_initialValue) {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
+ */
+Uint32Array.prototype.reverse = function() {};
+
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+Uint32Array.prototype.set = function(array, opt_offset) {};
+
+/**
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
+ */
+Uint32Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Uint32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
+ */
+Uint32Array.prototype.some = function(callback, opt_thisArg) {};
+
+/**
+ * @param {(function(number, number) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ * @override
+ */
+Uint32Array.prototype.sort = function(opt_compareFunction) {};
+
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+Uint32Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+Uint32Array.prototype.values = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+Uint32Array.prototype.toReversed = function() {};
+
+/**
+ * @param {function(number, number): number=} compareFn
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ * @override
+ */
+Uint32Array.prototype.toSorted = function(compareFn) {};
+
+/**
+ * @param {number} index
+ * @param {number} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ * @override
+ */
+Uint32Array.prototype.with = function(index, value) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+Uint32Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+Uint32Array.prototype.toString = function() {};
+
+/** @override */
+Uint32Array.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
+ *     length
+ * @param {number=} opt_byteOffset
+ * @param {number=} opt_length
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float16Array
+ */
+function Float16Array(length, opt_byteOffset, opt_length) {}
+
+/** @const {number} */
+Float16Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<number>|!Iterable<number>} source
+ * @param {function(this:S, ?, number): number=} mapFn
+ * @param {S=} thisArg
+ * @return {!Float16Array}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+Float16Array.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...number} var_args
+ * @return {!Float16Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+Float16Array.of = function(var_args) {};
+
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+Float16Array.prototype.at = function(index) {};
+
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+Float16Array.prototype.copyWithin = function(target, start, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+Float16Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+Float16Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+Float16Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+Float16Array.prototype.filter = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
+ */
+Float16Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
+ */
+Float16Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
+ */
+Float16Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
+ */
+Float16Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
+ */
+Float16Array.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
+ */
+Float16Array.prototype.includes = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
+ */
+Float16Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+Float16Array.prototype.join = function(opt_separator) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
+ */
+Float16Array.prototype.keys = function() {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+Float16Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
+ */
+Float16Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Float16Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
+ */
+Float16Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Float16Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
+ */
+Float16Array.prototype.reduceRight = function(callback, opt_initialValue) {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
+ */
+Float16Array.prototype.reverse = function() {};
+
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+Float16Array.prototype.set = function(array, opt_offset) {};
+
+/**
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
+ */
+Float16Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Float16Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
+ */
+Float16Array.prototype.some = function(callback, opt_thisArg) {};
+
+/**
+ * @param {(function(number, number) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ * @override
+ */
+Float16Array.prototype.sort = function(opt_compareFunction) {};
+
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+Float16Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+Float16Array.prototype.values = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+Float16Array.prototype.toReversed = function() {};
+
+/**
+ * @param {function(number, number): number=} compareFn
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ * @override
+ */
+Float16Array.prototype.toSorted = function(compareFn) {};
+
+/**
+ * @param {number} index
+ * @param {number} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ * @override
+ */
+Float16Array.prototype.with = function(index, value) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+Float16Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+Float16Array.prototype.toString = function() {};
+
+/** @override */
+Float16Array.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
+ *     length or array or buffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} opt_byteOffset
+ * @param {number=} opt_length
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function Float32Array(length, opt_byteOffset, opt_length) {}
+
+/** @const {number} */
+Float32Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<number>|!Iterable<number>} source
+ * @param {function(this:S, ?, number): number=} mapFn
+ * @param {S=} thisArg
+ * @template S
+ * @return {!Float32Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+Float32Array.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...number} var_args
+ * @return {!Float32Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+Float32Array.of = function(var_args) {};
+
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+Float32Array.prototype.at = function(index) {};
+
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+Float32Array.prototype.copyWithin = function(target, start, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+Float32Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+Float32Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+Float32Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+Float32Array.prototype.filter = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
+ */
+Float32Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
+ */
+Float32Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
+ */
+Float32Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
+ */
+Float32Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
+ */
+Float32Array.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
+ */
+Float32Array.prototype.includes = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
+ */
+Float32Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+Float32Array.prototype.join = function(opt_separator) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
+ */
+Float32Array.prototype.keys = function() {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+Float32Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
+ */
+Float32Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Float32Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
+ */
+Float32Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Float32Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
+ */
+Float32Array.prototype.reduceRight = function(callback, opt_initialValue) {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
+ */
+Float32Array.prototype.reverse = function() {};
+
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+Float32Array.prototype.set = function(array, opt_offset) {};
+
+/**
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
+ */
+Float32Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Float32Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
+ */
+Float32Array.prototype.some = function(callback, opt_thisArg) {};
+
+/**
+ * @param {(function(number, number) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ * @override
+ */
+Float32Array.prototype.sort = function(opt_compareFunction) {};
+
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+Float32Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+Float32Array.prototype.values = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+Float32Array.prototype.toReversed = function() {};
+
+/**
+ * @param {function(number, number): number=} compareFn
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ * @override
+ */
+Float32Array.prototype.toSorted = function(compareFn) {};
+
+/**
+ * @param {number} index
+ * @param {number} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ * @override
+ */
+Float32Array.prototype.with = function(index, value) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+Float32Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+Float32Array.prototype.toString = function() {};
+
+/** @override */
+Float32Array.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
+ *     length or array or buffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} opt_byteOffset
+ * @param {number=} opt_length
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function Float64Array(length, opt_byteOffset, opt_length) {}
+
+/** @const {number} */
+Float64Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<number>|!Iterable<number>} source
  * @param {function(this:S, ?, number): number=} mapFn
  * @param {S=} thisArg
- * @return {!Float16Array}
  * @template S
+ * @return {!Float64Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+Float64Array.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...number} var_args
+ * @return {!Float64Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+Float64Array.of = function(var_args) {};
+
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+Float64Array.prototype.at = function(index) {};
+
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+Float64Array.prototype.copyWithin = function(target, start, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+Float64Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+Float64Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+Float64Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+Float64Array.prototype.filter = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
+ */
+Float64Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
+ */
+Float64Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
+ */
+Float64Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
+ */
+Float64Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
+ */
+Float64Array.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
+ */
+Float64Array.prototype.includes = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
+ */
+Float64Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+Float64Array.prototype.join = function(opt_separator) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
+ */
+Float64Array.prototype.keys = function() {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+Float64Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
+ */
+Float64Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Float64Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
+ */
+Float64Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !Float64Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
+ */
+Float64Array.prototype.reduceRight = function(callback, opt_initialValue) {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
+ */
+Float64Array.prototype.reverse = function() {};
+
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+Float64Array.prototype.set = function(array, opt_offset) {};
+
+/**
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
+ */
+Float64Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !Float64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
+ */
+Float64Array.prototype.some = function(callback, opt_thisArg) {};
+
+/**
+ * @param {(function(number, number) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ * @override
+ */
+Float64Array.prototype.sort = function(opt_compareFunction) {};
+
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+Float64Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+Float64Array.prototype.values = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+Float64Array.prototype.toReversed = function() {};
+
+/**
+ * @param {function(number, number): number=} compareFn
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ * @override
+ */
+Float64Array.prototype.toSorted = function(compareFn) {};
+
+/**
+ * @param {number} index
+ * @param {number} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ * @override
+ */
+Float64Array.prototype.with = function(index, value) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+Float64Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+Float64Array.prototype.toString = function() {};
+
+/** @override */
+Float64Array.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @param {number|ArrayBufferView|Array<bigint>|ArrayBuffer|SharedArrayBuffer}
+ *     lengthOrArrayOrBuffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} byteOffset
+ * @param {number=} bufferLength
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function BigInt64Array(lengthOrArrayOrBuffer, byteOffset, bufferLength) {}
+
+/** @const {number} */
+BigInt64Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<bigint>|!Iterable<bigint>} source
+ * @param {function(this:S, ?, number): bigint=} mapFn
+ * @param {S=} thisArg
+ * @template S
+ * @return {!BigInt64Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ */
+BigInt64Array.from = function(source, mapFn, thisArg) {};
+
+/**
+ * @param {...bigint} var_args
+ * @return {!BigInt64Array}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ */
+BigInt64Array.of = function(var_args) {};
+
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+BigInt64Array.prototype.at = function(index) {};
+
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+BigInt64Array.prototype.copyWithin = function(target, start, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+BigInt64Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+BigInt64Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+BigInt64Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+BigInt64Array.prototype.filter = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
+ */
+BigInt64Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
+ */
+BigInt64Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
+ */
+BigInt64Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
+ */
+BigInt64Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
+ */
+BigInt64Array.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
+ */
+BigInt64Array.prototype.includes = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
+ */
+BigInt64Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+BigInt64Array.prototype.join = function(opt_separator) {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
+ */
+BigInt64Array.prototype.keys = function() {};
+
+/**
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
+ */
+BigInt64Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : number} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
+ * @override
+ */
+BigInt64Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !BigInt64Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
+ * @override
+ */
+BigInt64Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @param {function((number|INIT|RET), number, number, !BigInt64Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
+ * @override
+ */
+BigInt64Array.prototype.reduceRight = function(callback, opt_initialValue) {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
+ */
+BigInt64Array.prototype.reverse = function() {};
+
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+BigInt64Array.prototype.set = function(array, opt_offset) {};
+
+/**
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
+ */
+BigInt64Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !BigInt64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
+ */
+BigInt64Array.prototype.some = function(callback, opt_thisArg) {};
+
+/**
+ * @param {(function(bigint, bigint) : number)=} opt_compareFunction
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @override
+ * @suppress {checkTypes} The types are specialized in this override.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+ */
+BigInt64Array.prototype.sort = function(opt_compareFunction) {};
+
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+BigInt64Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+BigInt64Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+BigInt64Array.prototype.toReversed = function() {};
+
+/**
+ * NOTE: this is an ES2023 extern.
+ * @param {function(bigint, bigint): number=} compareFn
+ * @return {!BigInt64Array}
+ * @nosideeffects
+ * @override
+ * @suppress {checkTypes} The types are specialized in this override.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
+ */
+BigInt64Array.prototype.toSorted = function(compareFn) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+BigInt64Array.prototype.toString = function() {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+BigInt64Array.prototype.values = function() {};
+
+/**
+ * NOTE: this is an ES2023 extern.
+ * @param {number} index
+ * @param {bigint} value
+ * @return {!BigInt64Array}
+ * @nosideeffects
+ * @override
+ * @suppress {checkTypes} The types are specialized in this override.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
+ */
+BigInt64Array.prototype.with = function(index, value) {};
+
+/** @override */
+BigInt64Array.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @param {number|ArrayBufferView|Array<bigint>|ArrayBuffer|SharedArrayBuffer}
+ *     lengthOrArrayOrBuffer
+ *     NOTE: We require that at least this first argument be present even though
+ *         the ECMAScript spec allows it to be absent, because this is better
+ *         for readability and detection of programmer errors.
+ * @param {number=} byteOffset
+ * @param {number=} bufferLength
+ * @template TArrayBuffer (unused)
+ * @constructor
+ * @implements {TypedArray}
+ * @throws {Error}
+ * @modifies {arguments}
+ */
+function BigUint64Array(lengthOrArrayOrBuffer, byteOffset, bufferLength) {}
+
+/** @const {number} */
+BigUint64Array.BYTES_PER_ELEMENT;
+
+/**
+ * @param {string|!IArrayLike<bigint>|!Iterable<bigint>} source
+ * @param {function(this:S, ?, number): bigint=} mapFn
+ * @param {S=} thisArg
+ * @template S
+ * @return {!BigUint64Array}
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
  */
-Float16Array.from = function(source, mapFn, thisArg) {};
+BigUint64Array.from = function(source, mapFn, thisArg) {};
 
 /**
- * @param {...number} var_args
- * @return {!Float16Array}
+ * @param {...bigint} var_args
+ * @return {!BigUint64Array}
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
  */
-Float16Array.of = function(var_args) {};
+BigUint64Array.of = function(var_args) {};
+
+
+/**
+ * @param {number} index
+ * @return {(number|undefined)}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at
+ * @override
+ */
+BigUint64Array.prototype.at = function(index) {};
+
+/**
+ * @param {number} target
+ * @param {number} start
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin
+ * @override
+ */
+BigUint64Array.prototype.copyWithin = function(target, start, opt_end) {};
+
+/**
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
+ */
+BigUint64Array.prototype.entries = function() {};
+
+/**
+ * @param {function(this:S, number, number, !BigUint64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every
+ * @override
+ */
+BigUint64Array.prototype.every = function(callback, opt_thisArg) {};
+
+/**
+ * @param {number} value
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill
+ * @override
+ */
+BigUint64Array.prototype.fill = function(value, opt_begin, opt_end) {};
+
+/**
+ * @param {function(this:S, number, number, !BigUint64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter
+ * @override
+ */
+BigUint64Array.prototype.filter = function(callback, opt_thisArg) {};
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length or array or buffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} opt_byteOffset
- * @param {number=} opt_length
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * @param {function(this:S, number, number, !BigUint64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
  */
-function Float32Array(length, opt_byteOffset, opt_length) {}
-
-/** @const {number} */
-Float32Array.BYTES_PER_ELEMENT;
+BigUint64Array.prototype.find = function(callback, opt_thisArg) {};
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
+ * @param {function(this:S, number, number, !BigUint64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
  * @template S
- * @return {!Float32Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex
+ * @override
  */
-Float32Array.from = function(source, mapFn, thisArg) {};
+BigUint64Array.prototype.findIndex = function(callback, opt_thisArg) {};
 
 /**
- * @param {...number} var_args
- * @return {!Float32Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @param {function(this:S, number, number, !BigUint64Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {(number|undefined)}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLast
  */
-Float32Array.of = function(var_args) {};
-
+BigUint64Array.prototype.findLast = function(callback, opt_thisArg) {};
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length or array or buffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} opt_byteOffset
- * @param {number=} opt_length
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * @param {function(this:S, number, number, !BigUint64Array) : boolean} callback
+ * @param {S=} opt_thisArg
+ * @return {number}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findLastIndex
+ * @override
  */
-function Float64Array(length, opt_byteOffset, opt_length) {}
-
-/** @const {number} */
-Float64Array.BYTES_PER_ELEMENT;
+BigUint64Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
+ * @param {function(this:S, number, number, !BigUint64Array) : ?} callback
+ * @param {S=} opt_thisArg
+ * @return {undefined}
  * @template S
- * @return {!Float64Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach
+ * @override
  */
-Float64Array.from = function(source, mapFn, thisArg) {};
+BigUint64Array.prototype.forEach = function(callback, opt_thisArg) {};
 
 /**
- * @param {...number} var_args
- * @return {!Float64Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {boolean}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes
+ * @override
  */
-Float64Array.of = function(var_args) {};
-
+BigUint64Array.prototype.includes = function(searchElement, opt_fromIndex) {};
 
 /**
- * @param {number|ArrayBufferView|Array<bigint>|ArrayBuffer|SharedArrayBuffer}
- *     lengthOrArrayOrBuffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} byteOffset
- * @param {number=} bufferLength
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf
+ * @override
  */
-function BigInt64Array(lengthOrArrayOrBuffer, byteOffset, bufferLength) {}
+BigUint64Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
 
-/** @const {number} */
-BigInt64Array.BYTES_PER_ELEMENT;
+/**
+ * @param {string=} opt_separator
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join
+ * @override
+ */
+BigUint64Array.prototype.join = function(opt_separator) {};
 
 /**
- * @param {string|!IArrayLike<bigint>|!Iterable<bigint>} source
- * @param {function(this:S, ?, number): bigint=} mapFn
- * @param {S=} thisArg
- * @template S
- * @return {!BigInt64Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
  */
-BigInt64Array.from = function(source, mapFn, thisArg) {};
+BigUint64Array.prototype.keys = function() {};
 
 /**
- * @param {...bigint} var_args
- * @return {!BigInt64Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @param {number} searchElement
+ * @param {number=} opt_fromIndex
+ * @return {number}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf
+ * @override
  */
-BigInt64Array.of = function(var_args) {};
+BigUint64Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
 
 /**
- * @param {(function(bigint, bigint) : number)=} opt_compareFunction
+ * @param {function(this:S, number, number, !BigUint64Array) : number} callback
+ * @param {S=} opt_thisArg
  * @return {THIS}
  * @this {THIS}
- * @template THIS
+ * @template THIS,S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map
  * @override
- * @suppress {checkTypes} The types are specialized in this override.
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort
  */
-BigInt64Array.prototype.sort = function(opt_compareFunction) {};
+BigUint64Array.prototype.map = function(callback, opt_thisArg) {};
 
 /**
- * NOTE: this is an ES2023 extern.
- * @param {function(bigint, bigint): number=} compareFn
- * @return {!BigInt64Array}
+ * @param {function((number|INIT|RET), number, number, !BigUint64Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
  * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce
  * @override
- * @suppress {checkTypes} The types are specialized in this override.
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toSorted
  */
-BigInt64Array.prototype.toSorted = function(compareFn) {};
+BigUint64Array.prototype.reduce = function(callback, opt_initialValue) {};
 
 /**
- * NOTE: this is an ES2023 extern.
- * @param {number} index
- * @param {bigint} value
- * @return {!BigInt64Array}
+ * @param {function((number|INIT|RET), number, number, !BigUint64Array) : RET}
+ *     callback
+ * @param {INIT=} opt_initialValue
+ * @return {RET}
+ * @template INIT,RET
  * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight
  * @override
- * @suppress {checkTypes} The types are specialized in this override.
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/with
  */
-BigInt64Array.prototype.with = function(index, value) {};
+BigUint64Array.prototype.reduceRight = function(callback, opt_initialValue) {};
 
 /**
- * @param {number|ArrayBufferView|Array<bigint>|ArrayBuffer|SharedArrayBuffer}
- *     lengthOrArrayOrBuffer
- *     NOTE: We require that at least this first argument be present even though
- *         the ECMAScript spec allows it to be absent, because this is better
- *         for readability and detection of programmer errors.
- * @param {number=} byteOffset
- * @param {number=} bufferLength
- * @template TArrayBuffer (unused)
- * @constructor
- * @extends {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
  */
-function BigUint64Array(lengthOrArrayOrBuffer, byteOffset, bufferLength) {}
+BigUint64Array.prototype.reverse = function() {};
 
-/** @const {number} */
-BigUint64Array.BYTES_PER_ELEMENT;
+/**
+ * @param {!ArrayBufferView|!Array<number>} array
+ * @param {number=} opt_offset
+ * @return {undefined}
+ * @throws {!RangeError}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set
+ * @override
+ */
+BigUint64Array.prototype.set = function(array, opt_offset) {};
 
 /**
- * @param {string|!IArrayLike<bigint>|!Iterable<bigint>} source
- * @param {function(this:S, ?, number): bigint=} mapFn
- * @param {S=} thisArg
- * @template S
- * @return {!BigUint64Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * @param {number=} opt_begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice
+ * @override
  */
-BigUint64Array.from = function(source, mapFn, thisArg) {};
+BigUint64Array.prototype.slice = function(opt_begin, opt_end) {};
 
 /**
- * @param {...bigint} var_args
- * @return {!BigUint64Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @param {function(this:S, number, number, !BigUint64Array) : *} callback
+ * @param {S=} opt_thisArg
+ * @return {boolean}
+ * @template S
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some
+ * @override
  */
-BigUint64Array.of = function(var_args) {};
+BigUint64Array.prototype.some = function(callback, opt_thisArg) {};
 
 /**
  * @param {(function(bigint, bigint) : number)=} opt_compareFunction
@@ -1401,6 +4459,36 @@ BigUint64Array.of = function(var_args) {};
  */
 BigUint64Array.prototype.sort = function(opt_compareFunction) {};
 
+/**
+ * @param {number} begin
+ * @param {number=} opt_end
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray
+ * @override
+ */
+BigUint64Array.prototype.subarray = function(begin, opt_end) {};
+
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
+ */
+BigUint64Array.prototype.toLocaleString = function() {};
+
+/**
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
+ */
+BigUint64Array.prototype.toReversed = function() {};
+
 /**
  * NOTE: this is an ES2023 extern.
  * @param {function(bigint, bigint): number=} compareFn
@@ -1412,6 +4500,22 @@ BigUint64Array.prototype.sort = function(opt_compareFunction) {};
  */
 BigUint64Array.prototype.toSorted = function(compareFn) {};
 
+/**
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
+ */
+BigUint64Array.prototype.toString = function() {};
+
+/**
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
+ */
+BigUint64Array.prototype.values = function() {};
+
 /**
  * NOTE: this is an ES2023 extern.
  * @param {number} index
@@ -1424,12 +4528,16 @@ BigUint64Array.prototype.toSorted = function(compareFn) {};
  */
 BigUint64Array.prototype.with = function(index, value) {};
 
+/** @override */
+BigUint64Array.prototype[Symbol.iterator] = function() {};
+
+
 /**
  * @param {ArrayBuffer|SharedArrayBuffer} buffer
  * @param {number=} opt_byteOffset
  * @param {number=} opt_byteLength
  * @constructor
- * @extends {ArrayBufferView}
+ * @implements {ArrayBufferView}
  * @throws {Error}
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays/DataView
  */