@fedify/interaction-controls 2.4.0-dev.0

package/dist/mod.d.cts

@@ -0,0 +1,762 @@
+/// <reference lib="esnext.temporal" />
+import { Accept, Activity, Actor, Announce, AnnounceAuthorization, AnnounceRequest, Article, ChatMessage, Create, Delete, FeatureAuthorization, FeatureRequest, FeaturedCollection, Like, LikeAuthorization, LikeRequest, Note, Object as Object$1, Question, QuoteAuthorization, QuoteRequest, Reject, ReplyAuthorization, ReplyRequest } from "@fedify/vocab";
+import { Context } from "@fedify/fedify";
+import { DocumentLoader } from "@fedify/vocab-runtime";
+
+//#region ../../node_modules/.pnpm/temporal-spec@1.0.0/node_modules/temporal-spec/index.d.ts
+/*
+This file was derived from the TypeScript project.
+Original source: https://github.com/microsoft/TypeScript/blob/main/src/lib/esnext.intl.d.ts
+Copyright (c) Microsoft Corporation. Licensed under the Apache License 2.0.
+*/
+/// <reference lib="es2015.symbol.wellknown" />
+/// <reference lib="es2020.intl" />
+/// <reference lib="es2021.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?: globalThis.Intl.LocalesArgument, options?: globalThis.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?: globalThis.Intl.LocalesArgument, options?: globalThis.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?: globalThis.Intl.LocalesArgument, options?: globalThis.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?: globalThis.Intl.LocalesArgument, options?: globalThis.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>;
+  } // Use the host's Intl.DurationFormat options when the consumer includes a
+  // lib that declares Intl.DurationFormat, without forcing this file to
+  // reference es2025.intl for every consumer.
+  type DurationFormatOptions = typeof Intl extends {
+    DurationFormat: {
+      new (locales?: unknown, options?: infer Options): unknown;
+    };
+  } ? NonNullable<Options> : unknown;
+  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<DateUnit | TimeUnit>): number;
+    total(totalOf: DurationTotalOptions): number;
+    toString(options?: DurationToStringOptions): string;
+    toLocaleString(locales?: globalThis.Intl.LocalesArgument, options?: 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?: globalThis.Intl.LocalesArgument, options?: globalThis.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?: globalThis.Intl.LocalesArgument, options?: globalThis.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?: globalThis.Intl.LocalesArgument, options?: globalThis.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;
+}
+declare namespace Intl {
+  type FormattableTemporalObject = Temporal.PlainDate | Temporal.PlainYearMonth | Temporal.PlainMonthDay | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.Instant;
+  interface DateTimeFormat extends Omit<globalThis.Intl.DateTimeFormat, 'format' | 'formatToParts' | 'formatRange' | 'formatRangeToParts'> {
+    format(date?: FormattableTemporalObject | Date | number): string;
+    formatToParts(date?: FormattableTemporalObject | Date | number): globalThis.Intl.DateTimeFormatPart[];
+    formatRange(startDate: FormattableTemporalObject | Date | number, endDate: FormattableTemporalObject | Date | number): string;
+    formatRangeToParts(startDate: FormattableTemporalObject | Date | number, endDate: FormattableTemporalObject | Date | number): globalThis.Intl.DateTimeRangeFormatPart[];
+  }
+}
+//#endregion
+//#region src/types.d.ts
+type InteractionName = "like" | "reply" | "announce" | "quote" | "feature";
+type InteractionPolicyProperty = "canLike" | "canReply" | "canAnnounce" | "canQuote" | "canFeature";
+interface InteractionControl<TRequest extends Activity, TAuthorization extends Object$1, TInteracting extends Object$1, TTarget extends Object$1, TImpoliteSource extends Object$1> {
+  readonly name: InteractionName;
+  readonly policyProperty: InteractionPolicyProperty;
+  readonly requestTypeId: URL;
+  readonly authorizationTypeId: URL;
+  readonly verifyRequest: <TContextData>(context: Context<TContextData>, options: InteractionRequestVerificationOptions<TRequest>) => Promise<InteractionRequestVerification<TRequest, TInteracting, TTarget>>;
+  readonly evaluatePolicy: <TContextData>(context: Context<TContextData>, options: InteractionPolicyEvaluationOptions<TContextData, TTarget>) => Promise<InteractionPolicyDecision>;
+  readonly createRequest: (options: InteractionRequestCreationOptions<TInteracting, TTarget>) => TRequest;
+  readonly createAuthorization: (options: InteractionAuthorizationCreationOptions<TInteracting, TTarget>) => TAuthorization;
+  readonly verifyAuthorization: <TContextData>(context: Context<TContextData>, options: InteractionAuthorizationVerificationOptions<TContextData, TAuthorization, TInteracting, TTarget>) => Promise<InteractionAuthorizationVerification<TAuthorization>>;
+  readonly createAccept: (options: InteractionAcceptOptions<TRequest, TAuthorization, TInteracting, TTarget>) => Accept;
+  readonly createReject: (options: InteractionRejectOptions<TRequest, TInteracting, TTarget>) => Reject;
+  readonly createRevocation: (options: InteractionRevocationCreationOptions<TAuthorization>) => Delete;
+  readonly recognizeImpolite: (source: TImpoliteSource) => RecognizedImpoliteInteraction<TInteracting, TTarget, TImpoliteSource> | null;
+  readonly getInteractionKey: (input: InteractionKeyInput<TInteracting, TTarget>) => InteractionKey;
+  readonly getAuthorizationKey: (input: InteractionAuthorizationKeyInput<TAuthorization>) => InteractionAuthorizationKey;
+}
+interface InteractionRequestVerificationOptions<TRequest extends Activity> {
+  readonly request: TRequest | URL;
+  readonly documentLoader?: DocumentLoader;
+}
+type InteractionRequestVerification<TRequest extends Activity, TInteracting extends Object$1, TTarget extends Object$1> = {
+  readonly verified: true;
+  readonly request: TRequest;
+  readonly requestId: URL;
+  readonly requester: URL;
+  readonly interactingObject: TInteracting;
+  readonly interactingObjectId: URL;
+  readonly interactionTarget: TTarget;
+  readonly interactionTargetId: URL;
+} | {
+  readonly verified: false;
+  readonly failure: InteractionRequestVerificationFailure;
+  readonly request?: TRequest;
+  readonly requestId?: URL;
+};
+type InteractionRequestVerificationFailure = {
+  readonly category: "unverifiable";
+  readonly type: "notDereferenceable";
+  readonly url: URL;
+  readonly cause?: unknown;
+} | {
+  readonly category: "unverifiable";
+  readonly type: "unauthorizedFetchRequired";
+  readonly url: URL;
+} | {
+  readonly category: "unverifiable";
+  readonly type: "invalidJsonLd";
+  readonly cause?: unknown;
+} | {
+  readonly category: "invalid";
+  readonly type: "wrongType";
+  readonly expectedType: URL;
+  readonly actualTypes: readonly URL[];
+} | {
+  readonly category: "invalid";
+  readonly type: "wrongInstrumentType";
+  readonly expectedTypes: readonly URL[];
+  readonly actualTypes: readonly URL[];
+} | {
+  readonly category: "invalid";
+  readonly type: "wrongObjectType";
+  readonly expectedTypes: readonly URL[];
+  readonly actualTypes: readonly URL[];
+} | {
+  readonly category: "invalid";
+  readonly type: "missingId" | "missingActor" | "missingObject" | "missingObjectId" | "missingInstrument" | "missingInstrumentId";
+} | {
+  readonly category: "invalid";
+  readonly type: "idMismatch" | "objectMismatch" | "instrumentMismatch";
+  readonly expected: URL;
+  readonly actual?: URL;
+} | {
+  readonly category: "unauthorized";
+  readonly type: "requesterMismatch";
+  readonly expected: URL;
+  readonly actual?: URL;
+};
+interface InteractionPolicyEvaluationOptions<TContextData, TTarget extends Object$1> {
+  readonly subject: TTarget;
+  readonly requester: URL;
+  readonly documentLoader?: DocumentLoader;
+  readonly matchesApprovalCollection?: MatchesApprovalCollection<TContextData>;
+}
+type MatchesApprovalCollection<TContextData> = (collection: URL, actor: URL, context: Context<TContextData>) => boolean | Promise<boolean>;
+type InteractionPolicyDecision = {
+  readonly result: "automatic";
+  readonly reason: InteractionPolicyMatchReason;
+} | {
+  readonly result: "manual";
+  readonly reason: InteractionPolicyMatchReason;
+} | {
+  readonly result: "denied";
+  readonly reason: InteractionPolicyDenialReason;
+};
+type InteractionPolicyMatchReason = {
+  readonly type: "self";
+} | {
+  readonly type: "default";
+  readonly default: "publicAutomatic";
+} | {
+  readonly type: "public";
+} | {
+  readonly type: "actor";
+  readonly actor: URL;
+} | {
+  readonly type: "collection";
+  readonly collection: URL;
+};
+type InteractionPolicyDenialReason = {
+  readonly type: "missingPolicy";
+} | {
+  readonly type: "missingRule";
+} | {
+  readonly type: "noMatch";
+} | {
+  readonly type: "unverifiableCollection";
+  readonly collection: URL;
+};
+interface InteractionRequestCreationOptions<TInteracting extends Object$1, TTarget extends Object$1> {
+  readonly id: URL;
+  readonly actor: URL;
+  readonly object: TTarget | URL;
+  readonly instrument: TInteracting | URL;
+  readonly to?: URL | readonly URL[];
+  readonly cc?: URL | readonly URL[];
+}
+interface InteractionAuthorizationCreationOptions<TInteracting extends Object$1, TTarget extends Object$1> {
+  readonly id: URL;
+  readonly attributedTo?: URL;
+  readonly interactingObject: TInteracting | URL;
+  readonly interactionTarget: TTarget | URL;
+}
+interface InteractionAuthorizationVerificationOptions<TContextData, TAuthorization extends Object$1, TInteracting extends Object$1, TTarget extends Object$1> {
+  readonly authorization: TAuthorization | URL;
+  readonly interactingObject: TInteracting | URL;
+  readonly interactionTarget: TTarget | URL;
+  readonly attributedTo?: URL;
+  readonly documentLoader?: DocumentLoader;
+  readonly getRevocation?: GetInteractionAuthorizationRevocation<TContextData>;
+  readonly verifyAuthenticity?: (authorization: TAuthorization, context: Context<TContextData>) => boolean | Promise<boolean>;
+}
+type InteractionAuthorizationVerification<TAuthorization extends Object$1> = {
+  readonly verified: true;
+  readonly authorization: TAuthorization;
+  readonly authorizationId: URL;
+} | {
+  readonly verified: false;
+  readonly failure: InteractionAuthorizationVerificationFailure;
+  readonly authorization?: TAuthorization;
+  readonly authorizationId?: URL;
+};
+type InteractionAuthorizationVerificationFailure = {
+  readonly category: "unverifiable";
+  readonly type: "notDereferenceable";
+  readonly url: URL;
+  readonly cause?: unknown;
+} | {
+  readonly category: "unverifiable";
+  readonly type: "unauthorizedFetchRequired";
+  readonly url: URL;
+} | {
+  readonly category: "unverifiable";
+  readonly type: "invalidJsonLd";
+  readonly cause?: unknown;
+} | {
+  readonly category: "unauthorized";
+  readonly type: "wrongType";
+  readonly expectedType: URL;
+  readonly actualTypes: readonly URL[];
+} | {
+  readonly category: "unauthorized";
+  readonly type: "missingId" | "missingObjectId" | "missingTargetId";
+} | {
+  readonly category: "unauthorized";
+  readonly type: "missingAttribution";
+} | {
+  readonly category: "unauthorized";
+  readonly type: "idMismatch" | "objectMismatch" | "targetMismatch";
+  readonly expected: URL;
+  readonly actual?: URL;
+} | {
+  readonly category: "unauthorized";
+  readonly type: "attributionMismatch";
+  readonly expected: URL;
+  readonly actual?: URL;
+} | {
+  readonly category: "unauthorized";
+  readonly type: "originMismatch";
+  readonly expectedOrigin: string;
+  readonly actualOrigin: string;
+} | {
+  readonly category: "unauthorized";
+  readonly type: "notAuthentic";
+  readonly detail?: string;
+  readonly cause?: unknown;
+} | {
+  readonly category: "revoked";
+  readonly type: "deleted";
+  readonly revoker?: URL;
+  readonly revoked?: Temporal.Instant;
+  readonly activity?: Delete;
+};
+type GetInteractionAuthorizationRevocation<TContextData> = (authorizationId: URL, context: Context<TContextData>) => InteractionAuthorizationRevocation | null | Promise<InteractionAuthorizationRevocation | null>;
+interface InteractionAuthorizationRevocation {
+  readonly revoker?: URL;
+  readonly revoked?: Temporal.Instant;
+  readonly activity?: Delete;
+}
+type InteractionAcceptOptions<TRequest extends Activity, TAuthorization extends Object$1, TInteracting extends Object$1, TTarget extends Object$1> = {
+  readonly mode: "polite";
+  readonly id: URL;
+  readonly actor: URL;
+  readonly request: TRequest | URL;
+  readonly authorization: TAuthorization | URL;
+  readonly to: URL | readonly URL[];
+  readonly cc?: URL | readonly URL[];
+} | {
+  readonly mode: "impolite";
+  readonly id: URL;
+  readonly actor: URL;
+  readonly interactingObject: TInteracting | URL;
+  readonly interactionTarget: TTarget | URL;
+  readonly authorization: TAuthorization | URL;
+  readonly to: URL | readonly URL[];
+  readonly cc?: URL | readonly URL[];
+};
+type InteractionRejectOptions<TRequest extends Activity, TInteracting extends Object$1, TTarget extends Object$1> = {
+  readonly mode: "polite";
+  readonly id: URL;
+  readonly actor: URL;
+  readonly request: TRequest | URL;
+  readonly to: URL | readonly URL[];
+  readonly cc?: URL | readonly URL[];
+} | {
+  readonly mode: "impolite";
+  readonly id: URL;
+  readonly actor: URL;
+  readonly interactingObject: TInteracting | URL;
+  readonly interactionTarget: TTarget | URL;
+  readonly to: URL | readonly URL[];
+  readonly cc?: URL | readonly URL[];
+};
+interface InteractionRevocationCreationOptions<TAuthorization extends Object$1> {
+  readonly id: URL;
+  readonly actor: URL;
+  readonly authorization: TAuthorization | URL;
+  readonly to: URL | readonly URL[];
+  readonly cc?: URL | readonly URL[];
+}
+interface RecognizedImpoliteInteraction<TInteracting extends Object$1, TTarget extends Object$1, TImpoliteSource extends Object$1> {
+  readonly requester: URL;
+  readonly interactingObject: TInteracting;
+  readonly interactingObjectId: URL;
+  readonly interactionTarget?: TTarget;
+  readonly interactionTargetId: URL;
+  readonly source: TImpoliteSource;
+  readonly evidence: ImpoliteInteractionEvidence;
+}
+type ImpoliteInteractionEvidence = {
+  readonly type: "activity";
+  readonly activityType: URL;
+} | {
+  readonly type: "property";
+  readonly property: URL;
+} | {
+  readonly type: "linkRel";
+  readonly rel: URL;
+};
+interface InteractionKeyInput<TInteracting extends Object$1, TTarget extends Object$1> {
+  readonly requester: URL;
+  readonly interactingObject: TInteracting | URL;
+  readonly interactionTarget: TTarget | URL;
+}
+interface InteractionKey {
+  readonly interaction: string;
+  readonly requester: URL;
+  readonly interactingObjectId: URL;
+  readonly interactionTargetId: URL;
+}
+interface InteractionAuthorizationKeyInput<TAuthorization extends Object$1> {
+  readonly authorization: TAuthorization | URL;
+}
+interface InteractionAuthorizationKey {
+  readonly interaction: string;
+  readonly authorizationId: URL;
+}
+//#endregion
+//#region src/announce.d.ts
+declare const announceInteraction: InteractionControl<AnnounceRequest, AnnounceAuthorization, Announce, Object$1, Announce>;
+//#endregion
+//#region src/feature.d.ts
+declare const featureInteraction: InteractionControl<FeatureRequest, FeatureAuthorization, FeaturedCollection, Actor, Object$1>;
+//#endregion
+//#region src/key.d.ts
+declare function formatInteractionKey(key: InteractionKey): string;
+declare function formatAuthorizationKey(key: InteractionAuthorizationKey): string;
+//#endregion
+//#region src/like.d.ts
+declare const likeInteraction: InteractionControl<LikeRequest, LikeAuthorization, Like, Object$1, Like>;
+//#endregion
+//#region src/quote.d.ts
+type QuotePost = Note | Article | Question | ChatMessage;
+type QuoteImpoliteSource = Create | QuotePost;
+declare const quoteInteraction: InteractionControl<QuoteRequest, QuoteAuthorization, QuotePost, Object$1, QuoteImpoliteSource>;
+//#endregion
+//#region src/reply.d.ts
+type ReplyPost = Note | Article | Question | ChatMessage;
+type ReplyImpoliteSource = Create | ReplyPost;
+declare const replyInteraction: InteractionControl<ReplyRequest, ReplyAuthorization, ReplyPost, Object$1, ReplyImpoliteSource>;
+//#endregion
+export { GetInteractionAuthorizationRevocation, ImpoliteInteractionEvidence, InteractionAcceptOptions, InteractionAuthorizationCreationOptions, InteractionAuthorizationKey, InteractionAuthorizationKeyInput, InteractionAuthorizationRevocation, InteractionAuthorizationVerification, InteractionAuthorizationVerificationFailure, InteractionAuthorizationVerificationOptions, InteractionControl, InteractionKey, InteractionKeyInput, InteractionName, InteractionPolicyDecision, InteractionPolicyDenialReason, InteractionPolicyEvaluationOptions, InteractionPolicyMatchReason, InteractionPolicyProperty, InteractionRejectOptions, InteractionRequestCreationOptions, InteractionRequestVerification, InteractionRequestVerificationFailure, InteractionRequestVerificationOptions, InteractionRevocationCreationOptions, MatchesApprovalCollection, type QuoteImpoliteSource, type QuotePost, RecognizedImpoliteInteraction, type ReplyImpoliteSource, type ReplyPost, announceInteraction, featureInteraction, formatAuthorizationKey, formatInteractionKey, likeInteraction, quoteInteraction, replyInteraction };