@ykdz/template 0.0.41 → 0.1.0-experimental.0

package/node_modules/@typescript/typescript-linux-x64/lib/lib.esnext.temporal.d.ts

@@ -0,0 +1,485 @@
+/*! *****************************************************************************
+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/node_modules/@typescript/typescript-linux-x64/lib/lib.esnext.typedarrays.d.ts

@@ -0,0 +1,90 @@
+/*! *****************************************************************************
+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>;
+}