@fedify/vocab-runtime 2.4.0-pr.936.41 → 2.4.1

package/dist/mod.d.cts

@@ -1,5 +1,6 @@
 /// <reference lib="esnext.temporal" />
-import { a as DocumentLoaderOptions, c as getDocumentLoader, d as FetchError, f as GetUserAgentOptions, h as logRequest, i as DocumentLoaderFactoryOptions, l as getRemoteDocument, m as getUserAgent, n as DocumentLoader, o as GetDocumentLoaderOptions, p as createActivityPubRequest, r as DocumentLoaderFactory, s as RemoteDocument, t as AuthenticatedDocumentLoaderFactory, u as CreateRequestOptions } from "./docloader-D2DTRiyA.cjs";
+import { _ as logRequest, a as DocumentLoaderOptions, c as getDocumentLoader, d as withDocumentLoaderTimeout, f as CreateRequestOptions, g as getUserAgent, h as createActivityPubRequest, i as DocumentLoaderFactoryOptions, l as getRemoteDocument, m as GetUserAgentOptions, n as DocumentLoader, o as GetDocumentLoaderOptions, p as FetchError, r as DocumentLoaderFactory, s as RemoteDocument, t as AuthenticatedDocumentLoaderFactory, u as resolveDocumentLoaderTimeout } from "./docloader-BMHljyYb.cjs";
+import { i as PortableObjectVerifierOptions, n as PortableObjectVerification, r as PortableObjectVerifier, t as PortableObjectReferrer } from "./portable-6Aj-7dZJ.cjs";
 import { TracerProvider } from "@opentelemetry/api";
 
 //#region src/contexts.d.ts
@@ -73,9 +74,16 @@ declare function importDidKey(did: string | URL): Promise<CryptoKey>;
 /**
 * Exports an Ed25519 public key as a `did:key` DID.
 *
+* The DID is encoded in base58-btc with the Ed25519 multicodec prefix, e.g.,
+* `did:key:z6Mk...`, as [FEP-ef61] requires for the DIDs of portable
+* objects.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
 * @param key The Ed25519 public key.
 * @returns The `did:key` DID.
-* @throws {TypeError} If the key is invalid or unsupported.
+* @throws {TypeError} If the key is invalid or unsupported, or it is not
+*                     a public key.
 * @since 2.4.0
 */
 declare function exportDidKey(key: CryptoKey): Promise<string>;
@@ -204,6 +212,87 @@ declare function canParseDecimal(value: string): boolean;
 */
 declare function parseDecimal(value: string): Decimal;
 //#endregion
+//#region src/digest.d.ts
+/**
+* A parsed SHA-256 resource digest.
+*
+* @since 2.4.0
+*/
+interface ParsedDigestMultibase {
+  /** The multihash algorithm represented by the digest. */
+  readonly algorithm: "sha2-256";
+  /** The raw 32-byte SHA-256 digest. */
+  readonly digest: Uint8Array;
+}
+/**
+* A parsed simple hashlink.
+*
+* @since 2.4.0
+*/
+interface ParsedHashlink {
+  /** The multibase-encoded multihash carried by the hashlink. */
+  readonly digestMultibase: string;
+}
+/**
+* Computes the SHA-256 digest of a byte sequence and encodes it as a
+* base58-btc multibase multihash suitable for FEP-ef61's
+* `digestMultibase` property.
+*
+* @param bytes The bytes to digest.
+* @returns The base58-btc multibase-encoded SHA-256 multihash.
+* @since 2.4.0
+*/
+declare function computeDigestMultibase(bytes: Uint8Array): Promise<string>;
+/**
+* Parses and validates a SHA-256 `digestMultibase` value.
+*
+* @param value The multibase-encoded multihash to parse.
+* @returns The digest algorithm and raw digest bytes.
+* @throws {TypeError} If the value is malformed or uses an unsupported hash
+*                      algorithm.
+* @since 2.4.0
+*/
+declare function parseDigestMultibase(value: string): ParsedDigestMultibase;
+/**
+* Parses a metadata-free `hl:` hashlink and validates its resource digest.
+*
+* @param value The simple hashlink to parse.
+* @returns The `digestMultibase` value carried by the hashlink.
+* @throws {TypeError} If the hashlink is malformed, contains metadata, or
+*                      carries an invalid or unsupported digest.
+* @since 2.4.0
+*/
+declare function parseHashlink(value: string | URL): ParsedHashlink;
+/**
+* Creates a metadata-free `hl:` hashlink from a `digestMultibase` value.
+*
+* @param digestMultibase The SHA-256 multibase multihash to embed.
+* @returns The simple hashlink.
+* @throws {TypeError} If the digest is malformed or unsupported.
+* @since 2.4.0
+*/
+declare function createHashlink(digestMultibase: string): string;
+/**
+* Verifies that bytes match a SHA-256 `digestMultibase` value.
+*
+* @param bytes The bytes to verify.
+* @param digestMultibase The expected digest.
+* @returns Whether the bytes match the digest.
+* @throws {TypeError} If the digest is malformed or unsupported.
+* @since 2.4.0
+*/
+declare function verifyDigestMultibase(bytes: Uint8Array, digestMultibase: string): Promise<boolean>;
+/**
+* Verifies that bytes match the resource digest in a simple hashlink.
+*
+* @param bytes The bytes to verify.
+* @param hashlink The simple hashlink containing the expected digest.
+* @returns Whether the bytes match the hashlink digest.
+* @throws {TypeError} If the hashlink or digest is malformed or unsupported.
+* @since 2.4.0
+*/
+declare function verifyHashlink(bytes: Uint8Array, hashlink: string | URL): Promise<boolean>;
+//#endregion
 //#region src/langstr.d.ts
 /**
 * A language-tagged string which corresponds to the `rdf:langString` type.
@@ -218,11 +307,81 @@ declare class LanguageString extends String {
   * Constructs a new `LanguageString`.
   * @param value A string value written in the given language.
   * @param language The language of the string.  If a string is given, it will
-  *                 be parsed as a `Intl.Locale` object.
+  *                 be parsed as a `Intl.Locale` object.  Extended language
+  *                 subtags are normalized first, e.g., `zh-yue` is parsed as
+  *                 `yue`.
   */
   constructor(value: string, language: Intl.Locale | string);
 }
 //#endregion
+//#region src/langtag.d.ts
+/**
+* Normalizes a BCP 47 language tag that has an extended language subtag
+* (extlang), such as `zh-yue`, into its canonical form, such as `yue`, as
+* described in [RFC 5646, Section 4.5][1].  `Intl.Locale` rejects extlang
+* tags, so tags should be normalized before being passed to it.
+*
+* Only registered extlangs that follow their registered prefix are removed;
+* any other tag is returned unchanged, so the result still needs to be
+* validated, e.g., by `Intl.Locale`.
+*
+* NOTE: This function is marked as internal in the 2.0.x–2.4.x patch
+* releases.  When merging it into the *main* branch, remove the `@internal`
+* tag, formalize it as a public API (`@since 2.5.0`), and add it to
+* the changelog fragment.
+*
+* [1]: https://www.rfc-editor.org/rfc/rfc5646.html#section-4.5
+*
+* @param tag The BCP 47 language tag to normalize.
+* @returns The normalized language tag.
+* @internal
+*/
+declare function normalizeLanguageTag(tag: string): string;
+//#endregion
+//#region src/portable-media.d.ts
+/** A link or document with an external resource and its integrity digest. */
+interface PortableMedia {
+  readonly href?: URL | null;
+  readonly url?: URL | {
+    readonly href: URL | null;
+    readonly digestMultibase?: string | null;
+  } | null;
+  readonly digestMultibase?: string | null;
+}
+/** Options for {@link fetchPortableMedia}. */
+interface FetchPortableMediaOptions {
+  /** Ordered FEP-ef61 gateway origins used for `hl:` resources. */
+  readonly gateways?: Iterable<string | URL>;
+  /** Expected digest when the first argument is a URL or string. */
+  readonly digestMultibase?: string;
+  /** Maximum decoded response size in bytes.  Defaults to 16 MiB. */
+  readonly maxBytes?: number;
+  /** Whether private network addresses may be fetched.  Defaults to `false`. */
+  readonly allowPrivateAddress?: boolean;
+  /** The HTTP `User-Agent` value or its components. */
+  readonly userAgent?: string | GetUserAgentOptions;
+  /** Cancels the entire retrieval and all gateway attempts. */
+  readonly signal?: AbortSignal;
+  /** Overall timeout in milliseconds.  Defaults to 10 seconds; `null` disables it. */
+  readonly timeout?: number | null;
+  /** Timeout per gateway in milliseconds.  Defaults to 3 seconds. */
+  readonly gatewayTimeout?: number | null;
+}
+/**
+* Fetches a portable object's external media and returns it only after its
+* SHA-256 `digestMultibase` has been verified.  `hl:` resources are tried at
+* the supplied gateways in order.  The result contains verified body bytes;
+* its `Content-Type` is unverified metadata supplied by the server.
+*
+* @param media A Link, Image, Document, or URL with an external resource.
+* @param options Retrieval, integrity, and network policy options.
+* @returns A response containing only verified bytes.
+* @throws {TypeError} If the media reference or digest is invalid.
+* @throws {Error} If no source supplies a matching bounded resource.
+* @since 2.4.0
+*/
+declare function fetchPortableMedia(media: string | URL | PortableMedia, options?: FetchPortableMediaOptions): Promise<Response>;
+//#endregion
 //#region src/multibase/types.d.ts
 type BaseCode = "\x00" | "0" | "7" | "9" | "f" | "F" | "v" | "V" | "t" | "T" | "b" | "B" | "c" | "C" | "h" | "k" | "K" | "z" | "Z" | "m" | "M" | "u" | "U";
 /**
@@ -295,6 +454,12 @@ interface PropertyPreprocessorContext {
   contextLoader?: DocumentLoader;
   /** OpenTelemetry tracer provider for instrumentation. */
   tracerProvider?: TracerProvider;
+  /**
+  * The default FEP-ef61 portable object verifier that objects returned by
+  * the preprocessor should use for their property accessors.
+  * @since 2.4.0
+  */
+  verifyPortableObject?: PortableObjectVerifier;
   /** Base URL for resolving relative references. */
   baseUrl?: URL;
 }
@@ -311,18 +476,66 @@ type PropertyPreprocessor<T = unknown> = (value: Json, context: PropertyPreproce
 //#endregion
 //#region src/url.d.ts
 declare class UrlError extends Error {
-  constructor(message: string);
+  /**
+  * The failure category. Defaults to `"disallowed"`.
+  * `"dns"` includes lookup errors and results with no usable IP addresses.
+  * @since 2.0.29
+  */
+  readonly reason: "dns" | "disallowed";
+  constructor(message: string, options?: {
+    cause?: unknown;
+    reason?: "dns" | "disallowed";
+  });
 }
 /**
-* Parses a JSON-LD `@id` value as an IRI.
+* Parses a JSON-LD `@id` value as an IRI, including FEP-ef61 portable
+* ActivityPub IRIs.  See {@link parseIri} for how IRIs are parsed.
+* @param id The `@id` value.
+* @param base The base IRI to resolve a relative `@id` against.
+* @returns The parsed IRI, or `undefined` if `id` is missing or a blank node
+*          identifier.
+* @throws {TypeError} If `id` is not a valid IRI.
+* @since 2.4.0
 */
 declare function parseJsonLdId(id: string | undefined, base?: string | URL): URL | undefined;
 /**
 * Parses an IRI as a URL, including FEP-ef61 portable ActivityPub IRIs.
+* Portable URI and FEP-ef61 compatible identifier strings whose path contains
+* a `.` or `..` segment, including percent-encoded spellings, throw a
+* `TypeError`: JavaScript `URL` would otherwise identify a different object.
+* This also applies to compatible identifier strings used as relative bases.
+* A `URL` argument may already have lost such segments before this function
+* receives it.
+*
+* Portable IRIs, e.g., `ap://did:key:z6Mk.../actor`, cannot be represented by
+* JavaScript `URL` as they are, so the returned `URL` keeps the DID authority
+* percent-encoded, e.g., `ap+ef61://did%3Akey%3Az6Mk.../actor`.  Use
+* {@link formatIri} to get the canonical string back.
+* @param iri The IRI to parse.
+* @param base The base IRI to resolve a relative IRI against.
+* @returns The parsed IRI.
+* @throws {TypeError} If the IRI is malformed.
+* @since 2.4.0
 */
 declare function parseIri(iri: string | URL, base?: string | URL): URL;
 /**
 * Formats a URL as an IRI, including FEP-ef61 portable ActivityPub IRIs.
+* Portable URI and FEP-ef61 compatible identifier strings with dot segments
+* throw a `TypeError` because their paths cannot be represented by JavaScript
+* `URL` without normalization.
+*
+* Portable IRIs are formatted with the `ap+ef61:` scheme and a decoded DID
+* authority, even if they were parsed from `ap:` IRIs.  FEP-ef61 currently
+* recommends the `ap:` scheme, so a future major version of Fedify may change
+* the scheme this function produces.  Do not compare its results as strings to
+* tell whether two portable IRIs identify the same object; use
+* `arePortableUrisEqual()` instead.
+* @param iri The IRI to format.
+* @returns The formatted IRI.  A string that cannot be parsed as a URL at all
+*          is returned unchanged.
+* @throws {TypeError} If the IRI is a malformed portable IRI or FEP-ef61
+*                     compatible identifier, e.g., one with dot segments.
+* @since 2.4.0
 */
 declare function formatIri(iri: string | URL): string;
 /**
@@ -334,6 +547,12 @@ declare function formatIri(iri: string | URL): string;
 * string, not a `URL` object, because JavaScript `URL` normalizes opaque path
 * segments before Fedify can compare them.
 *
+* The `ap+ef61:` scheme of the result is a choice of Fedify's, whereas
+* FEP-ef61 currently canonicalizes portable URIs with the `ap:` scheme.
+* A future major version of Fedify may change the scheme of the result, so
+* do not persist the result as the only copy of an identifier; keep the
+* original URI, and canonicalize it again when comparing.
+*
 * @param input The raw portable ActivityPub URI string to canonicalize.
 * @returns The canonical portable ActivityPub URI string.
 * @throws {TypeError} If the input is not a valid portable ActivityPub IRI.
@@ -371,18 +590,217 @@ declare function getFe34Origin(input: string | URL): string;
 */
 declare function haveSameFe34Origin(left: string | URL, right: string | URL): boolean;
 /**
-* Checks whether two IRIs have the same origin.
+* Checks whether two IRIs have the same origin.  Unlike comparing
+* `URL.origin`, which is `"null"` for URLs with non-special schemes, this
+* compares FEP-ef61 portable ActivityPub IRIs by their schemes and DIDs, so
+* that `ap:` and `ap+ef61:` IRIs of the same DID with decoded or
+* percent-encoded authorities have the same origin.  Other IRIs with
+* a non-special scheme and a host are compared by their schemes and hosts.
+*
+* This is not an FEP-fe34 origin check: an `ap+ef61:` IRI and the `did:key`
+* verification method of the same DID have different origins here.  Use
+* {@link haveSameFe34Origin} for that.
+* @param left The first IRI.
+* @param right The second IRI.
+* @returns `true` if the IRIs have the same origin.
+* @since 2.4.0
 */
 declare function haveSameIriOrigin(left: URL, right: URL): boolean;
 /**
-* Checks whether the URL is an FEP-ef61 gateway base URI.
+* Checks whether the URL is an FEP-ef61 gateway base URI, i.e., an HTTP(S)
+* URI with no credentials, path, query, or fragment, such as
+* `https://example.com/`.  FEP-ef61 requires every item of a portable actor's
+* `gateways` to be such a URI.  A URI with an empty query or fragment
+* delimiter, such as `https://example.com/?`, is not a gateway base URI.
+*
+* Note that the `URL` class normalizes `https://example.com` to
+* `https://example.com/`, so both are gateway base URIs.
+* @param url The URL to check.
+* @returns `true` if the URL is an FEP-ef61 gateway base URI.
+* @since 2.4.0
 */
 declare function isGatewayUrl(url: URL): boolean;
 /**
-* Parses and validates an FEP-ef61 gateway base URI.
+* Parses and validates an FEP-ef61 gateway base URI, i.e., an HTTP(S) URI with
+* no credentials, path, query, or fragment, such as `https://example.com`.
+* See {@link isGatewayUrl} for the rules.
+* @param url The gateway base URI to parse.
+* @returns The parsed gateway base URI, whose path is `/`.
+* @throws {TypeError} If the URI is malformed, or is not an HTTP(S) base URI
+*                     with no credentials, path, query, or fragment.  In the
+*                     latter case, the message starts with
+*                     `Invalid FEP-ef61 gateway:`.
+* @since 2.4.0
 */
 declare function parseGatewayUrl(url: string): URL;
 /**
+* Converts an [FEP-ef61] compatible identifier into a portable ActivityPub
+* URI.
+*
+* A compatible identifier is an HTTP(S) URL under a gateway's fixed
+* `/.well-known/apgateway/` path, such as
+* `https://server.example/.well-known/apgateway/did:key:z6Mk.../objects/1`.
+* This function removes the gateway part and returns the corresponding
+* portable URI, e.g., `ap+ef61://did:key:z6Mk.../objects/1`, in the same
+* internal `URL` form that {@link parseIri} produces.  The path, query, and
+* fragment are preserved, so the result is a portable URI, not a comparison
+* form; pass its `href` to {@link canonicalizePortableUri} or
+* {@link arePortableUrisEqual} to compare it with other portable URIs.
+*
+* The conversion only reveals the *claimed* portable identifier.  Anyone can
+* publish a compatible identifier for any DID on their own server, so the
+* gateway that served it is neither the object's origin nor authorized to act
+* for the DID.  Callers must still verify the retrieved document's Object
+* Integrity Proof against the DID, as FEP-ef61 requires, and should keep the
+* original URL if they need the gateway as a retrieval hint.
+*
+* Arbitrary gateway paths are not supported.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @param input The URL to convert.
+* @returns The portable ActivityPub URI, or `null` if the input is not an
+*          HTTP(S) URL whose path starts with `/.well-known/apgateway/did:`.
+*          Other gateway routes, such as the gateway discovery endpoint and
+*          hashlink media URLs, also yield `null`.
+* @throws {TypeError} If the input looks like a compatible identifier but is
+*                     malformed, e.g., it has an invalid DID, no object path,
+*                     invalid percent-encoding, credentials, or location
+*                     hints (`@gateway` query parameters, or the legacy
+*                     `gateways` parameter), or its raw string path would
+*                     change during URL parsing.  Already-parsed `URL`
+*                     arguments cannot reveal segments lost by their parser.
+* @since 2.4.0
+*/
+declare function fromCompatibleEf61Id(input: string | URL): URL | null;
+/**
+* Converts a portable ActivityPub URI into an [FEP-ef61] compatible
+* identifier, which is an HTTP(S) URL under the gateway's fixed
+* `/.well-known/apgateway/` path.
+*
+* For example, `ap+ef61://did:key:z6Mk.../objects/1` and
+* `https://server.example` yield
+* `https://server.example/.well-known/apgateway/did:key:z6Mk.../objects/1`.
+* Both `ap:` and `ap+ef61:` URIs with decoded or percent-encoded DID
+* authorities are accepted.  Publishers should use the first gateway in the
+* actor's `gateways` list, as FEP-ef61 requires.
+*
+* The path and fragment are preserved, with characters that are not allowed
+* in HTTP(S) URLs percent-encoded the same way as
+* {@link canonicalizePortableUri} does.  FEP-ef61 location hints (`@gateway`
+* query parameters, and the legacy `gateways` parameter) are removed, since
+* compatible identifiers must not have them; other query parameters are kept
+* in order.
+*
+* Arbitrary gateway paths are not supported.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @param portableId The `ap:` or `ap+ef61:` URI to convert.
+* @param gateway The gateway's HTTP(S) origin, e.g., `https://server.example`.
+* @returns The compatible identifier.
+* @throws {TypeError} If the portable ID is not a valid `ap:` or `ap+ef61:`
+*                     URI, if its path has `.` or `..` segments (which
+*                     HTTP(S) URLs cannot represent without changing the
+*                     identified object), or if the gateway is
+*                     not an HTTP(S) origin with no credentials, path, query,
+*                     or fragment.
+* @since 2.4.0
+*/
+declare function toCompatibleEf61Id(portableId: string | URL, gateway: string | URL): URL;
+/**
+* Returns a copy of an [FEP-ef61] portable ActivityPub URI with `@gateway`
+* location hints for the given gateways, which tell consumers where they can
+* retrieve the object.  Put hints on *references* to portable actors, e.g.,
+* in `actor`, `attributedTo`, `to`, or `cc`, when constructing an object, as
+* FEP-ef61 recommends:
+*
+* ~~~~ typescript
+* withGatewayHints("ap://did:key:z6Mk.../actor", [
+*   "https://server1.example",
+*   "https://server2.example",
+* ]);
+* // ap+ef61://did:key:z6Mk.../actor?@gateway=https%3A%2F%2Fserver1.example&@gateway=https%3A%2F%2Fserver2.example
+* ~~~~
+*
+* Do not put hints on an object's own `id`.  Hints do not change the
+* identity of a portable URI, since FEP-ef61 drops the query when comparing
+* portable URIs, but implementations that do not canonicalize portable URIs
+* would take a hinted ID for another object.  Add hints before signing the
+* object, since its Object Integrity Proof covers its references too.
+*
+* The hints that the URI already has, including the legacy `gateways`
+* parameter, are replaced.  Each gateway becomes a `@gateway` query
+* parameter whose value is its URI-encoded origin, e.g.,
+* `@gateway=https%3A%2F%2Fserver1.example`, in the given order after the
+* other query parameters.  Duplicate gateways are dropped, and an empty list
+* removes the hints as {@link withoutGatewayHints} does.  The other query
+* parameters, their order, and the fragment are kept, but percent-encoding
+* is normalized the same way as {@link canonicalizePortableUri} does it.
+*
+* Fedify follows at most five hints when dereferencing a portable URI
+* (three for the key ID of an HTTP Signature), so list the preferred
+* gateways first; there is no limit on the number of hints added here.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @param portableId The `ap:` or `ap+ef61:` URI.  Pass the raw string rather
+*                   than a `URL` if its path may have `.` or `..` segments,
+*                   because the `URL` class resolves them.
+* @param gateways The gateways, e.g., the `gateways` of the actor that the
+*                 URI refers to.  Each has to be an HTTP(S) origin with no
+*                 credentials, path, query, or fragment.
+* @returns The portable URI with the hints, in the same internal `URL` form
+*          as {@link parseIri} returns.  Use {@link formatIri} to get its
+*          canonical string.
+* @throws {TypeError} If the portable ID is not a valid `ap:` or `ap+ef61:`
+*                     URI, e.g., it is a compatible identifier, which must
+*                     not have location hints; if its path has `.` or `..`
+*                     segments, which the `URL` class cannot represent; or
+*                     if a gateway is invalid.
+* @since 2.4.0
+*/
+declare function withGatewayHints(portableId: string | URL, gateways: Iterable<string | URL>): URL;
+/**
+* Returns a copy of an [FEP-ef61] portable ActivityPub URI without its
+* location hints, i.e., `@gateway` query parameters and the legacy
+* `gateways` parameter.  The other query parameters, their order, and the
+* fragment are kept, but percent-encoding is normalized the same way as
+* {@link canonicalizePortableUri} does it.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @param portableId The `ap:` or `ap+ef61:` URI.  Pass the raw string rather
+*                   than a `URL` if its path may have `.` or `..` segments,
+*                   because the `URL` class resolves them.
+* @returns The portable URI without the hints, in the same internal `URL`
+*          form as {@link parseIri} returns.
+* @throws {TypeError} If the portable ID is not a valid `ap:` or `ap+ef61:`
+*                     URI, or if its path has `.` or `..` segments, which
+*                     the `URL` class cannot represent.
+* @since 2.4.0
+*/
+declare function withoutGatewayHints(portableId: string | URL): URL;
+/**
+* Gets the gateways in the `@gateway` location hints of an [FEP-ef61]
+* portable ActivityPub URI, in order.  Hints that are not valid gateways,
+* i.e., HTTP(S) origins with no credentials, path, query, or fragment, are
+* skipped, and so are duplicates.  The legacy `gateways` parameter is not
+* read.
+*
+* Unlike Fedify's dereferencing, which follows at most five hints, this
+* returns all of them.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @param portableId The `ap:` or `ap+ef61:` URI.
+* @returns The gateways, e.g., `https://server1.example/`.
+* @throws {TypeError} If the portable ID is not a valid `ap:` or `ap+ef61:`
+*                     URI.
+* @since 2.4.0
+*/
+declare function getGatewayHints(portableId: string | URL): URL[];
+/**
 * Validates a URL to prevent SSRF attacks.
 */
 declare function validatePublicUrl(url: string): Promise<void>;
@@ -390,4 +808,4 @@ declare function isValidPublicIPv4Address(address: string): boolean;
 declare function isValidPublicIPv6Address(address: string): boolean;
 declare function expandIPv6Address(address: string): string;
 //#endregion
-export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DidKeyVerificationMethod, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, arePortableUrisEqual, canParseDecimal, canonicalizePortableUri, createActivityPubRequest, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, formatIri, getDocumentLoader, getFe34Origin, getRemoteDocument, getUserAgent, haveSameFe34Origin, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isGatewayUrl, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseDidKeyVerificationMethod, parseGatewayUrl, parseIri, parseJsonLdId, preloadedContexts, validatePublicUrl };
+export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DidKeyVerificationMethod, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type FetchPortableMediaOptions, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type ParsedDigestMultibase, type ParsedHashlink, type PortableMedia, type PortableObjectReferrer, type PortableObjectVerification, type PortableObjectVerifier, type PortableObjectVerifierOptions, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, arePortableUrisEqual, canParseDecimal, canonicalizePortableUri, computeDigestMultibase, createActivityPubRequest, createHashlink, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, fetchPortableMedia, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, getGatewayHints, getRemoteDocument, getUserAgent, haveSameFe34Origin, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isGatewayUrl, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, normalizeLanguageTag, parseDecimal, parseDidKeyVerificationMethod, parseDigestMultibase, parseGatewayUrl, parseHashlink, parseIri, parseJsonLdId, preloadedContexts, resolveDocumentLoaderTimeout, toCompatibleEf61Id, validatePublicUrl, verifyDigestMultibase, verifyHashlink, withDocumentLoaderTimeout, withGatewayHints, withoutGatewayHints };