@fedify/vocab 2.5.0-dev.2364 → 2.5.0-dev.2378

package/dist/mod.d.ts

@@ -102,6 +102,19 @@ declare class Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -1527,6 +1540,19 @@ declare class Emoji extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -1733,6 +1759,19 @@ declare class ChatMessage extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -2026,6 +2065,19 @@ declare class Activity extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -2638,6 +2690,19 @@ declare class EmojiReact extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -2812,6 +2877,19 @@ declare class PropertyValue {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -2927,6 +3005,19 @@ declare class Measure {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -3091,6 +3182,19 @@ declare class AnnounceAuthorization extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -3374,6 +3478,19 @@ declare class AnnounceRequest extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -3557,6 +3674,19 @@ declare class InteractionPolicy {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -3718,6 +3848,19 @@ declare class InteractionRule {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -3893,6 +4036,19 @@ declare class LikeAuthorization extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -4175,6 +4331,19 @@ declare class LikeRequest extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -4395,6 +4564,19 @@ declare class ReplyAuthorization extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -4677,6 +4859,19 @@ declare class ReplyRequest extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -4897,6 +5092,19 @@ declare class QuoteAuthorization extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -5178,6 +5386,19 @@ declare class QuoteRequest extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -5364,6 +5585,19 @@ declare class Translation {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -5617,6 +5851,19 @@ declare class FeatureAuthorization extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -5895,6 +6142,19 @@ declare class FeatureRequest extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -6123,6 +6383,19 @@ declare class Collection extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -6718,6 +6991,19 @@ declare class OrderedCollection extends Collection {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -6978,6 +7264,19 @@ declare class FeaturedCollection extends OrderedCollection {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -7205,6 +7504,19 @@ declare class FeaturedItem extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -7433,6 +7745,19 @@ declare class DidService {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -7533,6 +7858,19 @@ declare class Export extends DidService {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -7646,6 +7984,19 @@ declare class DataIntegrityProof {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -7809,6 +8160,19 @@ declare class CryptographicKey {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -7954,6 +8318,19 @@ declare class Multikey {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -8149,6 +8526,19 @@ declare class Agreement extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -8326,6 +8716,19 @@ declare class Commitment {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -8451,6 +8854,19 @@ declare class Intent {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -8631,6 +9047,19 @@ declare class Proposal extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -8862,6 +9291,19 @@ declare class Accept extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -9087,6 +9529,19 @@ declare class Add extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -9311,6 +9766,19 @@ declare class Announce extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -9553,6 +10021,19 @@ declare class Application extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -10464,6 +10945,19 @@ declare class IntransitiveActivity extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -10688,6 +11182,19 @@ declare class Arrive extends IntransitiveActivity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -10902,6 +11409,19 @@ declare class Article extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -11182,6 +11702,19 @@ declare class Document extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -11400,6 +11933,19 @@ declare class Audio extends Document {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -11614,6 +12160,19 @@ declare class Ignore extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -11839,6 +12398,19 @@ declare class Block extends Ignore {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -12068,6 +12640,19 @@ declare class CollectionPage extends Collection {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -12385,6 +12970,19 @@ declare class Create extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -12608,6 +13206,19 @@ declare class Delete extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -12830,6 +13441,19 @@ declare class Dislike extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -13009,6 +13633,19 @@ declare class Endpoints {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -13208,6 +13845,19 @@ declare class Event extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -13420,6 +14070,19 @@ declare class Flag extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -13645,6 +14308,19 @@ declare class Follow extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -13887,6 +14563,19 @@ declare class Group extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -14765,6 +15454,19 @@ declare class Link {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -14973,6 +15675,19 @@ declare class Hashtag extends Link {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -15131,6 +15846,19 @@ declare class Image extends Document {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -15346,6 +16074,19 @@ declare class Offer extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -15569,6 +16310,19 @@ declare class Invite extends Offer {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -15792,6 +16546,19 @@ declare class Join extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -16015,6 +16782,19 @@ declare class Leave extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -16238,6 +17018,19 @@ declare class Like extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -16460,6 +17253,19 @@ declare class Listen extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -16627,6 +17433,19 @@ declare class Mention extends Link {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -16796,6 +17615,19 @@ declare class Move extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -17011,6 +17843,19 @@ declare class Note extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -17307,6 +18152,19 @@ declare class OrderedCollectionPage extends CollectionPage {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -17589,6 +18447,19 @@ declare class Organization extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -18489,6 +19360,19 @@ declare class Page extends Document {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -18722,6 +19606,19 @@ declare class Person extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -19628,6 +20525,19 @@ declare class Place extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -19864,6 +20774,19 @@ declare class Profile extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -20121,6 +21044,19 @@ declare class Question extends IntransitiveActivity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -20497,6 +21433,19 @@ declare class Read extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -20720,6 +21669,19 @@ declare class Reject extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -20942,6 +21904,19 @@ declare class Relationship extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -21315,6 +22290,19 @@ declare class Remove extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -21557,6 +22545,19 @@ declare class Service extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -22419,6 +23420,19 @@ declare class Source {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -22587,6 +23601,19 @@ declare class TentativeAccept extends Accept {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -22810,6 +23837,19 @@ declare class TentativeReject extends Reject {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -23026,6 +24066,19 @@ declare class Tombstone extends Object$1 {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -23254,6 +24307,19 @@ declare class Travel extends IntransitiveActivity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -23482,6 +24548,19 @@ declare class Undo extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -23708,6 +24787,19 @@ declare class Update extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -23921,6 +25013,19 @@ declare class Video extends Document {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document
@@ -24134,6 +25239,19 @@ declare class View extends Activity {
   /**
   * Clones this instance, optionally updating it with the given values.
   *
+  * This is a shallow copy: property arrays are copied, but nested objects
+  * and URLs are shared with this instance.  Dereferencing accessors can cache
+  * fetched objects in the instance whose accessor is called.  Hydrating a
+  * shared nested object through the clone can affect the original as well,
+  * and can change JSON-LD output when either is embedded in another
+  * object.  Hydrating a top-level property of the clone does not update this
+  * instance's property.
+  *
+  * To resolve properties without sharing nested objects, serialize and
+  * re-parse the instance before hydration rather than using this method.
+  * See the [vocabulary manual](https://fedify.dev/manual/vocab#immutability)
+  * for details, including how cached JSON-LD affects serialization.
+  *
   * A clone never inherits a signed JSON-LD representation retained by
   * `signObject()`: the clone may differ from the document that the proof
   * covers, so embedding the original secured JSON in a parent document