@tsonic/js 0.1.2

package/index/internal/index.d.ts

@@ -0,0 +1,735 @@
+// Generated by tsbindgen - Architecture
+// Namespace: Tsonic.JSRuntime
+// Assembly: Tsonic.JSRuntime
+
+// Primitive type aliases from @tsonic/core
+import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';
+
+// Import types from other namespaces
+import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic.js";
+import type { IEnumerable as IEnumerable__System_Collections_Generic, IEnumerator, KeyValuePair, List } from "@tsonic/dotnet/System.Collections.Generic.js";
+import * as System_Collections_Internal from "@tsonic/dotnet/System.Collections.js";
+import type { IEnumerable } from "@tsonic/dotnet/System.Collections.js";
+import * as System_Internal from "@tsonic/dotnet/System.js";
+import type { Action, Boolean as ClrBoolean, Byte, Comparison, Double, Func, Int16, Int32, Int64, Nullable, Object as ClrObject, SByte, Single, String as ClrString, UInt16, UInt32, ValueTuple, Void } from "@tsonic/dotnet/System.js";
+
+export interface ArrayBuffer$instance {
+    readonly byteLength: int;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): ArrayBuffer;
+}
+
+
+export const ArrayBuffer: {
+    new(byteLength: int): ArrayBuffer;
+};
+
+
+export type ArrayBuffer = ArrayBuffer$instance;
+
+export interface Date$instance {
+    getDate(): int;
+    getDay(): int;
+    getFullYear(): int;
+    getHours(): int;
+    getMilliseconds(): int;
+    getMinutes(): int;
+    getMonth(): int;
+    getSeconds(): int;
+    getTime(): long;
+    getTimezoneOffset(): int;
+    getUTCDate(): int;
+    getUTCDay(): int;
+    getUTCFullYear(): int;
+    getUTCHours(): int;
+    getUTCMilliseconds(): int;
+    getUTCMinutes(): int;
+    getUTCMonth(): int;
+    getUTCSeconds(): int;
+    setDate(day: int): double;
+    setFullYear(year: int, month?: Nullable<System_Internal.Int32>, day?: Nullable<System_Internal.Int32>): double;
+    setHours(hour: int, min?: Nullable<System_Internal.Int32>, sec?: Nullable<System_Internal.Int32>, ms?: Nullable<System_Internal.Int32>): double;
+    setMilliseconds(ms: int): double;
+    setMinutes(min: int, sec?: Nullable<System_Internal.Int32>, ms?: Nullable<System_Internal.Int32>): double;
+    setMonth(month: int, day?: Nullable<System_Internal.Int32>): double;
+    setSeconds(sec: int, ms?: Nullable<System_Internal.Int32>): double;
+    setTime(milliseconds: double): double;
+    setUTCDate(day: int): double;
+    setUTCFullYear(year: int, month?: Nullable<System_Internal.Int32>, day?: Nullable<System_Internal.Int32>): double;
+    setUTCHours(hour: int, min?: Nullable<System_Internal.Int32>, sec?: Nullable<System_Internal.Int32>, ms?: Nullable<System_Internal.Int32>): double;
+    setUTCMilliseconds(ms: int): double;
+    setUTCMinutes(min: int, sec?: Nullable<System_Internal.Int32>, ms?: Nullable<System_Internal.Int32>): double;
+    setUTCMonth(month: int, day?: Nullable<System_Internal.Int32>): double;
+    setUTCSeconds(sec: int, ms?: Nullable<System_Internal.Int32>): double;
+    toDateString(): string;
+    toISOString(): string;
+    toJSON(): string;
+    toLocaleDateString(): string;
+    toLocaleString(): string;
+    toLocaleTimeString(): string;
+    toString(): string;
+    toTimeString(): string;
+    toUTCString(): string;
+    valueOf(): long;
+}
+
+
+export const Date: {
+    new(): Date;
+    new(milliseconds: double): Date;
+    new(dateString: string): Date;
+    new(year: int, month: int, day: int, hours: int, minutes: int, seconds: int, milliseconds: int): Date;
+    now(): long;
+    parse(dateString: string): double;
+    UTC(year: int, month: int, day?: int, hours?: int, minutes?: int, seconds?: int, milliseconds?: int): double;
+};
+
+
+export type Date = Date$instance;
+
+export interface Float32Array$instance {
+    readonly byteLength: int;
+    item: float;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.Single>;
+    fill(value: float, start?: int, end?: Nullable<System_Internal.Int32>): Float32Array;
+    getEnumerator(): IEnumerator<System_Internal.Single>;
+    includes(value: float, fromIndex?: int): boolean;
+    indexOf(value: float, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Float32Array;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.Single>, offset?: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Float32Array;
+    sort(compareFn?: Comparison<System_Internal.Single>): Float32Array;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Float32Array;
+}
+
+
+export const Float32Array: {
+    new(length: int): Float32Array;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.Single>): Float32Array;
+    new(values: float[]): Float32Array;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Float32Array = Float32Array$instance;
+
+export interface Float64Array$instance {
+    readonly byteLength: int;
+    item: double;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.Double>;
+    fill(value: double, start?: int, end?: Nullable<System_Internal.Int32>): Float64Array;
+    getEnumerator(): IEnumerator<System_Internal.Double>;
+    includes(value: double, fromIndex?: int): boolean;
+    indexOf(value: double, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Float64Array;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.Double>, offset?: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Float64Array;
+    sort(compareFn?: Comparison<System_Internal.Double>): Float64Array;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Float64Array;
+}
+
+
+export const Float64Array: {
+    new(length: int): Float64Array;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.Double>): Float64Array;
+    new(values: double[]): Float64Array;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Float64Array = Float64Array$instance;
+
+export interface Int16Array$instance {
+    readonly byteLength: int;
+    item: short;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.Int16>;
+    fill(value: short, start?: int, end?: Nullable<System_Internal.Int32>): Int16Array;
+    getEnumerator(): IEnumerator<System_Internal.Int16>;
+    includes(value: short, fromIndex?: int): boolean;
+    indexOf(value: short, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Int16Array;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.Int16>, offset?: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Int16Array;
+    sort(compareFn?: Comparison<System_Internal.Int16>): Int16Array;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Int16Array;
+}
+
+
+export const Int16Array: {
+    new(length: int): Int16Array;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.Int16>): Int16Array;
+    new(values: short[]): Int16Array;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Int16Array = Int16Array$instance;
+
+export interface Int32Array$instance {
+    readonly byteLength: int;
+    item: int;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.Int32>;
+    fill(value: int, start?: int, end?: Nullable<System_Internal.Int32>): Int32Array;
+    getEnumerator(): IEnumerator<System_Internal.Int32>;
+    includes(value: int, fromIndex?: int): boolean;
+    indexOf(value: int, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Int32Array;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.Int32>, offset?: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Int32Array;
+    sort(compareFn?: Comparison<System_Internal.Int32>): Int32Array;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Int32Array;
+}
+
+
+export const Int32Array: {
+    new(length: int): Int32Array;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.Int32>): Int32Array;
+    new(values: int[]): Int32Array;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Int32Array = Int32Array$instance;
+
+export interface Int8Array$instance {
+    readonly byteLength: int;
+    item: sbyte;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.SByte>;
+    fill(value: sbyte, start?: int, end?: Nullable<System_Internal.Int32>): Int8Array;
+    getEnumerator(): IEnumerator<System_Internal.SByte>;
+    includes(value: sbyte, fromIndex?: int): boolean;
+    indexOf(value: sbyte, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Int8Array;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.SByte>, offset?: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Int8Array;
+    sort(compareFn?: Comparison<System_Internal.SByte>): Int8Array;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Int8Array;
+}
+
+
+export const Int8Array: {
+    new(length: int): Int8Array;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.SByte>): Int8Array;
+    new(values: sbyte[]): Int8Array;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Int8Array = Int8Array$instance;
+
+export interface JSArray_1$instance<T> {
+    item: T;
+    readonly length: int;
+    at(index: int): T;
+    concat(...items: unknown[]): JSArray_1<T>;
+    copyWithin(target: int, start?: int, end?: Nullable<System_Internal.Int32>): JSArray_1<T>;
+    entries(): IEnumerable__System_Collections_Generic<ValueTuple<System_Internal.Int32, T>>;
+    every(callback: Func<T, System_Internal.Boolean>): boolean;
+    every(callback: Func<T, System_Internal.Int32, JSArray_1<T>, System_Internal.Boolean>): boolean;
+    fill(value: T, start?: int, end?: Nullable<System_Internal.Int32>): JSArray_1<T>;
+    filter(callback: Func<T, System_Internal.Boolean>): JSArray_1<T>;
+    filter(callback: Func<T, System_Internal.Int32, System_Internal.Boolean>): JSArray_1<T>;
+    filter(callback: Func<T, System_Internal.Int32, JSArray_1<T>, System_Internal.Boolean>): JSArray_1<T>;
+    find(callback: Func<T, System_Internal.Boolean>): T;
+    find(callback: Func<T, System_Internal.Int32, System_Internal.Boolean>): T;
+    find(callback: Func<T, System_Internal.Int32, JSArray_1<T>, System_Internal.Boolean>): T;
+    findIndex(callback: Func<T, System_Internal.Boolean>): int;
+    findIndex(callback: Func<T, System_Internal.Int32, System_Internal.Boolean>): int;
+    findIndex(callback: Func<T, System_Internal.Int32, JSArray_1<T>, System_Internal.Boolean>): int;
+    findLast(callback: Func<T, System_Internal.Boolean>): T;
+    findLast(callback: Func<T, System_Internal.Int32, System_Internal.Boolean>): T;
+    findLast(callback: Func<T, System_Internal.Int32, JSArray_1<T>, System_Internal.Boolean>): T;
+    findLastIndex(callback: Func<T, System_Internal.Boolean>): int;
+    findLastIndex(callback: Func<T, System_Internal.Int32, System_Internal.Boolean>): int;
+    findLastIndex(callback: Func<T, System_Internal.Int32, JSArray_1<T>, System_Internal.Boolean>): int;
+    flat(depth?: int): JSArray_1<unknown>;
+    flatMap<TResult>(callback: Func<T, System_Internal.Int32, JSArray_1<T>, unknown>): JSArray_1<TResult>;
+    forEach(callback: Action<T>): void;
+    forEach(callback: Action<T, System_Internal.Int32>): void;
+    forEach(callback: Action<T, System_Internal.Int32, JSArray_1<T>>): void;
+    getEnumerator(): IEnumerator<T>;
+    includes(searchElement: T): boolean;
+    indexOf(searchElement: T, fromIndex?: int): int;
+    join(separator?: string): string;
+    keys(): IEnumerable__System_Collections_Generic<System_Internal.Int32>;
+    lastIndexOf(searchElement: T, fromIndex?: Nullable<System_Internal.Int32>): int;
+    map<TResult>(callback: Func<T, TResult>): JSArray_1<TResult>;
+    map<TResult>(callback: Func<T, System_Internal.Int32, TResult>): JSArray_1<TResult>;
+    map<TResult>(callback: Func<T, System_Internal.Int32, JSArray_1<T>, TResult>): JSArray_1<TResult>;
+    pop(): T;
+    push(item: T): int;
+    push(...items: T[]): int;
+    reduce<TResult>(callback: Func<TResult, T, TResult>, initialValue: TResult): TResult;
+    reduce<TResult>(callback: Func<TResult, T, System_Internal.Int32, TResult>, initialValue: TResult): TResult;
+    reduce<TResult>(callback: Func<TResult, T, System_Internal.Int32, JSArray_1<T>, TResult>, initialValue: TResult): TResult;
+    reduce(callback: Func<T, T, T>): T;
+    reduceRight<TResult>(callback: Func<TResult, T, TResult>, initialValue: TResult): TResult;
+    reduceRight<TResult>(callback: Func<TResult, T, System_Internal.Int32, TResult>, initialValue: TResult): TResult;
+    reduceRight<TResult>(callback: Func<TResult, T, System_Internal.Int32, JSArray_1<T>, TResult>, initialValue: TResult): TResult;
+    reverse(): JSArray_1<T>;
+    setLength(newLength: int): void;
+    shift(): T;
+    slice(start?: int, end?: Nullable<System_Internal.Int32>): JSArray_1<T>;
+    some(callback: Func<T, System_Internal.Boolean>): boolean;
+    some(callback: Func<T, System_Internal.Int32, JSArray_1<T>, System_Internal.Boolean>): boolean;
+    sort(compareFunc?: Func<T, T, System_Internal.Double>): JSArray_1<T>;
+    splice(start: int, deleteCount?: Nullable<System_Internal.Int32>, ...items: T[]): JSArray_1<T>;
+    toArray(): T[];
+    toList(): List<T>;
+    toLocaleString(): string;
+    toReversed(): JSArray_1<T>;
+    toSorted(compareFunc?: Func<T, T, System_Internal.Double>): JSArray_1<T>;
+    toSpliced(start: int, deleteCount?: Nullable<System_Internal.Int32>, ...items: T[]): JSArray_1<T>;
+    toString(): string;
+    unshift(item: T): int;
+    unshift(...items: T[]): int;
+    values(): IEnumerable__System_Collections_Generic<T>;
+    with_(index: int, value: T): JSArray_1<T>;
+}
+
+
+export const JSArray_1: {
+    new<T>(): JSArray_1<T>;
+    new<T>(capacity: int): JSArray_1<T>;
+    new<T>(source: T[]): JSArray_1<T>;
+    new<T>(source: List<T>): JSArray_1<T>;
+    new<T>(source: IEnumerable__System_Collections_Generic<T>): JSArray_1<T>;
+    from_<T, TSource, TResult>(iterable: IEnumerable__System_Collections_Generic<TSource>, mapFunc: Func<TSource, System_Internal.Int32, TResult>): JSArray_1<TResult>;
+    from_<T>(iterable: IEnumerable__System_Collections_Generic<T>): JSArray_1<T>;
+    isArray<T>(value: unknown): boolean;
+    of_<T>(...items: T[]): JSArray_1<T>;
+};
+
+
+export type JSArray_1<T> = JSArray_1$instance<T>;
+
+export interface Map_2$instance<K, V> {
+    readonly size: int;
+    clear(): void;
+    delete_(key: K): boolean;
+    entries(): IEnumerable__System_Collections_Generic<ValueTuple<K, V>>;
+    forEach(callback: Action<V, K, Map_2<K, V>>): void;
+    forEach(callback: Action<V, K>): void;
+    forEach(callback: Action<V>): void;
+    get_(key: K): V | undefined;
+    getEnumerator(): IEnumerator<KeyValuePair<K, V>>;
+    has(key: K): boolean;
+    keys(): IEnumerable__System_Collections_Generic<K>;
+    set_(key: K, value: V): Map_2<K, V>;
+    values(): IEnumerable__System_Collections_Generic<V>;
+}
+
+
+export const Map_2: {
+    new<K, V>(): Map_2<K, V>;
+    new<K, V>(entries: IEnumerable__System_Collections_Generic<ValueTuple<K, V>>): Map_2<K, V>;
+};
+
+
+export type Map_2<K, V> = Map_2$instance<K, V>;
+
+export interface RegExp$instance {
+    readonly dotAll: boolean;
+    readonly flags: string;
+    readonly global: boolean;
+    readonly ignoreCase: boolean;
+    lastIndex: int;
+    readonly multiline: boolean;
+    readonly source: string;
+    readonly sticky: boolean;
+    readonly unicode: boolean;
+    exec(str: string): RegExpMatchResult | undefined;
+    test(str: string): boolean;
+    toString(): string;
+}
+
+
+export const RegExp: {
+    new(pattern: string): RegExp;
+    new(pattern: string, flags: string): RegExp;
+};
+
+
+export type RegExp = RegExp$instance;
+
+export interface RegExpMatchResult$instance {
+    readonly groups: (string | undefined)[];
+    readonly index: int;
+    readonly input: string;
+    readonly item: string;
+    readonly length: int;
+    readonly value: string;
+}
+
+
+export const RegExpMatchResult: {
+    new(value: string, index: int, input: string, groups: string[]): RegExpMatchResult;
+};
+
+
+export type RegExpMatchResult = RegExpMatchResult$instance;
+
+export interface Set_1$instance<T> {
+    readonly size: int;
+    add(value: T): Set_1<T>;
+    clear(): void;
+    delete_(value: T): boolean;
+    difference(other: Set_1<T>): Set_1<T>;
+    entries(): IEnumerable__System_Collections_Generic<ValueTuple<T, T>>;
+    forEach(callback: Action<T, T, Set_1<T>>): void;
+    forEach(callback: Action<T, T>): void;
+    forEach(callback: Action<T>): void;
+    getEnumerator(): IEnumerator<T>;
+    has(value: T): boolean;
+    intersection(other: Set_1<T>): Set_1<T>;
+    isDisjointFrom(other: Set_1<T>): boolean;
+    isSubsetOf(other: Set_1<T>): boolean;
+    isSupersetOf(other: Set_1<T>): boolean;
+    keys(): IEnumerable__System_Collections_Generic<T>;
+    symmetricDifference(other: Set_1<T>): Set_1<T>;
+    union(other: Set_1<T>): Set_1<T>;
+    values(): IEnumerable__System_Collections_Generic<T>;
+}
+
+
+export const Set_1: {
+    new<T>(): Set_1<T>;
+    new<T>(values: IEnumerable__System_Collections_Generic<T>): Set_1<T>;
+};
+
+
+export type Set_1<T> = Set_1$instance<T>;
+
+export interface Uint16Array$instance {
+    readonly byteLength: int;
+    item: ushort;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.UInt16>;
+    fill(value: ushort, start?: int, end?: Nullable<System_Internal.Int32>): Uint16Array;
+    getEnumerator(): IEnumerator<System_Internal.UInt16>;
+    includes(value: ushort, fromIndex?: int): boolean;
+    indexOf(value: ushort, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Uint16Array;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.UInt16>, offset?: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Uint16Array;
+    sort(compareFn?: Comparison<System_Internal.UInt16>): Uint16Array;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Uint16Array;
+}
+
+
+export const Uint16Array: {
+    new(length: int): Uint16Array;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.UInt16>): Uint16Array;
+    new(values: ushort[]): Uint16Array;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Uint16Array = Uint16Array$instance;
+
+export interface Uint32Array$instance {
+    readonly byteLength: int;
+    item: uint;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.UInt32>;
+    fill(value: uint, start?: int, end?: Nullable<System_Internal.Int32>): Uint32Array;
+    getEnumerator(): IEnumerator<System_Internal.UInt32>;
+    includes(value: uint, fromIndex?: int): boolean;
+    indexOf(value: uint, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Uint32Array;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.UInt32>, offset?: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Uint32Array;
+    sort(compareFn?: Comparison<System_Internal.UInt32>): Uint32Array;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Uint32Array;
+}
+
+
+export const Uint32Array: {
+    new(length: int): Uint32Array;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.UInt32>): Uint32Array;
+    new(values: uint[]): Uint32Array;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Uint32Array = Uint32Array$instance;
+
+export interface Uint8Array$instance {
+    readonly byteLength: int;
+    item: byte;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.Byte>;
+    fill(value: byte, start?: int, end?: Nullable<System_Internal.Int32>): Uint8Array;
+    getEnumerator(): IEnumerator<System_Internal.Byte>;
+    includes(value: byte, fromIndex?: int): boolean;
+    indexOf(value: byte, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Uint8Array;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.Byte>, offset?: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Uint8Array;
+    sort(compareFn?: Comparison<System_Internal.Byte>): Uint8Array;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Uint8Array;
+}
+
+
+export const Uint8Array: {
+    new(length: int): Uint8Array;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.Byte>): Uint8Array;
+    new(values: byte[]): Uint8Array;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Uint8Array = Uint8Array$instance;
+
+export interface Uint8ClampedArray$instance {
+    readonly byteLength: int;
+    item: byte;
+    readonly length: int;
+    at(index: int): Nullable<System_Internal.Byte>;
+    fill(value: byte, start?: int, end?: Nullable<System_Internal.Int32>): Uint8ClampedArray;
+    getEnumerator(): IEnumerator<System_Internal.Byte>;
+    includes(value: byte, fromIndex?: int): boolean;
+    indexOf(value: byte, fromIndex?: int): int;
+    join(separator?: string): string;
+    reverse(): Uint8ClampedArray;
+    set_(array: IEnumerable__System_Collections_Generic<System_Internal.Byte>, offset?: int): void;
+    setClamped(index: int, value: int): void;
+    slice(begin?: int, end?: Nullable<System_Internal.Int32>): Uint8ClampedArray;
+    sort(compareFn?: Comparison<System_Internal.Byte>): Uint8ClampedArray;
+    subarray(begin?: int, end?: Nullable<System_Internal.Int32>): Uint8ClampedArray;
+}
+
+
+export const Uint8ClampedArray: {
+    new(length: int): Uint8ClampedArray;
+    new(values: IEnumerable__System_Collections_Generic<System_Internal.Byte>): Uint8ClampedArray;
+    new(values: byte[]): Uint8ClampedArray;
+    readonly BYTES_PER_ELEMENT: int;
+};
+
+
+export type Uint8ClampedArray = Uint8ClampedArray$instance;
+
+export interface WeakMap_2$instance<K, V> {
+    delete_(key: K): boolean;
+    get_(key: K): V | undefined;
+    has(key: K): boolean;
+    set_(key: K, value: V): WeakMap_2<K, V>;
+}
+
+
+export const WeakMap_2: {
+    new<K, V>(): WeakMap_2<K, V>;
+};
+
+
+export type WeakMap_2<K, V> = WeakMap_2$instance<K, V>;
+
+export interface WeakSet_1$instance<T> {
+    add(value: T): WeakSet_1<T>;
+    delete_(value: T): boolean;
+    has(value: T): boolean;
+}
+
+
+export const WeakSet_1: {
+    new<T>(): WeakSet_1<T>;
+};
+
+
+export type WeakSet_1<T> = WeakSet_1$instance<T>;
+
+export abstract class console$instance {
+    static assert(condition: boolean, message?: string): void;
+    static clear(): void;
+    static count(label?: string): void;
+    static countReset(label?: string): void;
+    static debug(...data: unknown[]): void;
+    static dir(obj: unknown): void;
+    static dirxml(obj: unknown): void;
+    static error(...data: unknown[]): void;
+    static group(...data: unknown[]): void;
+    static groupCollapsed(...data: unknown[]): void;
+    static groupEnd(): void;
+    static info(...data: unknown[]): void;
+    static log(...data: unknown[]): void;
+    static table(data: unknown): void;
+    static time(label?: string): void;
+    static timeEnd(label?: string): void;
+    static timeLog(label?: string, ...data: unknown[]): void;
+    static trace(...data: unknown[]): void;
+    static warn(...data: unknown[]): void;
+}
+
+
+export type console = console$instance;
+
+export abstract class Globals$instance {
+    static readonly undefined: unknown | undefined;
+    static readonly infinity: double;
+    static readonly naN: double;
+    static boolean_(value: unknown): boolean;
+    static decodeURI(uri: string): string;
+    static decodeURIComponent(component: string): string;
+    static encodeURI(uri: string): string;
+    static encodeURIComponent(component: string): string;
+    static isFinite(value: double): boolean;
+    static isNaN(value: double): boolean;
+    static number_(value: unknown): double;
+    static parseFloat(str: string): double;
+    static parseInt(str: string, radix?: Nullable<System_Internal.Int32>): Nullable<System_Internal.Int64>;
+    static string_(value: unknown): string;
+}
+
+
+export type Globals = Globals$instance;
+
+export abstract class JSON$instance {
+    static parse<T>(text: string): T;
+    static stringify(value: unknown): string;
+}
+
+
+export type JSON = JSON$instance;
+
+export abstract class Math$instance {
+    static readonly E: double;
+    static readonly PI: double;
+    static readonly LN2: double;
+    static readonly LN10: double;
+    static readonly LOG2E: double;
+    static readonly LOG10E: double;
+    static readonly SQRT1_2: double;
+    static readonly SQRT2: double;
+    static abs(x: double): double;
+    static acos(x: double): double;
+    static acosh(x: double): double;
+    static asin(x: double): double;
+    static asinh(x: double): double;
+    static atan(x: double): double;
+    static atan2(y: double, x: double): double;
+    static atanh(x: double): double;
+    static cbrt(x: double): double;
+    static ceil(x: double): long;
+    static clz32(x: int): int;
+    static cos(x: double): double;
+    static cosh(x: double): double;
+    static exp(x: double): double;
+    static expm1(x: double): double;
+    static f16round(x: double): double;
+    static floor(x: double): long;
+    static fround(x: double): double;
+    static hypot(...values: double[]): double;
+    static imul(a: int, b: int): int;
+    static log(x: double): double;
+    static log10(x: double): double;
+    static log1p(x: double): double;
+    static log2(x: double): double;
+    static max(...values: double[]): double;
+    static min(...values: double[]): double;
+    static pow(x: double, y: double): double;
+    static random(): double;
+    static round(x: double): long;
+    static sign(x: double): int;
+    static sin(x: double): double;
+    static sinh(x: double): double;
+    static sqrt(x: double): double;
+    static tan(x: double): double;
+    static tanh(x: double): double;
+    static trunc(x: double): long;
+}
+
+
+export type Math = Math$instance;
+
+export abstract class Number$instance {
+    static readonly MAX_VALUE: double;
+    static readonly MIN_VALUE: double;
+    static readonly MAX_SAFE_INTEGER: double;
+    static readonly MIN_SAFE_INTEGER: double;
+    static readonly POSITIVE_INFINITY: double;
+    static readonly NEGATIVE_INFINITY: double;
+    static readonly naN: double;
+    static readonly EPSILON: double;
+    static isFinite(value: double): boolean;
+    static isInteger(value: double): boolean;
+    static isNaN(value: double): boolean;
+    static isSafeInteger(value: double): boolean;
+    static parseFloat(str: string): double;
+    static parseInt(str: string, radix?: Nullable<System_Internal.Int32>): Nullable<System_Internal.Int64>;
+}
+
+
+export type Number = Number$instance;
+
+export abstract class String$instance {
+    static at(str: string, index: int): string;
+    static charAt(str: string, index: int): string;
+    static charCodeAt(str: string, index: int): int;
+    static codePointAt(str: string, index: int): int;
+    static concat(str: string, ...strings: string[]): string;
+    static endsWith(str: string, searchString: string): boolean;
+    static fromCharCode(...codes: int[]): string;
+    static fromCodePoint(...codePoints: int[]): string;
+    static includes(str: string, searchString: string): boolean;
+    static indexOf(str: string, searchString: string, position?: int): int;
+    static isWellFormed(str: string): boolean;
+    static lastIndexOf(str: string, searchString: string, position?: Nullable<System_Internal.Int32>): int;
+    static length(str: string): int;
+    static localeCompare(str: string, compareString: string): int;
+    static match(str: string, pattern: string): List<System_Internal.String> | undefined;
+    static matchAll(str: string, pattern: string): List<List<System_Internal.String>>;
+    static normalize(str: string, form?: string): string;
+    static padEnd(str: string, targetLength: int, padString?: string): string;
+    static padStart(str: string, targetLength: int, padString?: string): string;
+    static raw(template: List<System_Internal.String>, ...substitutions: unknown[]): string;
+    static repeat(str: string, count: int): string;
+    static replace(str: string, search: string, replacement: string): string;
+    static replaceAll(str: string, search: string, replacement: string): string;
+    static search(str: string, pattern: string): int;
+    static slice(str: string, start: int, end?: Nullable<System_Internal.Int32>): string;
+    static split(str: string, separator: string, limit?: Nullable<System_Internal.Int32>): List<System_Internal.String>;
+    static startsWith(str: string, searchString: string): boolean;
+    static substr(str: string, start: int, length?: Nullable<System_Internal.Int32>): string;
+    static substring(str: string, start: int, end?: Nullable<System_Internal.Int32>): string;
+    static toLocaleLowerCase(str: string): string;
+    static toLocaleUpperCase(str: string): string;
+    static toLowerCase(str: string): string;
+    static toString(str: string): string;
+    static toUpperCase(str: string): string;
+    static toWellFormed(str: string): string;
+    static trim(str: string): string;
+    static trimEnd(str: string): string;
+    static trimLeft(str: string): string;
+    static trimRight(str: string): string;
+    static trimStart(str: string): string;
+    static valueOf(str: string): string;
+}
+
+
+export type String = String$instance;
+
+export abstract class Timers$instance {
+    static clearInterval(id: int): void;
+    static clearTimeout(id: int): void;
+    static setInterval<T>(callback: Action<T>, intervalMs: int, arg: T): int;
+    static setInterval(callback: Action, intervalMs: int): int;
+    static setTimeout<T>(callback: Action<T>, delayMs: int, arg: T): int;
+    static setTimeout(callback: Action, delayMs?: int): int;
+}
+
+
+export type Timers = Timers$instance;
+