From 4149aad83a346e44b2753c5038b7f9ba58c4595a Mon Sep 17 00:00:00 2001
From: Colin Alworth <colin@colinalworth.com>
Date: Fri, 19 Jul 2024 16:29:13 -0500
Subject: [PATCH 1/5] Define ArrayBufferView and TypedArray as interfaces
 rather than classes

Technically, the former appears to be a typedef and the latter might be
a template for classes? But neither exists as a named
function/constructor. Earlier versions of the spec do indicate that both
were at one point interfaces though.
---
 externs/es6.js | 34 ++++++++++++++++++----------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/externs/es6.js b/externs/es6.js
index 85f778f4c64..d44e79c28f6 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,14 @@ var AllowSharedBufferSource;
 
 
 /**
- * @constructor
+ * @interface
  * @implements {IArrayLike<number>}
  * @implements {Iterable<number>}
- * @extends {ArrayBufferView}
+ * @implements {ArrayBufferView}
  * @template TArrayBuffer (unused)
+ * @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-typedarray-objects
  */
-function TypedArray() {};
+function TypedArray() {}
 
 /** @const {number} */
 TypedArray.prototype.BYTES_PER_ELEMENT;
@@ -771,7 +773,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
@@ -818,7 +820,7 @@ Int8Array.of = function(var_args) {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -855,7 +857,7 @@ Uint8Array.of = function(var_args) {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -901,7 +903,7 @@ var CanvasPixelArray;
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -938,7 +940,7 @@ Int16Array.of = function(var_args) {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -975,7 +977,7 @@ Uint16Array.of = function(var_args) {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -1012,7 +1014,7 @@ Int32Array.of = function(var_args) {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -1082,7 +1084,7 @@ Float16Array.of = function(var_args) {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -1119,7 +1121,7 @@ Float32Array.of = function(var_args) {};
  * @param {number=} opt_length
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -1156,7 +1158,7 @@ Float64Array.of = function(var_args) {};
  * @param {number=} bufferLength
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -1226,7 +1228,7 @@ BigInt64Array.prototype.with = function(index, value) {};
  * @param {number=} bufferLength
  * @template TArrayBuffer (unused)
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  */
@@ -1291,7 +1293,7 @@ BigUint64Array.prototype.with = function(index, value) {};
  * @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
  */

From 2fee2308eb4a27d20efc3d8edc42791e4c930b28 Mon Sep 17 00:00:00 2001
From: Colin Alworth <colin@colinalworth.com>
Date: Thu, 25 Jul 2024 14:42:55 -0500
Subject: [PATCH 2/5] Interfaces should use @extends for other interfaces

---
 externs/es6.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/externs/es6.js b/externs/es6.js
index d44e79c28f6..718d3ba724e 100644
--- a/externs/es6.js
+++ b/externs/es6.js
@@ -455,9 +455,9 @@ var AllowSharedBufferSource;
 
 /**
  * @interface
- * @implements {IArrayLike<number>}
- * @implements {Iterable<number>}
- * @implements {ArrayBufferView}
+ * @extends {IArrayLike<number>}
+ * @extends {Iterable<number>}
+ * @extends {ArrayBufferView}
  * @template TArrayBuffer (unused)
  * @see https://tc39.es/ecma262/multipage/indexed-collections.html#sec-typedarray-objects
  */

From 91829e4db6161216c896049d4dbdb8b598ceee44 Mon Sep 17 00:00:00 2001
From: Colin Alworth <colin@colinalworth.com>
Date: Fri, 2 Jan 2026 11:49:16 -0600
Subject: [PATCH 3/5] Add another reference

---
 externs/es6.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/externs/es6.js b/externs/es6.js
index 718d3ba724e..a6614aa444f 100644
--- a/externs/es6.js
+++ b/externs/es6.js
@@ -460,6 +460,7 @@ var AllowSharedBufferSource;
  * @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() {}
 

From b5b9d5ec0275ed005b33a11a0a0c7c009f59072d Mon Sep 17 00:00:00 2001
From: Colin Alworth <colin@colinalworth.com>
Date: Fri, 2 Jan 2026 16:47:41 -0600
Subject: [PATCH 4/5] Add override for new method, handle other
 extends/implements change

---
 externs/es6.js | 41 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 40 insertions(+), 1 deletion(-)

diff --git a/externs/es6.js b/externs/es6.js
index a6614aa444f..5a3ec1fb504 100644
--- a/externs/es6.js
+++ b/externs/es6.js
@@ -810,6 +810,9 @@ Int8Array.from = function(source, mapFn, thisArg) {};
  */
 Int8Array.of = function(var_args) {};
 
+/** @override */
+Int8Array.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
@@ -847,6 +850,9 @@ Uint8Array.from = function(source, mapFn, thisArg) {};
  */
 Uint8Array.of = function(var_args) {};
 
+/** @override */
+Uint8Array.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
@@ -884,6 +890,9 @@ Uint8ClampedArray.from = function(source, mapFn, thisArg) {};
  */
 Uint8ClampedArray.of = function(var_args) {};
 
+/** @override */
+Uint8ClampedArray.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @typedef {Uint8ClampedArray}
@@ -930,6 +939,9 @@ Int16Array.from = function(source, mapFn, thisArg) {};
  */
 Int16Array.of = function(var_args) {};
 
+/** @override */
+Int16Array.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
@@ -967,6 +979,9 @@ Uint16Array.from = function(source, mapFn, thisArg) {};
  */
 Uint16Array.of = function(var_args) {};
 
+/** @override */
+Uint16Array.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
@@ -1004,6 +1019,9 @@ Int32Array.from = function(source, mapFn, thisArg) {};
  */
 Int32Array.of = function(var_args) {};
 
+/** @override */
+Int32Array.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
@@ -1041,6 +1059,9 @@ Uint32Array.from = function(source, mapFn, thisArg) {};
  */
 Uint32Array.of = function(var_args) {};
 
+/** @override */
+Uint32Array.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
@@ -1048,7 +1069,7 @@ Uint32Array.of = function(var_args) {};
  * @param {number=} opt_byteOffset
  * @param {number=} opt_length
  * @constructor
- * @extends {TypedArray}
+ * @implements {TypedArray}
  * @throws {Error}
  * @modifies {arguments}
  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float16Array
@@ -1075,6 +1096,10 @@ Float16Array.from = function(source, mapFn, thisArg) {};
  */
 Float16Array.of = function(var_args) {};
 
+/** @override */
+Float16Array.prototype[Symbol.iterator] = function() {};
+
+
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
  *     length or array or buffer
@@ -1111,6 +1136,9 @@ Float32Array.from = function(source, mapFn, thisArg) {};
  */
 Float32Array.of = function(var_args) {};
 
+/** @override */
+Float32Array.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
@@ -1148,6 +1176,9 @@ Float64Array.from = function(source, mapFn, thisArg) {};
  */
 Float64Array.of = function(var_args) {};
 
+/** @override */
+Float64Array.prototype[Symbol.iterator] = function() {};
+
 
 /**
  * @param {number|ArrayBufferView|Array<bigint>|ArrayBuffer|SharedArrayBuffer}
@@ -1219,6 +1250,10 @@ BigInt64Array.prototype.toSorted = function(compareFn) {};
  */
 BigInt64Array.prototype.with = function(index, value) {};
 
+/** @override */
+BigInt64Array.prototype[Symbol.iterator] = function() {};
+
+
 /**
  * @param {number|ArrayBufferView|Array<bigint>|ArrayBuffer|SharedArrayBuffer}
  *     lengthOrArrayOrBuffer
@@ -1289,6 +1324,10 @@ 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

From e8e885d5e5637e88d7d0294752c32350a5dbeb7e Mon Sep 17 00:00:00 2001
From: Colin Alworth <colin@colinalworth.com>
Date: Wed, 8 Apr 2026 12:34:21 -0500
Subject: [PATCH 5/5] Duplicate overrides

---
 externs/es6.js | 3702 +++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 3384 insertions(+), 318 deletions(-)

diff --git a/externs/es6.js b/externs/es6.js
index aeba4e855b6..d5db9cecdde 100644
--- a/externs/es6.js
+++ b/externs/es6.js
@@ -810,356 +810,412 @@ Int8Array.from = function(source, mapFn, thisArg) {};
  */
 Int8Array.of = function(var_args) {};
 
-/** @override */
-Int8Array.prototype[Symbol.iterator] = function() {};
-
-
 /**
- * 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} 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 Uint8ArrayBase64Options() {}
+Int8Array.prototype.at = function(index) {};
 
 /**
- * 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 {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
  */
-Uint8ArrayBase64Options.prototype.alphabet;
+Int8Array.prototype.copyWithin = function(target, start, opt_end) {};
 
 /**
- * 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)}
+ * @return {!IteratorIterable<!Array<number>>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries
+ * @override
  */
-Uint8ArrayBase64Options.prototype.lastChunkHandling;
-
+Int8Array.prototype.entries = function() {};
 
 /**
- * Results from Uint8Array.prototype.setFromBase64.
- * @record
+ * @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
  */
-function Uint8ArraySetFromBase64Results() {}
+Int8Array.prototype.every = 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 {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
  */
-Uint8ArraySetFromBase64Results.prototype.read;
+Int8Array.prototype.fill = function(value, opt_begin, opt_end) {};
 
 /**
- * The number of bytes written into the Uint8Array.
- * @type {number}
+ * @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
  */
-Uint8ArraySetFromBase64Results.prototype.written;
+Int8Array.prototype.filter = 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) : *} 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 Uint8ArrayToBase64Options() {}
+Int8Array.prototype.find = 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) : *} 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
  */
-Uint8ArrayToBase64Options.prototype.alphabet;
+Int8Array.prototype.findIndex = 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) : 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
  */
-Uint8ArrayToBase64Options.prototype.omitPadding;
+Int8Array.prototype.findLast = 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 {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
  */
-function Uint8ArraySetFromHexResults() {}
+Int8Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
 
 /**
- * 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 {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
  */
-Uint8ArraySetFromHexResults.prototype.read;
+Int8Array.prototype.forEach = function(callback, opt_thisArg) {};
 
 /**
- * The number of bytes written into the Uint8Array. Will never be greater than this Uint8Array's
- * length.
- * @type {number}
+ * @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
  */
-Uint8ArraySetFromHexResults.prototype.written;
+Int8Array.prototype.includes = function(searchElement, opt_fromIndex) {};
 
 /**
- * @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}
+ * @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 Uint8Array(length, opt_byteOffset, opt_length) {}
+Int8Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
 
-/** @const {number} */
-Uint8Array.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
+ */
+Int8Array.prototype.join = function(opt_separator) {};
 
 /**
- * @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
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys
+ * @override
  */
-Uint8Array.from = function(source, mapFn, thisArg) {};
+Int8Array.prototype.keys = function() {};
 
 /**
- * @param {...number} var_args
- * @return {!Uint8Array}
- * @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
  */
-Uint8Array.of = function(var_args) {};
+Int8Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
 
-/** @override */
-Uint8Array.prototype[Symbol.iterator] = function() {};
+/**
+ * @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) {};
 
 /**
- * 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/reduce
+ * @override
  */
-Uint8Array.fromBase64 = function(string, options) {};
+Int8Array.prototype.reduce = 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
+ * @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.fromHex = function(string) {};
+Int8Array.prototype.reduceRight = function(callback, opt_initialValue) {};
 
 /**
- * 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
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse
  */
-Uint8Array.prototype.setFromBase64 = function(string, options) {};
+Int8Array.prototype.reverse = function() {};
 
 /**
- * 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 {!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.setFromHex = function(string) {};
+Int8Array.prototype.set = function(array, opt_offset) {};
 
 /**
- * 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 {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.toBase64 = function(options) {};
+Int8Array.prototype.slice = function(opt_begin, opt_end) {};
 
 /**
- * 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(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.toHex = function() {};
+Int8Array.prototype.some = 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
- * @implements {TypedArray}
- * @throws {Error}
- * @modifies {arguments}
+ * @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
  */
-function Uint8ClampedArray(length, opt_byteOffset, opt_length) {}
-
-/** @const {number} */
-Uint8ClampedArray.BYTES_PER_ELEMENT;
+Int8Array.prototype.sort = function(opt_compareFunction) {};
 
 /**
- * @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
+ * @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
  */
-Uint8ClampedArray.from = function(source, mapFn, thisArg) {};
+Int8Array.prototype.subarray = function(begin, opt_end) {};
 
 /**
- * @param {...number} var_args
- * @return {!Uint8ClampedArray}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @return {!IteratorIterable<number>}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values
+ * @override
  */
-Uint8ClampedArray.of = function(var_args) {};
-
-/** @override */
-Uint8ClampedArray.prototype[Symbol.iterator] = function() {};
-
+Int8Array.prototype.values = function() {};
 
 /**
- * @typedef {Uint8ClampedArray}
- * @deprecated CanvasPixelArray has been replaced by Uint8ClampedArray
- *     in the latest spec.
- * @see http://www.w3.org/TR/2dcontext/#imagedata
+ * @return {THIS}y
+ * @this {THIS}
+ * @template THIS
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toReversed
+ * @override
  */
-var CanvasPixelArray;
-
+Int8Array.prototype.toReversed = 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}
+ * @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
  */
-function Int16Array(length, opt_byteOffset, opt_length) {}
+Int8Array.prototype.toSorted = function(compareFn) {};
 
-/** @const {number} */
-Int16Array.BYTES_PER_ELEMENT;
+/**
+ * @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) {};
 
 /**
- * @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
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
  */
-Int16Array.from = function(source, mapFn, thisArg) {};
+Int8Array.prototype.toLocaleString = function() {};
 
 /**
- * @param {...number} var_args
- * @return {!Int16Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
  */
-Int16Array.of = function(var_args) {};
+Int8Array.prototype.toString = function() {};
 
 /** @override */
-Int16Array.prototype[Symbol.iterator] = function() {};
+Int8Array.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}
+ * 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
  */
-function Uint16Array(length, opt_byteOffset, opt_length) {}
+function Uint8ArrayBase64Options() {}
 
-/** @const {number} */
-Uint16Array.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)}
+ */
+Uint8ArrayBase64Options.prototype.alphabet;
 
 /**
- * @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
+ * 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)}
  */
-Uint16Array.from = function(source, mapFn, thisArg) {};
+Uint8ArrayBase64Options.prototype.lastChunkHandling;
+
 
 /**
- * @param {...number} var_args
- * @return {!Uint16Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * Results from Uint8Array.prototype.setFromBase64.
+ * @record
  */
-Uint16Array.of = function(var_args) {};
+function Uint8ArraySetFromBase64Results() {}
 
-/** @override */
-Uint16Array.prototype[Symbol.iterator] = function() {};
+/**
+ * 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}
+ */
+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
- * @implements {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() {}
 
-/** @override */
-Int32Array.prototype[Symbol.iterator] = function() {};
+/**
+ * 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}
@@ -1175,144 +1231,2593 @@ Int32Array.prototype[Symbol.iterator] = function() {};
  * @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) {};
-
-/** @override */
-Uint32Array.prototype[Symbol.iterator] = function() {};
+Uint8Array.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
+ */
+Uint8Array.prototype.at = function(index) {};
 
 /**
- * @param {number|ArrayBufferView|Array<number>|ArrayBuffer|SharedArrayBuffer}
- *     length
+ * @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) {};
+
+/**
+ * @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}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float16Array
  */
-function Float16Array(length, opt_byteOffset, opt_length) {}
+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
+ * @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() {};
 
-/** @const {number} */
-Float16Array.BYTES_PER_ELEMENT;
+/**
+ * @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 {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
- * @return {!Float16Array}
+ * @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/from
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find
+ * @override
  */
-Float16Array.from = function(source, mapFn, thisArg) {};
+Float64Array.prototype.find = function(callback, opt_thisArg) {};
 
 /**
- * @param {...number} var_args
- * @return {!Float16Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @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
  */
-Float16Array.of = function(var_args) {};
+Float64Array.prototype.findIndex = function(callback, opt_thisArg) {};
 
-/** @override */
-Float16Array.prototype[Symbol.iterator] = function() {};
+/**
+ * @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|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}
+ * @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 Float32Array(length, opt_byteOffset, opt_length) {}
+Float64Array.prototype.includes = function(searchElement, opt_fromIndex) {};
 
-/** @const {number} */
-Float32Array.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/indexOf
+ * @override
+ */
+Float64Array.prototype.indexOf = function(searchElement, opt_fromIndex) {};
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
+ * @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
- * @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/some
+ * @override
  */
-Float32Array.from = function(source, mapFn, thisArg) {};
+Float64Array.prototype.some = 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(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.of = function(var_args) {};
+Float64Array.prototype.sort = function(opt_compareFunction) {};
 
-/** @override */
-Float32Array.prototype[Symbol.iterator] = function() {};
+/**
+ * @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() {};
 
 /**
- * @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}
+ * @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
  */
-function Float64Array(length, opt_byteOffset, opt_length) {}
-
-/** @const {number} */
-Float64Array.BYTES_PER_ELEMENT;
+Float64Array.prototype.with = function(index, value) {};
 
 /**
- * @param {string|!IArrayLike<number>|!Iterable<number>} source
- * @param {function(this:S, ?, number): number=} mapFn
- * @param {S=} thisArg
- * @template S
- * @return {!Float64Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString
+ * @override
  */
-Float64Array.from = function(source, mapFn, thisArg) {};
+Float64Array.prototype.toLocaleString = function() {};
 
 /**
- * @param {...number} var_args
- * @return {!Float64Array}
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of
+ * @return {string}
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString
+ * @override
  */
-Float64Array.of = function(var_args) {};
+Float64Array.prototype.toString = function() {};
 
 /** @override */
 Float64Array.prototype[Symbol.iterator] = function() {};
@@ -1354,6 +3859,240 @@ BigInt64Array.from = function(source, mapFn, thisArg) {};
  */
 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}
@@ -1365,6 +4104,36 @@ BigInt64Array.of = function(var_args) {};
  */
 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
@@ -1376,6 +4145,22 @@ BigInt64Array.prototype.sort = function(opt_compareFunction) {};
  */
 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
@@ -1428,6 +4213,241 @@ BigUint64Array.from = function(source, mapFn, thisArg) {};
  */
 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 {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
+ */
+BigUint64Array.prototype.find = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !BigUint64Array) : *} 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
+ */
+BigUint64Array.prototype.findIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @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
+ */
+BigUint64Array.prototype.findLast = function(callback, opt_thisArg) {};
+
+/**
+ * @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
+ */
+BigUint64Array.prototype.findLastIndex = function(callback, opt_thisArg) {};
+
+/**
+ * @param {function(this:S, number, number, !BigUint64Array) : ?} 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
+ */
+BigUint64Array.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
+ */
+BigUint64Array.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
+ */
+BigUint64Array.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
+ */
+BigUint64Array.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
+ */
+BigUint64Array.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
+ */
+BigUint64Array.prototype.lastIndexOf = function(searchElement, opt_fromIndex) {};
+
+/**
+ * @param {function(this:S, number, number, !BigUint64Array) : 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
+ */
+BigUint64Array.prototype.map = function(callback, opt_thisArg) {};
+
+/**
+ * @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
+ */
+BigUint64Array.prototype.reduce = function(callback, opt_initialValue) {};
+
+/**
+ * @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
+ */
+BigUint64Array.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
+ */
+BigUint64Array.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
+ */
+BigUint64Array.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
+ */
+BigUint64Array.prototype.slice = function(opt_begin, opt_end) {};
+
+/**
+ * @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.prototype.some = function(callback, opt_thisArg) {};
+
 /**
  * @param {(function(bigint, bigint) : number)=} opt_compareFunction
  * @return {THIS}
@@ -1439,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
@@ -1450,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