typescript 6.0.3 → 7.0.2

package/lib/lib.esnext.temporal.d.ts

@@ -1,485 +0,0 @@
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABILITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-
-/// <reference lib="es2015.symbol.wellknown" />
-/// <reference lib="es2020.intl" />
-/// <reference lib="es2025.intl" />
-
-declare namespace Temporal {
-    type CalendarLike = PlainDate | PlainDateTime | PlainMonthDay | PlainYearMonth | ZonedDateTime | string;
-    type DurationLike = Duration | DurationLikeObject | string;
-    type InstantLike = Instant | ZonedDateTime | string;
-    type PlainDateLike = PlainDate | ZonedDateTime | PlainDateTime | DateLikeObject | string;
-    type PlainDateTimeLike = PlainDateTime | ZonedDateTime | PlainDate | DateTimeLikeObject | string;
-    type PlainMonthDayLike = PlainMonthDay | DateLikeObject | string;
-    type PlainTimeLike = PlainTime | PlainDateTime | ZonedDateTime | TimeLikeObject | string;
-    type PlainYearMonthLike = PlainYearMonth | YearMonthLikeObject | string;
-    type TimeZoneLike = ZonedDateTime | string;
-    type ZonedDateTimeLike = ZonedDateTime | ZonedDateTimeLikeObject | string;
-
-    type PartialTemporalLike<T extends object> = {
-        [P in Exclude<keyof T, "calendar" | "timeZone">]?: T[P] | undefined;
-    };
-
-    interface DateLikeObject {
-        year?: number | undefined;
-        era?: string | undefined;
-        eraYear?: number | undefined;
-        month?: number | undefined;
-        monthCode?: string | undefined;
-        day: number;
-        calendar?: string | undefined;
-    }
-
-    interface DateTimeLikeObject extends DateLikeObject, TimeLikeObject {}
-
-    interface DurationLikeObject {
-        years?: number | undefined;
-        months?: number | undefined;
-        weeks?: number | undefined;
-        days?: number | undefined;
-        hours?: number | undefined;
-        minutes?: number | undefined;
-        seconds?: number | undefined;
-        milliseconds?: number | undefined;
-        microseconds?: number | undefined;
-        nanoseconds?: number | undefined;
-    }
-
-    interface TimeLikeObject {
-        hour?: number | undefined;
-        minute?: number | undefined;
-        second?: number | undefined;
-        millisecond?: number | undefined;
-        microsecond?: number | undefined;
-        nanosecond?: number | undefined;
-    }
-
-    interface YearMonthLikeObject extends Omit<DateLikeObject, "day"> {}
-
-    interface ZonedDateTimeLikeObject extends DateTimeLikeObject {
-        timeZone: TimeZoneLike;
-        offset?: string | undefined;
-    }
-
-    type DateUnit = "year" | "month" | "week" | "day";
-    type TimeUnit = "hour" | "minute" | "second" | "millisecond" | "microsecond" | "nanosecond";
-    type PluralizeUnit<T extends DateUnit | TimeUnit> =
-        | T
-        | {
-            year: "years";
-            month: "months";
-            week: "weeks";
-            day: "days";
-            hour: "hours";
-            minute: "minutes";
-            second: "seconds";
-            millisecond: "milliseconds";
-            microsecond: "microseconds";
-            nanosecond: "nanoseconds";
-        }[T];
-
-    interface DisambiguationOptions {
-        disambiguation?: "compatible" | "earlier" | "later" | "reject" | undefined;
-    }
-
-    interface OverflowOptions {
-        overflow?: "constrain" | "reject" | undefined;
-    }
-
-    interface TransitionOptions {
-        direction: "next" | "previous";
-    }
-
-    interface RoundingOptions<Units extends DateUnit | TimeUnit> {
-        smallestUnit?: PluralizeUnit<Units> | undefined;
-        roundingIncrement?: number | undefined;
-        roundingMode?: "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven" | undefined;
-    }
-
-    interface RoundingOptionsWithLargestUnit<Units extends DateUnit | TimeUnit> extends RoundingOptions<Units> {
-        largestUnit?: "auto" | PluralizeUnit<Units> | undefined;
-    }
-
-    interface ToStringRoundingOptions<Units extends DateUnit | TimeUnit> extends Pick<RoundingOptions<Units>, "smallestUnit" | "roundingMode"> {}
-
-    interface ToStringRoundingOptionsWithFractionalSeconds<Units extends DateUnit | TimeUnit> extends ToStringRoundingOptions<Units> {
-        fractionalSecondDigits?: "auto" | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
-    }
-
-    namespace Now {
-        function timeZoneId(): string;
-        function instant(): Instant;
-        function plainDateTimeISO(timeZone?: TimeZoneLike): PlainDateTime;
-        function zonedDateTimeISO(timeZone?: TimeZoneLike): ZonedDateTime;
-        function plainDateISO(timeZone?: TimeZoneLike): PlainDate;
-        function plainTimeISO(timeZone?: TimeZoneLike): PlainTime;
-    }
-
-    interface PlainDateToStringOptions {
-        calendarName?: "auto" | "always" | "never" | "critical" | undefined;
-    }
-
-    interface PlainDateToZonedDateTimeOptions {
-        plainTime?: PlainTimeLike | undefined;
-        timeZone: TimeZoneLike;
-    }
-
-    interface PlainDate {
-        readonly calendarId: string;
-        readonly era: string | undefined;
-        readonly eraYear: number | undefined;
-        readonly year: number;
-        readonly month: number;
-        readonly monthCode: string;
-        readonly day: number;
-        readonly dayOfWeek: number;
-        readonly dayOfYear: number;
-        readonly weekOfYear: number | undefined;
-        readonly yearOfWeek: number | undefined;
-        readonly daysInWeek: number;
-        readonly daysInMonth: number;
-        readonly daysInYear: number;
-        readonly monthsInYear: number;
-        readonly inLeapYear: boolean;
-        toPlainYearMonth(): PlainYearMonth;
-        toPlainMonthDay(): PlainMonthDay;
-        add(duration: DurationLike, options?: OverflowOptions): PlainDate;
-        subtract(duration: DurationLike, options?: OverflowOptions): PlainDate;
-        with(dateLike: PartialTemporalLike<DateLikeObject>, options?: OverflowOptions): PlainDate;
-        withCalendar(calendarLike: CalendarLike): PlainDate;
-        until(other: PlainDateLike, options?: RoundingOptionsWithLargestUnit<DateUnit>): Duration;
-        since(other: PlainDateLike, options?: RoundingOptionsWithLargestUnit<DateUnit>): Duration;
-        equals(other: PlainDateLike): boolean;
-        toPlainDateTime(time?: PlainTimeLike): PlainDateTime;
-        toZonedDateTime(timeZone: TimeZoneLike): ZonedDateTime;
-        toZonedDateTime(item: PlainDateToZonedDateTimeOptions): ZonedDateTime;
-        toString(options?: PlainDateToStringOptions): string;
-        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-        toJSON(): string;
-        valueOf(): never;
-        readonly [Symbol.toStringTag]: "Temporal.PlainDate";
-    }
-
-    interface PlainDateConstructor {
-        new (isoYear: number, isoMonth: number, isoDay: number, calendar?: string): PlainDate;
-        readonly prototype: PlainDate;
-        from(item: PlainDateLike, options?: OverflowOptions): PlainDate;
-        compare(one: PlainDateLike, two: PlainDateLike): number;
-    }
-    var PlainDate: PlainDateConstructor;
-
-    interface PlainTimeToStringOptions extends ToStringRoundingOptionsWithFractionalSeconds<Exclude<TimeUnit, "hour">> {}
-
-    interface PlainTime {
-        readonly hour: number;
-        readonly minute: number;
-        readonly second: number;
-        readonly millisecond: number;
-        readonly microsecond: number;
-        readonly nanosecond: number;
-        add(duration: DurationLike): PlainTime;
-        subtract(duration: DurationLike): PlainTime;
-        with(timeLike: PartialTemporalLike<TimeLikeObject>, options?: OverflowOptions): PlainTime;
-        until(other: PlainTimeLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
-        since(other: PlainTimeLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
-        equals(other: PlainTimeLike): boolean;
-        round(roundTo: PluralizeUnit<TimeUnit>): PlainTime;
-        round(roundTo: RoundingOptions<TimeUnit>): PlainTime;
-        toString(options?: PlainTimeToStringOptions): string;
-        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-        toJSON(): string;
-        valueOf(): never;
-        readonly [Symbol.toStringTag]: "Temporal.PlainTime";
-    }
-
-    interface PlainTimeConstructor {
-        new (hour?: number, minute?: number, second?: number, millisecond?: number, microsecond?: number, nanosecond?: number): PlainTime;
-        readonly prototype: PlainTime;
-        from(item: PlainTimeLike, options?: OverflowOptions): PlainTime;
-        compare(one: PlainTimeLike, two: PlainTimeLike): number;
-    }
-    var PlainTime: PlainTimeConstructor;
-
-    interface PlainDateTimeToStringOptions extends PlainDateToStringOptions, PlainTimeToStringOptions {}
-
-    interface PlainDateTime {
-        readonly calendarId: string;
-        readonly era: string | undefined;
-        readonly eraYear: number | undefined;
-        readonly year: number;
-        readonly month: number;
-        readonly monthCode: string;
-        readonly day: number;
-        readonly hour: number;
-        readonly minute: number;
-        readonly second: number;
-        readonly millisecond: number;
-        readonly microsecond: number;
-        readonly nanosecond: number;
-        readonly dayOfWeek: number;
-        readonly dayOfYear: number;
-        readonly weekOfYear: number | undefined;
-        readonly yearOfWeek: number | undefined;
-        readonly daysInWeek: number;
-        readonly daysInMonth: number;
-        readonly daysInYear: number;
-        readonly monthsInYear: number;
-        readonly inLeapYear: boolean;
-        with(dateTimeLike: PartialTemporalLike<DateTimeLikeObject>, options?: OverflowOptions): PlainDateTime;
-        withPlainTime(plainTime?: PlainTimeLike): PlainDateTime;
-        withCalendar(calendar: CalendarLike): PlainDateTime;
-        add(duration: DurationLike, options?: OverflowOptions): PlainDateTime;
-        subtract(duration: DurationLike, options?: OverflowOptions): PlainDateTime;
-        until(other: PlainDateTimeLike, options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>): Duration;
-        since(other: PlainDateTimeLike, options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>): Duration;
-        round(roundTo: PluralizeUnit<"day" | TimeUnit>): PlainDateTime;
-        round(roundTo: RoundingOptions<"day" | TimeUnit>): PlainDateTime;
-        equals(other: PlainDateTimeLike): boolean;
-        toString(options?: PlainDateTimeToStringOptions): string;
-        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-        toJSON(): string;
-        valueOf(): never;
-        toZonedDateTime(timeZone: TimeZoneLike, options?: DisambiguationOptions): ZonedDateTime;
-        toPlainDate(): PlainDate;
-        toPlainTime(): PlainTime;
-        readonly [Symbol.toStringTag]: "Temporal.PlainDateTime";
-    }
-
-    interface PlainDateTimeConstructor {
-        new (isoYear: number, isoMonth: number, isoDay: number, hour?: number, minute?: number, second?: number, millisecond?: number, microsecond?: number, nanosecond?: number, calendar?: string): PlainDateTime;
-        readonly prototype: PlainDateTime;
-        from(item: PlainDateTimeLike, options?: OverflowOptions): PlainDateTime;
-        compare(one: PlainDateTimeLike, two: PlainDateTimeLike): number;
-    }
-    var PlainDateTime: PlainDateTimeConstructor;
-
-    interface ZonedDateTimeToStringOptions extends PlainDateTimeToStringOptions {
-        offset?: "auto" | "never" | undefined;
-        timeZoneName?: "auto" | "never" | "critical" | undefined;
-    }
-
-    interface ZonedDateTimeFromOptions extends OverflowOptions, DisambiguationOptions {
-        offset?: "use" | "ignore" | "prefer" | "reject" | undefined;
-    }
-
-    interface ZonedDateTime {
-        readonly calendarId: string;
-        readonly timeZoneId: string;
-        readonly era: string | undefined;
-        readonly eraYear: number | undefined;
-        readonly year: number;
-        readonly month: number;
-        readonly monthCode: string;
-        readonly day: number;
-        readonly hour: number;
-        readonly minute: number;
-        readonly second: number;
-        readonly millisecond: number;
-        readonly microsecond: number;
-        readonly nanosecond: number;
-        readonly epochMilliseconds: number;
-        readonly epochNanoseconds: bigint;
-        readonly dayOfWeek: number;
-        readonly dayOfYear: number;
-        readonly weekOfYear: number | undefined;
-        readonly yearOfWeek: number | undefined;
-        readonly hoursInDay: number;
-        readonly daysInWeek: number;
-        readonly daysInMonth: number;
-        readonly daysInYear: number;
-        readonly monthsInYear: number;
-        readonly inLeapYear: boolean;
-        readonly offsetNanoseconds: number;
-        readonly offset: string;
-        with(zonedDateTimeLike: PartialTemporalLike<ZonedDateTimeLikeObject>, options?: ZonedDateTimeFromOptions): ZonedDateTime;
-        withPlainTime(plainTime?: PlainTimeLike): ZonedDateTime;
-        withTimeZone(timeZone: TimeZoneLike): ZonedDateTime;
-        withCalendar(calendar: CalendarLike): ZonedDateTime;
-        add(duration: DurationLike, options?: OverflowOptions): ZonedDateTime;
-        subtract(duration: DurationLike, options?: OverflowOptions): ZonedDateTime;
-        until(other: ZonedDateTimeLike, options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>): Duration;
-        since(other: ZonedDateTimeLike, options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>): Duration;
-        round(roundTo: PluralizeUnit<"day" | TimeUnit>): ZonedDateTime;
-        round(roundTo: RoundingOptions<"day" | TimeUnit>): ZonedDateTime;
-        equals(other: ZonedDateTimeLike): boolean;
-        toString(options?: ZonedDateTimeToStringOptions): string;
-        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-        toJSON(): string;
-        valueOf(): never;
-        startOfDay(): ZonedDateTime;
-        getTimeZoneTransition(direction: "next" | "previous"): ZonedDateTime | null;
-        getTimeZoneTransition(direction: TransitionOptions): ZonedDateTime | null;
-        toInstant(): Instant;
-        toPlainDate(): PlainDate;
-        toPlainTime(): PlainTime;
-        toPlainDateTime(): PlainDateTime;
-        readonly [Symbol.toStringTag]: "Temporal.ZonedDateTime";
-    }
-
-    interface ZonedDateTimeConstructor {
-        new (epochNanoseconds: bigint, timeZone: string, calendar?: string): ZonedDateTime;
-        readonly prototype: ZonedDateTime;
-        from(item: ZonedDateTimeLike, options?: ZonedDateTimeFromOptions): ZonedDateTime;
-        compare(one: ZonedDateTimeLike, two: ZonedDateTimeLike): number;
-    }
-    var ZonedDateTime: ZonedDateTimeConstructor;
-
-    interface DurationRelativeToOptions {
-        relativeTo?: ZonedDateTimeLike | PlainDateLike | undefined;
-    }
-
-    interface DurationRoundingOptions extends DurationRelativeToOptions, RoundingOptionsWithLargestUnit<DateUnit | TimeUnit> {}
-
-    interface DurationToStringOptions extends ToStringRoundingOptionsWithFractionalSeconds<Exclude<TimeUnit, "hour" | "minute">> {}
-
-    interface DurationTotalOptions extends DurationRelativeToOptions {
-        unit: PluralizeUnit<DateUnit | TimeUnit>;
-    }
-
-    interface Duration {
-        readonly years: number;
-        readonly months: number;
-        readonly weeks: number;
-        readonly days: number;
-        readonly hours: number;
-        readonly minutes: number;
-        readonly seconds: number;
-        readonly milliseconds: number;
-        readonly microseconds: number;
-        readonly nanoseconds: number;
-        readonly sign: number;
-        readonly blank: boolean;
-        with(durationLike: PartialTemporalLike<DurationLikeObject>): Duration;
-        negated(): Duration;
-        abs(): Duration;
-        add(other: DurationLike): Duration;
-        subtract(other: DurationLike): Duration;
-        round(roundTo: PluralizeUnit<"day" | TimeUnit>): Duration;
-        round(roundTo: DurationRoundingOptions): Duration;
-        total(totalOf: PluralizeUnit<"day" | TimeUnit>): number;
-        total(totalOf: DurationTotalOptions): number;
-        toString(options?: DurationToStringOptions): string;
-        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DurationFormatOptions): string;
-        toJSON(): string;
-        valueOf(): never;
-        readonly [Symbol.toStringTag]: "Temporal.Duration";
-    }
-
-    interface DurationConstructor {
-        new (years?: number, months?: number, weeks?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, microseconds?: number, nanoseconds?: number): Duration;
-        readonly prototype: Duration;
-        from(item: DurationLike): Duration;
-        compare(one: DurationLike, two: DurationLike, options?: DurationRelativeToOptions): number;
-    }
-    var Duration: DurationConstructor;
-
-    interface InstantToStringOptions extends PlainTimeToStringOptions {
-        timeZone?: TimeZoneLike | undefined;
-    }
-
-    interface Instant {
-        readonly epochMilliseconds: number;
-        readonly epochNanoseconds: bigint;
-        add(duration: DurationLike): Instant;
-        subtract(duration: DurationLike): Instant;
-        until(other: InstantLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
-        since(other: InstantLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
-        round(roundTo: PluralizeUnit<TimeUnit>): Instant;
-        round(roundTo: RoundingOptions<TimeUnit>): Instant;
-        equals(other: InstantLike): boolean;
-        toString(options?: InstantToStringOptions): string;
-        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-        toJSON(): string;
-        valueOf(): never;
-        toZonedDateTimeISO(timeZone: TimeZoneLike): ZonedDateTime;
-        readonly [Symbol.toStringTag]: "Temporal.Instant";
-    }
-
-    interface InstantConstructor {
-        new (epochNanoseconds: bigint): Instant;
-        readonly prototype: Instant;
-        from(item: InstantLike): Instant;
-        fromEpochMilliseconds(epochMilliseconds: number): Instant;
-        fromEpochNanoseconds(epochNanoseconds: bigint): Instant;
-        compare(one: InstantLike, two: InstantLike): number;
-    }
-    var Instant: InstantConstructor;
-
-    interface PlainYearMonthToPlainDateOptions {
-        day: number;
-    }
-
-    interface PlainYearMonth {
-        readonly calendarId: string;
-        readonly era: string | undefined;
-        readonly eraYear: number | undefined;
-        readonly year: number;
-        readonly month: number;
-        readonly monthCode: string;
-        readonly daysInYear: number;
-        readonly daysInMonth: number;
-        readonly monthsInYear: number;
-        readonly inLeapYear: boolean;
-        with(yearMonthLike: PartialTemporalLike<YearMonthLikeObject>, options?: OverflowOptions): PlainYearMonth;
-        add(duration: DurationLike, options?: OverflowOptions): PlainYearMonth;
-        subtract(duration: DurationLike, options?: OverflowOptions): PlainYearMonth;
-        until(other: PlainYearMonthLike, options?: RoundingOptionsWithLargestUnit<"year" | "month">): Duration;
-        since(other: PlainYearMonthLike, options?: RoundingOptionsWithLargestUnit<"year" | "month">): Duration;
-        equals(other: PlainYearMonthLike): boolean;
-        toString(options?: PlainDateToStringOptions): string;
-        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-        toJSON(): string;
-        valueOf(): never;
-        toPlainDate(item: PlainYearMonthToPlainDateOptions): PlainDate;
-        readonly [Symbol.toStringTag]: "Temporal.PlainYearMonth";
-    }
-
-    interface PlainYearMonthConstructor {
-        new (isoYear: number, isoMonth: number, calendar?: string, referenceISODay?: number): PlainYearMonth;
-        readonly prototype: PlainYearMonth;
-        from(item: PlainYearMonthLike, options?: OverflowOptions): PlainYearMonth;
-        compare(one: PlainYearMonthLike, two: PlainYearMonthLike): number;
-    }
-    var PlainYearMonth: PlainYearMonthConstructor;
-
-    interface PlainMonthDayToPlainDateOptions {
-        era?: string | undefined;
-        eraYear?: number | undefined;
-        year?: number | undefined;
-    }
-
-    interface PlainMonthDay {
-        readonly calendarId: string;
-        readonly monthCode: string;
-        readonly day: number;
-        with(monthDayLike: PartialTemporalLike<DateLikeObject>, options?: OverflowOptions): PlainMonthDay;
-        equals(other: PlainMonthDayLike): boolean;
-        toString(options?: PlainDateToStringOptions): string;
-        toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
-        toJSON(): string;
-        valueOf(): never;
-        toPlainDate(item: PlainMonthDayToPlainDateOptions): PlainDate;
-        readonly [Symbol.toStringTag]: "Temporal.PlainMonthDay";
-    }
-
-    interface PlainMonthDayConstructor {
-        new (isoMonth: number, isoDay: number, calendar?: string, referenceISOYear?: number): PlainMonthDay;
-        readonly prototype: PlainMonthDay;
-        from(item: PlainMonthDayLike, options?: OverflowOptions): PlainMonthDay;
-    }
-    var PlainMonthDay: PlainMonthDayConstructor;
-}

package/lib/lib.esnext.typedarrays.d.ts

@@ -1,90 +0,0 @@
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABILITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-
-interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
-    /**
-     * Converts the `Uint8Array` to a base64-encoded string.
-     * @param options If provided, sets the alphabet and padding behavior used.
-     * @returns A base64-encoded string.
-     */
-    toBase64(
-        options?: {
-            alphabet?: "base64" | "base64url" | undefined;
-            omitPadding?: boolean | undefined;
-        },
-    ): string;
-
-    /**
-     * Sets the `Uint8Array` from a base64-encoded string.
-     * @param string The base64-encoded string.
-     * @param options If provided, specifies the alphabet and handling of the last chunk.
-     * @returns An object containing the number of bytes read and written.
-     * @throws {SyntaxError} If the input string contains characters outside the specified alphabet, or if the last
-     * chunk is inconsistent with the `lastChunkHandling` option.
-     */
-    setFromBase64(
-        string: string,
-        options?: {
-            alphabet?: "base64" | "base64url" | undefined;
-            lastChunkHandling?: "loose" | "strict" | "stop-before-partial" | undefined;
-        },
-    ): {
-        read: number;
-        written: number;
-    };
-
-    /**
-     * Converts the `Uint8Array` to a base16-encoded string.
-     * @returns A base16-encoded string.
-     */
-    toHex(): string;
-
-    /**
-     * Sets the `Uint8Array` from a base16-encoded string.
-     * @param string The base16-encoded string.
-     * @returns An object containing the number of bytes read and written.
-     */
-    setFromHex(string: string): {
-        read: number;
-        written: number;
-    };
-}
-
-interface Uint8ArrayConstructor {
-    /**
-     * Creates a new `Uint8Array` from a base64-encoded string.
-     * @param string The base64-encoded string.
-     * @param options If provided, specifies the alphabet and handling of the last chunk.
-     * @returns A new `Uint8Array` instance.
-     * @throws {SyntaxError} If the input string contains characters outside the specified alphabet, or if the last
-     * chunk is inconsistent with the `lastChunkHandling` option.
-     */
-    fromBase64(
-        string: string,
-        options?: {
-            alphabet?: "base64" | "base64url" | undefined;
-            lastChunkHandling?: "loose" | "strict" | "stop-before-partial" | undefined;
-        },
-    ): Uint8Array<ArrayBuffer>;
-
-    /**
-     * Creates a new `Uint8Array` from a base16-encoded string.
-     * @returns A new `Uint8Array` instance.
-     */
-    fromHex(
-        string: string,
-    ): Uint8Array<ArrayBuffer>;
-}