@fedify/vocab 2.4.1 → 2.4.2-dev.2357

package/dist/mod.d.cts

@@ -101,6 +101,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
@@ -1505,6 +1518,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
@@ -1709,6 +1735,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
@@ -2000,6 +2039,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
@@ -2610,6 +2662,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
@@ -2783,6 +2848,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
@@ -2898,6 +2976,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
@@ -3061,6 +3152,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
@@ -3342,6 +3446,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
@@ -3524,6 +3641,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
@@ -3685,6 +3815,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
@@ -3859,6 +4002,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
@@ -4139,6 +4295,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
@@ -4357,6 +4526,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
@@ -4637,6 +4819,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
@@ -4855,6 +5050,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
@@ -5134,6 +5342,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
@@ -5319,6 +5540,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
@@ -5571,6 +5805,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
@@ -5847,6 +6094,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
@@ -6073,6 +6333,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
@@ -6666,6 +6939,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
@@ -6924,6 +7210,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
@@ -7149,6 +7448,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
@@ -7376,6 +7688,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
@@ -7476,6 +7801,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
@@ -7589,6 +7927,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
@@ -7752,6 +8103,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
@@ -7897,6 +8261,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
@@ -8091,6 +8468,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
@@ -8267,6 +8657,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
@@ -8392,6 +8795,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
@@ -8571,6 +8987,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
@@ -8800,6 +9229,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
@@ -9023,6 +9465,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
@@ -9245,6 +9700,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
@@ -9484,6 +9952,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
@@ -10384,6 +10865,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
@@ -10606,6 +11100,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
@@ -10818,6 +11325,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
@@ -11096,6 +11616,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
@@ -11312,6 +11845,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
@@ -11524,6 +12070,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
@@ -11747,6 +12306,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
@@ -11974,6 +12546,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
@@ -12289,6 +12874,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
@@ -12510,6 +13108,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
@@ -12730,6 +13341,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
@@ -12908,6 +13532,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
@@ -13106,6 +13743,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
@@ -13316,6 +13966,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
@@ -13539,6 +14202,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
@@ -13778,6 +14454,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
@@ -14645,6 +15334,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
@@ -14837,6 +15539,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
@@ -14993,6 +15708,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
@@ -15206,6 +15934,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
@@ -15427,6 +16168,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
@@ -15648,6 +16402,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
@@ -15869,6 +16636,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
@@ -16090,6 +16870,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
@@ -16310,6 +17103,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
@@ -16475,6 +17281,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
@@ -16642,6 +17461,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
@@ -16855,6 +17687,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
@@ -17149,6 +17994,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
@@ -17428,6 +18286,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
@@ -18317,6 +19188,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
@@ -18547,6 +19431,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
@@ -19442,6 +20339,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
@@ -19676,6 +20586,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
@@ -19931,6 +20854,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
@@ -20305,6 +21241,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
@@ -20526,6 +21475,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
@@ -20746,6 +21708,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
@@ -21117,6 +22092,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
@@ -21356,6 +22344,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
@@ -22208,6 +23209,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
@@ -22375,6 +23389,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
@@ -22596,6 +23623,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
@@ -22810,6 +23850,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
@@ -23036,6 +24089,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
@@ -23262,6 +24328,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
@@ -23486,6 +24565,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
@@ -23697,6 +24789,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
@@ -23908,6 +25013,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