strict-ts-lib-v5.2-branded 0.4.0

package/libs/es2017/sharedmemory/index.d.ts

@@ -0,0 +1,392 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.symbol" />
+/// <reference lib="es2015.symbol.wellknown" />
+
+interface SharedArrayBuffer {
+  /**
+   * Read-only. The length of the ArrayBuffer (in bytes).
+   */
+  readonly byteLength: NumberType.TypedArraySize;
+
+  /**
+   * Returns a section of an SharedArrayBuffer.
+   */
+  slice(
+    begin: NumberType.TypedArraySizeArg,
+    end?: NumberType.TypedArraySizeArg,
+  ): SharedArrayBuffer;
+  readonly [Symbol.species]: SharedArrayBuffer;
+  readonly [Symbol.toStringTag]: 'SharedArrayBuffer';
+}
+
+interface SharedArrayBufferConstructor {
+  readonly prototype: SharedArrayBuffer;
+  new (byteLength: NumberType.TypedArraySizeArgNonNegative): SharedArrayBuffer;
+}
+declare const SharedArrayBuffer: SharedArrayBufferConstructor;
+
+interface ArrayBufferTypes {
+  readonly SharedArrayBuffer: SharedArrayBuffer;
+}
+
+interface Atomics {
+  /**
+   * Adds a value to the value at the given position in the array, returning the original value.
+   * Until this atomic operation completes, any other read or write operation against the array
+   * will block.
+   */
+  add(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  add(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  add(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int16,
+  ): import('ts-type-forge').Int16;
+  add(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint16,
+  ): import('ts-type-forge').Uint16;
+  add(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int32,
+  ): import('ts-type-forge').Int32;
+  add(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint32,
+  ): import('ts-type-forge').Uint32;
+
+  /**
+   * Stores the bitwise AND of a value with the value at the given position in the array,
+   * returning the original value. Until this atomic operation completes, any other read or
+   * write operation against the array will block.
+   */
+  and(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  and(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  and(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int16,
+  ): import('ts-type-forge').Int16;
+  and(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint16,
+  ): import('ts-type-forge').Uint16;
+  and(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int32,
+  ): import('ts-type-forge').Int32;
+  and(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint32,
+  ): import('ts-type-forge').Uint32;
+
+  /**
+   * Replaces the value at the given position in the array if the original value equals the given
+   * expected value, returning the original value. Until this atomic operation completes, any
+   * other read or write operation against the array will block.
+   */
+  compareExchange(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+    expectedValue: import('ts-type-forge').Int8,
+    replacementValue: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  compareExchange(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+    expectedValue: import('ts-type-forge').Uint8,
+    replacementValue: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  compareExchange(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+    expectedValue: import('ts-type-forge').Int16,
+    replacementValue: import('ts-type-forge').Int16,
+  ): import('ts-type-forge').Int16;
+  compareExchange(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+    expectedValue: import('ts-type-forge').Uint16,
+    replacementValue: import('ts-type-forge').Uint16,
+  ): import('ts-type-forge').Uint16;
+  compareExchange(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    expectedValue: import('ts-type-forge').Int32,
+    replacementValue: import('ts-type-forge').Int32,
+  ): import('ts-type-forge').Int32;
+  compareExchange(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+    expectedValue: import('ts-type-forge').Uint32,
+    replacementValue: import('ts-type-forge').Uint32,
+  ): import('ts-type-forge').Uint32;
+
+  /**
+   * Replaces the value at the given position in the array, returning the original value. Until
+   * this atomic operation completes, any other read or write operation against the array will
+   * block.
+   */
+  exchange(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  exchange(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  exchange(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int16,
+  ): import('ts-type-forge').Int16;
+  exchange(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint16,
+  ): import('ts-type-forge').Uint16;
+  exchange(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int32,
+  ): import('ts-type-forge').Int32;
+  exchange(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint32,
+  ): import('ts-type-forge').Uint32;
+
+  /**
+   * Returns a value indicating whether high-performance algorithms can use atomic operations
+   * (`true`) or must use locks (`false`) for the given number of bytes-per-element of a typed
+   * array.
+   */
+  isLockFree(size: NumberType.TypedArraySizeArgPositive): boolean;
+
+  /**
+   * Returns the value at the given position in the array. Until this atomic operation completes,
+   * any other read or write operation against the array will block.
+   */
+  load(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+  ): import('ts-type-forge').Int8;
+  load(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+  ): import('ts-type-forge').Uint8;
+  load(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+  ): import('ts-type-forge').Int16;
+  load(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+  ): import('ts-type-forge').Uint16;
+  load(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+  ): import('ts-type-forge').Int32;
+  load(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+  ): import('ts-type-forge').Uint32;
+
+  /**
+   * Stores the bitwise OR of a value with the value at the given position in the array,
+   * returning the original value. Until this atomic operation completes, any other read or write
+   * operation against the array will block.
+   */
+  or(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  or(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  or(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int16,
+  ): import('ts-type-forge').Int16;
+  or(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint16,
+  ): import('ts-type-forge').Uint16;
+  or(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int32,
+  ): import('ts-type-forge').Int32;
+  or(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint32,
+  ): import('ts-type-forge').Uint32;
+
+  /**
+   * Stores a value at the given position in the array, returning the new value. Until this
+   * atomic operation completes, any other read or write operation against the array will block.
+   */
+  store(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  store(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  store(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int16,
+  ): import('ts-type-forge').Int16;
+  store(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint16,
+  ): import('ts-type-forge').Uint16;
+  store(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int32,
+  ): import('ts-type-forge').Int32;
+  store(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint32,
+  ): import('ts-type-forge').Uint32;
+
+  /**
+   * Subtracts a value from the value at the given position in the array, returning the original
+   * value. Until this atomic operation completes, any other read or write operation against the
+   * array will block.
+   */
+  sub(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  sub(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  sub(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int16,
+  ): import('ts-type-forge').Int16;
+  sub(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint16,
+  ): import('ts-type-forge').Uint16;
+  sub(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int32,
+  ): import('ts-type-forge').Int32;
+  sub(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint32,
+  ): import('ts-type-forge').Uint32;
+
+  /**
+   * If the value at the given position in the array is equal to the provided value, the current
+   * agent is put to sleep causing execution to suspend until the timeout expires (returning
+   * `"timed-out"`) or until the agent is awoken (returning `"ok"`); otherwise, returns
+   * `"not-equal"`.
+   */
+  wait(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int32,
+    timeout?: number,
+  ): 'ok' | 'not-equal' | 'timed-out';
+
+  /**
+   * Wakes up sleeping agents that are waiting on the given index of the array, returning the
+   * number of agents that were awoken.
+   * @param typedArray A shared Int32Array.
+   * @param index The position in the typedArray to wake up on.
+   * @param count The number of sleeping agents to notify. Defaults to +Infinity.
+   */
+  notify(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    count?: import('ts-type-forge').SafeUint,
+  ): import('ts-type-forge').SafeUint;
+
+  /**
+   * Stores the bitwise XOR of a value with the value at the given position in the array,
+   * returning the original value. Until this atomic operation completes, any other read or write
+   * operation against the array will block.
+   */
+  xor(
+    typedArray: Int8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int8,
+  ): import('ts-type-forge').Int8;
+  xor(
+    typedArray: Uint8Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint8,
+  ): import('ts-type-forge').Uint8;
+  xor(
+    typedArray: Int16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int16,
+  ): import('ts-type-forge').Int16;
+  xor(
+    typedArray: Uint16Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint16,
+  ): import('ts-type-forge').Uint16;
+  xor(
+    typedArray: Int32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Int32,
+  ): import('ts-type-forge').Int32;
+  xor(
+    typedArray: Uint32Array,
+    index: NumberType.TypedArraySizeArg,
+    value: import('ts-type-forge').Uint32,
+  ): import('ts-type-forge').Uint32;
+
+  readonly [Symbol.toStringTag]: 'Atomics';
+}
+
+declare const Atomics: Atomics;

package/libs/es2017/string/index.d.ts

@@ -0,0 +1,35 @@
+/// <reference no-default-lib="true"/>
+
+interface String {
+  /**
+   * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length.
+   * The padding is applied from the start (left) of the current string.
+   *
+   * @param maxLength The length of the resulting string once the current string has been padded.
+   *        If this parameter is smaller than the current string's length, the current string will be returned as it is.
+   *
+   * @param fillString The string to pad the current string with.
+   *        If this string is too long, it will be truncated and the left-most part will be applied.
+   *        The default value for this parameter is " " (U+0020).
+   */
+  padStart(
+    maxLength: NumberType.StringSizeArgNonNegative,
+    fillString?: string,
+  ): string;
+
+  /**
+   * Pads the current string with a given string (possibly repeated) so that the resulting string reaches a given length.
+   * The padding is applied from the end (right) of the current string.
+   *
+   * @param maxLength The length of the resulting string once the current string has been padded.
+   *        If this parameter is smaller than the current string's length, the current string will be returned as it is.
+   *
+   * @param fillString The string to pad the current string with.
+   *        If this string is too long, it will be truncated and the left-most part will be applied.
+   *        The default value for this parameter is " " (U+0020).
+   */
+  padEnd(
+    maxLength: NumberType.StringSizeArgNonNegative,
+    fillString?: string,
+  ): string;
+}

package/libs/es2017/typedarrays/index.d.ts

@@ -0,0 +1,37 @@
+/// <reference no-default-lib="true"/>
+
+interface Int8ArrayConstructor {
+  new (): Int8Array;
+}
+
+interface Uint8ArrayConstructor {
+  new (): Uint8Array;
+}
+
+interface Uint8ClampedArrayConstructor {
+  new (): Uint8ClampedArray;
+}
+
+interface Int16ArrayConstructor {
+  new (): Int16Array;
+}
+
+interface Uint16ArrayConstructor {
+  new (): Uint16Array;
+}
+
+interface Int32ArrayConstructor {
+  new (): Int32Array;
+}
+
+interface Uint32ArrayConstructor {
+  new (): Uint32Array;
+}
+
+interface Float32ArrayConstructor {
+  new (): Float32Array;
+}
+
+interface Float64ArrayConstructor {
+  new (): Float64Array;
+}

package/libs/es2018/asyncgenerator/index.d.ts

@@ -0,0 +1,69 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2018.asynciterable" />
+
+interface AsyncGenerator<
+  T = unknown,
+  TReturn = any,
+  TNext = unknown,
+> extends AsyncIterator<T, TReturn, TNext> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(
+    ...args: readonly [] | readonly [TNext]
+  ): Promise<IteratorResult<T, TReturn>>;
+  return(
+    value: TReturn | PromiseLike<TReturn>,
+  ): Promise<IteratorResult<T, TReturn>>;
+  throw(e: unknown): Promise<IteratorResult<T, TReturn>>;
+  [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+}
+
+interface AsyncGeneratorFunction {
+  /**
+   * Creates a new AsyncGenerator object.
+   * @param args A list of arguments the function accepts.
+   */
+  new (...args: readonly unknown[]): AsyncGenerator;
+  /**
+   * Creates a new AsyncGenerator object.
+   * @param args A list of arguments the function accepts.
+   */
+  (...args: readonly unknown[]): AsyncGenerator;
+  /**
+   * The length of the arguments.
+   */
+  readonly length: number;
+  /**
+   * Returns the name of the function.
+   */
+  readonly name: string;
+  /**
+   * A reference to the prototype.
+   */
+  readonly prototype: AsyncGenerator;
+}
+
+interface AsyncGeneratorFunctionConstructor {
+  /**
+   * Creates a new AsyncGenerator function.
+   * @param args A list of arguments the function accepts.
+   */
+  new (...args: readonly string[]): AsyncGeneratorFunction;
+  /**
+   * Creates a new AsyncGenerator function.
+   * @param args A list of arguments the function accepts.
+   */
+  (...args: readonly string[]): AsyncGeneratorFunction;
+  /**
+   * The length of the arguments.
+   */
+  readonly length: number;
+  /**
+   * Returns the name of the function.
+   */
+  readonly name: string;
+  /**
+   * A reference to the prototype.
+   */
+  readonly prototype: AsyncGeneratorFunction;
+}

package/libs/es2018/asynciterable/index.d.ts

@@ -0,0 +1,31 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.symbol" />
+/// <reference lib="es2015.iterable" />
+
+interface SymbolConstructor {
+  /**
+   * A method that returns the default async iterator for an object. Called by the semantics of
+   * the for-await-of statement.
+   */
+  readonly asyncIterator: unique symbol;
+}
+
+interface AsyncIterator<T, TReturn = any, TNext = undefined> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(
+    ...args: readonly [] | readonly [TNext]
+  ): Promise<IteratorResult<T, TReturn>>;
+  return?(
+    value?: TReturn | PromiseLike<TReturn>,
+  ): Promise<IteratorResult<T, TReturn>>;
+  throw?(e?: unknown): Promise<IteratorResult<T, TReturn>>;
+}
+
+interface AsyncIterable<T> {
+  [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+interface AsyncIterableIterator<T> extends AsyncIterator<T> {
+  [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

package/libs/es2018/full/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2018" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />

package/libs/es2018/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2017" />
+/// <reference lib="es2018.asynciterable" />
+/// <reference lib="es2018.asyncgenerator" />
+/// <reference lib="es2018.promise" />
+/// <reference lib="es2018.regexp" />
+/// <reference lib="es2018.intl" />

package/libs/es2018/intl/index.d.ts

@@ -0,0 +1,102 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+  // http://cldr.unicode.org/index/cldr-spec/plural-rules#TOC-Determining-Plural-Categories
+  type LDMLPluralRule = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+  type PluralRuleType = 'cardinal' | 'ordinal';
+
+  interface PluralRulesOptions {
+    readonly localeMatcher?: 'lookup' | 'best fit' | undefined;
+    readonly type?: PluralRuleType | undefined;
+    readonly minimumIntegerDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+    readonly minimumFractionDigits?:
+      | import('ts-type-forge').UintRange<0, 21>
+      | undefined;
+    readonly maximumFractionDigits?:
+      | import('ts-type-forge').UintRange<0, 21>
+      | undefined;
+    readonly minimumSignificantDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+    readonly maximumSignificantDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+  }
+
+  interface ResolvedPluralRulesOptions {
+    readonly locale: string;
+    readonly pluralCategories: readonly LDMLPluralRule[];
+    readonly type: PluralRuleType;
+    readonly minimumIntegerDigits: import('ts-type-forge').UintRange<1, 22>;
+    readonly minimumFractionDigits: import('ts-type-forge').UintRange<0, 21>;
+    readonly maximumFractionDigits: import('ts-type-forge').UintRange<0, 21>;
+    readonly minimumSignificantDigits?: import('ts-type-forge').UintRange<
+      1,
+      22
+    >;
+    readonly maximumSignificantDigits?: import('ts-type-forge').UintRange<
+      1,
+      22
+    >;
+  }
+
+  interface PluralRules {
+    resolvedOptions(): ResolvedPluralRulesOptions;
+    select(n: number): LDMLPluralRule;
+  }
+
+  const PluralRules: {
+    new (
+      locales?: string | readonly string[],
+      options?: PluralRulesOptions,
+    ): PluralRules;
+    (
+      locales?: string | readonly string[],
+      options?: PluralRulesOptions,
+    ): PluralRules;
+
+    supportedLocalesOf(
+      locales: string | readonly string[],
+      options?: { readonly localeMatcher?: 'lookup' | 'best fit' },
+    ): readonly string[];
+  };
+
+  // We can only have one definition for 'type' in TypeScript, and so you can learn where the keys come from here:
+  type ES2018NumberFormatPartType =
+    | 'literal'
+    | 'nan'
+    | 'infinity'
+    | 'percent'
+    | 'integer'
+    | 'group'
+    | 'decimal'
+    | 'fraction'
+    | 'plusSign'
+    | 'minusSign'
+    | 'percentSign'
+    | 'currency'
+    | 'code'
+    | 'symbol'
+    | 'name';
+  type ES2020NumberFormatPartType =
+    | 'compact'
+    | 'exponentInteger'
+    | 'exponentMinusSign'
+    | 'exponentSeparator'
+    | 'unit'
+    | 'unknown';
+  type NumberFormatPartTypes =
+    | ES2018NumberFormatPartType
+    | ES2020NumberFormatPartType;
+
+  interface NumberFormatPart {
+    readonly type: NumberFormatPartTypes;
+    readonly value: string;
+  }
+
+  interface NumberFormat {
+    formatToParts(number?: number | bigint): readonly NumberFormatPart[];
+  }
+}