effect 4.0.0-beta.69 → 4.0.0-beta.70

package/src/Inspectable.ts

@@ -44,6 +44,8 @@ import { redact } from "./Redactable.ts"
 /**
  * Symbol used by Node.js for custom object inspection.
  *
+ * **Details**
+ *
  * This symbol is recognized by Node.js's `util.inspect()` function and the REPL
  * for custom object representation. When an object has a method with this symbol,
  * it will be called to determine how the object should be displayed.
@@ -100,6 +102,8 @@ export type NodeInspectSymbol = typeof NodeInspectSymbol
 /**
  * Interface for objects that can be inspected and provide custom string representations.
  *
+ * **Details**
+ *
  * Objects implementing this interface can control how they appear in debugging contexts,
  * JSON serialization, and Node.js inspection. This is particularly useful for creating
  * custom data types that display meaningful information during development.
@@ -142,8 +146,9 @@ export interface Inspectable {
 }
 
 /**
- * Safely converts a value to a JSON-serializable representation, useful for
- * implementing the `toJSON` method of the {@link Inspectable} interface.
+ * Safely converts a value to a JSON-serializable representation.
+ *
+ * **Details**
  *
  * This function attempts to extract JSON data from objects that implement the
  * `toJSON` method, recursively processes arrays, and handles errors gracefully.
@@ -173,6 +178,8 @@ export const toJson = (input: unknown): unknown => {
 /**
  * Converts an unknown value to a string for diagnostics.
  *
+ * **Details**
+ *
  * Strings are returned unchanged. Objects are formatted as JSON using the
  * provided whitespace setting when possible, and values that cannot be
  * formatted are converted with `String`.
@@ -194,6 +201,8 @@ export const toStringUnknown = (u: unknown, whitespace: number | string | undefi
 /**
  * A base prototype object that implements the {@link Inspectable} interface.
  *
+ * **Details**
+ *
  * This object provides default implementations for the {@link Inspectable} methods.
  * It can be used as a prototype for objects that want to be inspectable,
  * or as a mixin to add inspection capabilities to existing objects.
@@ -236,6 +245,8 @@ export const BaseProto: Inspectable = {
 /**
  * Abstract base class that implements the Inspectable interface.
  *
+ * **Details**
+ *
  * This class provides a convenient way to create inspectable objects by extending it.
  * Subclasses only need to implement the `toJSON()` method, and they automatically
  * get proper `toString()` and Node.js inspection support.
@@ -276,6 +287,8 @@ export abstract class Class {
   /**
    * Returns a JSON representation of this object.
    *
+   * **Details**
+   *
    * Subclasses must implement this method to define how the object
    * should be serialized for debugging and inspection purposes.
    *

package/src/Iterable.ts

@@ -46,9 +46,11 @@ import type { NoInfer } from "./Types.ts"
 /**
  * Creates an iterable by applying a function to consecutive integers.
  *
- * This is a fundamental constructor that generates iterables by calling a function
- * with each index starting from 0. If no length is specified, the iterable will
- * be infinite. This is useful for generating sequences, patterns, or any indexed data.
+ * **Details**
+ *
+ * The function is called with each index starting from `0`. If no length is
+ * specified, the iterable is infinite. This is useful for generating
+ * sequences, patterns, or any indexed data.
  *
  * **Example** (Generating values by index)
  *
@@ -94,6 +96,8 @@ export const makeBy = <A>(f: (i: number) => A, options?: {
 /**
  * Returns an iterable of integers starting at `start` and increasing by `1`.
  *
+ * **Details**
+ *
  * When `end` is provided and `start <= end`, both endpoints are included. When
  * `end` is omitted, the iterable is unbounded. When `start > end`, the
  * iterable contains only `start`.
@@ -122,7 +126,9 @@ export const range = (start: number, end?: number): Iterable<number> => {
 /**
  * Return a `Iterable` containing a value repeated the specified number of times.
  *
- * **Note**. `n` is normalized to an integer >= 1.
+ * **Details**
+ *
+ * `n` is normalized to an integer greater than or equal to `1`.
  *
  * **Example** (Repeating a value)
  *
@@ -140,7 +146,9 @@ export const replicate: {
   /**
    * Return a `Iterable` containing a value repeated the specified number of times.
    *
-   * **Note**. `n` is normalized to an integer >= 1.
+   * **Details**
+   *
+   * `n` is normalized to an integer greater than or equal to `1`.
    *
    * **Example** (Repeating a value)
    *
@@ -158,7 +166,9 @@ export const replicate: {
   /**
    * Return a `Iterable` containing a value repeated the specified number of times.
    *
-   * **Note**. `n` is normalized to an integer >= 1.
+   * **Details**
+   *
+   * `n` is normalized to an integer greater than or equal to `1`.
    *
    * **Example** (Repeating a value)
    *
@@ -179,6 +189,8 @@ export const replicate: {
  * Repeats an iterable `n` times, yielding the full contents of `self` for each
  * repetition.
  *
+ * **Details**
+ *
  * The result is lazy. Each repetition obtains a new iterator from `self`.
  *
  * @category constructors
@@ -189,6 +201,8 @@ export const repeat: {
    * Repeats an iterable `n` times, yielding the full contents of `self` for each
    * repetition.
    *
+   * **Details**
+   *
    * The result is lazy. Each repetition obtains a new iterator from `self`.
    *
    * @category constructors
@@ -199,6 +213,8 @@ export const repeat: {
    * Repeats an iterable `n` times, yielding the full contents of `self` for each
    * repetition.
    *
+   * **Details**
+   *
    * The result is lazy. Each repetition obtains a new iterator from `self`.
    *
    * @category constructors
@@ -210,6 +226,8 @@ export const repeat: {
 /**
  * Repeats an iterable without an upper bound.
  *
+ * **Gotchas**
+ *
  * The returned iterable is lazy and should usually be bounded with `take` or
  * another terminating consumer before materializing it.
  *
@@ -795,7 +813,9 @@ export const headUnsafe = <A>(self: Iterable<A>): A => {
 /**
  * Keep only a max number of elements from the start of an `Iterable`, creating a new `Iterable`.
  *
- * **Note**. `n` is normalized to a non negative integer.
+ * **Details**
+ *
+ * `n` is normalized to a non-negative integer.
  *
  * **Example** (Taking from the start)
  *
@@ -827,7 +847,9 @@ export const take: {
   /**
    * Keep only a max number of elements from the start of an `Iterable`, creating a new `Iterable`.
    *
-   * **Note**. `n` is normalized to a non negative integer.
+   * **Details**
+   *
+   * `n` is normalized to a non-negative integer.
    *
    * **Example** (Taking from the start)
    *
@@ -859,7 +881,9 @@ export const take: {
   /**
    * Keep only a max number of elements from the start of an `Iterable`, creating a new `Iterable`.
    *
-   * **Note**. `n` is normalized to a non negative integer.
+   * **Details**
+   *
+   * `n` is normalized to a non-negative integer.
    *
    * **Example** (Taking from the start)
    *
@@ -1098,7 +1122,9 @@ export const takeWhile: {
 /**
  * Drop a max number of elements from the start of an `Iterable`
  *
- * **Note**. `n` is normalized to a non negative integer.
+ * **Details**
+ *
+ * `n` is normalized to a non-negative integer.
  *
  * **Example** (Dropping from the start)
  *
@@ -1129,7 +1155,9 @@ export const drop: {
   /**
    * Drop a max number of elements from the start of an `Iterable`
    *
-   * **Note**. `n` is normalized to a non negative integer.
+   * **Details**
+   *
+   * `n` is normalized to a non-negative integer.
    *
    * **Example** (Dropping from the start)
    *
@@ -1160,7 +1188,9 @@ export const drop: {
   /**
    * Drop a max number of elements from the start of an `Iterable`
    *
-   * **Note**. `n` is normalized to a non negative integer.
+   * **Details**
+   *
+   * `n` is normalized to a non-negative integer.
    *
    * **Example** (Dropping from the start)
    *
@@ -2235,6 +2265,8 @@ export const containsWith = <A>(isEquivalent: (self: A, that: A) => boolean): {
  * Checks whether an iterable contains a value using Effect's default `Equal`
  * equivalence.
  *
+ * **Details**
+ *
  * Can be called as `contains(self, value)` or curried as
  * `contains(value)(self)`.
  *
@@ -2270,6 +2302,8 @@ export const contains: {
    * Checks whether an iterable contains a value using Effect's default `Equal`
    * equivalence.
    *
+   * **Details**
+   *
    * Can be called as `contains(self, value)` or curried as
    * `contains(value)(self)`.
    *
@@ -2305,6 +2339,8 @@ export const contains: {
    * Checks whether an iterable contains a value using Effect's default `Equal`
    * equivalence.
    *
+   * **Details**
+   *
    * Can be called as `contains(self, value)` or curried as
    * `contains(value)(self)`.
    *
@@ -2683,6 +2719,8 @@ export const group: <A>(self: Iterable<A>) => Iterable<NonEmptyArray<A>> = group
 /**
  * Groups all elements by the string or symbol key returned by `f`.
  *
+ * **Details**
+ *
  * Each property in the returned record contains a non-empty array of elements
  * that produced that key. Unlike `group`, matching elements do not need to be
  * consecutive.
@@ -2732,6 +2770,8 @@ export const groupBy: {
   /**
    * Groups all elements by the string or symbol key returned by `f`.
    *
+   * **Details**
+   *
    * Each property in the returned record contains a non-empty array of elements
    * that produced that key. Unlike `group`, matching elements do not need to be
    * consecutive.
@@ -2781,6 +2821,8 @@ export const groupBy: {
   /**
    * Groups all elements by the string or symbol key returned by `f`.
    *
+   * **Details**
+   *
    * Each property in the returned record contains a non-empty array of elements
    * that produced that key. Unlike `group`, matching elements do not need to be
    * consecutive.
@@ -2857,8 +2899,10 @@ const constEmptyIterator: Iterator<never> = {
 /**
  * Creates an empty iterable that yields no elements.
  *
- * This function returns a reusable empty iterable that can be used as a base case
- * for operations or when you need to represent "no data" in a type-safe way.
+ * **When to use**
+ *
+ * Use this reusable empty iterable as a base case for operations or when you
+ * need to represent "no data" in a type-safe way.
  *
  * **Example** (Creating an empty iterable)
  *
@@ -2884,8 +2928,10 @@ export const empty = <A = never>(): Iterable<A> => constEmpty
 /**
  * Creates an iterable containing a single element.
  *
- * This is useful for wrapping a single value in an iterable context,
- * allowing it to be used with other iterable operations.
+ * **When to use**
+ *
+ * Use this to wrap a single value in an iterable context so it can be combined
+ * with other iterable operations.
  *
  * **Example** (Wrapping a single value)
  *
@@ -2919,6 +2965,8 @@ export const of = <A>(a: A): Iterable<A> => [a]
 /**
  * Transforms each element of an iterable using a function.
  *
+ * **Details**
+ *
  * This is one of the most fundamental operations for working with iterables.
  * It applies a transformation function to each element, creating a new iterable
  * with the transformed values. The operation is lazy - elements are only
@@ -2953,6 +3001,8 @@ export const map: {
   /**
    * Transforms each element of an iterable using a function.
    *
+   * **Details**
+   *
    * This is one of the most fundamental operations for working with iterables.
    * It applies a transformation function to each element, creating a new iterable
    * with the transformed values. The operation is lazy - elements are only
@@ -2987,6 +3037,8 @@ export const map: {
   /**
    * Transforms each element of an iterable using a function.
    *
+   * **Details**
+   *
    * This is one of the most fundamental operations for working with iterables.
    * It applies a transformation function to each element, creating a new iterable
    * with the transformed values. The operation is lazy - elements are only
@@ -3215,6 +3267,8 @@ export const flatten = <A>(self: Iterable<Iterable<A>>): Iterable<A> => ({
 /**
  * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
  *
+ * **Details**
+ *
  * This combines mapping and filtering in a single operation - the function is applied to each element,
  * and only elements that result in `Result.succeed` are included in the result.
  *
@@ -3261,6 +3315,8 @@ export const filterMap: {
   /**
    * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
    *
+   * **Details**
+   *
    * This combines mapping and filtering in a single operation - the function is applied to each element,
    * and only elements that result in `Result.succeed` are included in the result.
    *
@@ -3307,6 +3363,8 @@ export const filterMap: {
   /**
    * Transforms elements of an iterable using a function that returns a `Result`, keeping only successful values.
    *
+   * **Details**
+   *
    * This combines mapping and filtering in a single operation - the function is applied to each element,
    * and only elements that result in `Result.succeed` are included in the result.
    *
@@ -3637,6 +3695,8 @@ export const getSuccesses = <R0, L>(self: Iterable<Result<R0, L>>): Iterable<R0>
 /**
  * Filters an iterable to only include elements that match a predicate.
  *
+ * **Details**
+ *
  * This function creates a new iterable containing only the elements for which
  * the predicate function returns true. Like map, this operation is lazy and
  * elements are only tested when the iterable is consumed.
@@ -3679,6 +3739,8 @@ export const filter: {
   /**
    * Filters an iterable to only include elements that match a predicate.
    *
+   * **Details**
+   *
    * This function creates a new iterable containing only the elements for which
    * the predicate function returns true. Like map, this operation is lazy and
    * elements are only tested when the iterable is consumed.
@@ -3721,6 +3783,8 @@ export const filter: {
   /**
    * Filters an iterable to only include elements that match a predicate.
    *
+   * **Details**
+   *
    * This function creates a new iterable containing only the elements for which
    * the predicate function returns true. Like map, this operation is lazy and
    * elements are only tested when the iterable is consumed.
@@ -3763,6 +3827,8 @@ export const filter: {
   /**
    * Filters an iterable to only include elements that match a predicate.
    *
+   * **Details**
+   *
    * This function creates a new iterable containing only the elements for which
    * the predicate function returns true. Like map, this operation is lazy and
    * elements are only tested when the iterable is consumed.
@@ -3805,6 +3871,8 @@ export const filter: {
   /**
    * Filters an iterable to only include elements that match a predicate.
    *
+   * **Details**
+   *
    * This function creates a new iterable containing only the elements for which
    * the predicate function returns true. Like map, this operation is lazy and
    * elements are only tested when the iterable is consumed.
@@ -3869,8 +3937,10 @@ export const filter: {
 /**
  * Transforms elements using a function that may return null or undefined, filtering out the null/undefined results.
  *
- * This is useful when working with APIs or functions that return nullable values,
- * providing a clean way to filter out null/undefined while transforming.
+ * **When to use**
+ *
+ * Use this when working with APIs or functions that return nullable values,
+ * providing a clean way to filter out null or undefined while transforming.
  *
  * **Example** (FlatMapping nullable results)
  *
@@ -3913,8 +3983,10 @@ export const flatMapNullishOr: {
   /**
    * Transforms elements using a function that may return null or undefined, filtering out the null/undefined results.
    *
-   * This is useful when working with APIs or functions that return nullable values,
-   * providing a clean way to filter out null/undefined while transforming.
+   * **When to use**
+   *
+   * Use this when working with APIs or functions that return nullable values,
+   * providing a clean way to filter out null or undefined while transforming.
    *
    * **Example** (FlatMapping nullable results)
    *
@@ -3957,8 +4029,10 @@ export const flatMapNullishOr: {
   /**
    * Transforms elements using a function that may return null or undefined, filtering out the null/undefined results.
    *
-   * This is useful when working with APIs or functions that return nullable values,
-   * providing a clean way to filter out null/undefined while transforming.
+   * **When to use**
+   *
+   * Use this when working with APIs or functions that return nullable values,
+   * providing a clean way to filter out null or undefined while transforming.
    *
    * **Example** (FlatMapping nullable results)
    *
@@ -4150,6 +4224,8 @@ export const some: {
  * Generates an iterable by repeatedly applying a function that produces the
  * next element and state.
  *
+ * **Details**
+ *
  * This is useful for creating iterables from a generating function that
  * maintains state. The function should return `Option.some([value, nextState])`
  * to continue or `Option.none()` to stop.
@@ -4328,6 +4404,8 @@ export const forEach: {
 /**
  * Reduce an iterable to a single value by applying a function to each element and accumulating the result.
  *
+ * **Details**
+ *
  * This function applies a reducing function against an accumulator and each element
  * of the iterable (from left to right) to reduce it to a single value.
  *
@@ -4378,6 +4456,8 @@ export const reduce: {
   /**
    * Reduce an iterable to a single value by applying a function to each element and accumulating the result.
    *
+   * **Details**
+   *
    * This function applies a reducing function against an accumulator and each element
    * of the iterable (from left to right) to reduce it to a single value.
    *
@@ -4428,6 +4508,8 @@ export const reduce: {
   /**
    * Reduce an iterable to a single value by applying a function to each element and accumulating the result.
    *
+   * **Details**
+   *
    * This function applies a reducing function against an accumulator and each element
    * of the iterable (from left to right) to reduce it to a single value.
    *

package/src/JsonPatch.ts

@@ -60,20 +60,19 @@ import type * as Schema from "./Schema.ts"
 /**
  * A single JSON Patch operation.
  *
- * Represents one transformation step in a JSON Patch document. This is a subset of RFC 6902, restricted to operations that can be applied deterministically without additional context.
+ * **When to use**
  *
- * ## When to use this
+ * Use this type when manually constructing patch operations, accepting patch
+ * operations from callers, or type-checking patch operation structures.
  *
- * - Defining patch operation types in your code
- * - Manually constructing patch operations
- * - Type-checking patch operation structures
+ * **Details**
  *
- * ## Behavior
- *
- * - All fields are readonly; operations are immutable value objects
- * - Paths use JSON Pointer syntax; empty string `""` refers to the root document
- * - The `description` field is optional and can be used for documentation
- * - Operations are discriminated unions based on the `op` field
+ * Represents one transformation step in a JSON Patch document. This is a subset
+ * of RFC 6902, restricted to operations that can be applied deterministically
+ * without additional context. All fields are readonly, paths use JSON Pointer
+ * syntax, and the empty string `""` refers to the root document. Operations are
+ * discriminated by the `op` field, and the optional `description` field can be
+ * used for documentation.
  *
  * **Example** (All operation types)
  *
@@ -98,12 +97,9 @@ import type * as Schema from "./Schema.ts"
  * }
  * ```
  *
- * ## See also
- *
- * - {@link JsonPatch} - Array of operations forming a complete patch
- * - {@link get} - Computes operations automatically from value differences
- * - {@link apply} - Applies operations to transform documents
- *
+ * @see {@link JsonPatch} - Array of operations forming a complete patch
+ * @see {@link get} - Computes operations automatically from value differences
+ * @see {@link apply} - Applies operations to transform documents
  * @category models
  * @since 4.0.0
  */
@@ -111,9 +107,8 @@ export type JsonPatchOperation =
   | {
     readonly op: "add"
     /**
-     * JSON Pointer to the target location.
-     *
-     * For arrays, the last token may be `-` to append.
+     * JSON Pointer to the target location. For arrays, the last token may be `-`
+     * to append.
      */
     readonly path: string
     readonly value: Schema.Json
@@ -136,21 +131,17 @@ export type JsonPatchOperation =
 /**
  * A JSON Patch document (an ordered list of operations).
  *
- * Represents a complete transformation as a sequence of operations. Operations are applied in order, and later operations observe the changes made by earlier ones.
- *
- * ## When to use this
+ * **When to use**
  *
- * - Storing or serializing patch documents
- * - Passing patches between functions or systems
- * - Type-checking patch arrays
- * - Validating patch structure
+ * Use this type when storing, serializing, passing, or validating complete patch
+ * documents.
  *
- * ## Behavior
+ * **Details**
  *
- * - Operations are applied sequentially from first to last
- * - Empty arrays represent no-op patches (return original document)
- * - Later operations see the document state after earlier operations
- * - The array is readonly; individual operations are immutable
+ * Represents a complete transformation as a readonly sequence of immutable
+ * operations. Operations are applied sequentially from first to last, and later
+ * operations observe the document state produced by earlier operations. An empty
+ * array represents a no-op patch and returns the original document.
  *
  * **Example** (Multi-operation patch)
  *
@@ -167,40 +158,36 @@ export type JsonPatchOperation =
  * // { count: 5, items: ["apple"] }
  * ```
  *
- * ## See also
- *
- * - {@link JsonPatchOperation} - Individual operation types
- * - {@link get} - Generates patches from value differences
- * - {@link apply} - Executes patches to transform documents
- *
+ * @see {@link JsonPatchOperation} - Individual operation types
+ * @see {@link get} - Generates patches from value differences
+ * @see {@link apply} - Executes patches to transform documents
  * @category models
  * @since 4.0.0
  */
 export type JsonPatch = ReadonlyArray<JsonPatchOperation>
 
 /**
- * Computes a patch that transforms `oldValue` into `newValue`.
+ * Computes a structural patch that transforms `oldValue` into `newValue`.
  *
- * Generates a structural diff between two JSON values, producing a patch that
- * yields `newValue` when applied to `oldValue`.
+ * **When to use**
  *
- * ## When to use this
+ * Use `get` to compute differences between JSON documents, detect structural
+ * changes, or create deterministic update operations from before and after
+ * states.
  *
- * - Computing differences between JSON documents
- * - Detecting changes in data structures
- * - Generating patches for synchronization or version control
- * - Creating deterministic update operations from before/after states
+ * **Details**
  *
- * ## Behavior
+ * Generates a structural diff between two JSON values, producing a patch that
+ * yields `newValue` when applied to `oldValue`. It returns an empty array when
+ * values are identical, recursively diffs nested structures, emits root
+ * `replace` operations for primitive changes, and processes object keys in
+ * sorted order for stable output. Inputs are not mutated.
+ *
+ * **Gotchas**
  *
- * - Returns an empty array if values are identical (same reference or deep equal)
- * - Does not mutate inputs; returns a new patch array
- * - Primitives (numbers, strings, booleans, null) result in a root `replace` operation
- * - Arrays are compared by index position; no move or copy detection
- * - Objects are compared by key; keys processed in sorted order for stable output
- * - Array removals emitted from highest to lowest index to prevent index shifting
- * - Output is deterministic but not guaranteed to be minimal
- * - Nested structures are recursively diffed
+ * Arrays are compared by index position, with no move or copy detection. Array
+ * removals are emitted from highest to lowest index to prevent index shifting.
+ * The output is deterministic but not guaranteed to be minimal.
  *
  * **Example** (Computing object diff)
  *
@@ -218,11 +205,8 @@ export type JsonPatch = ReadonlyArray<JsonPatchOperation>
  * // ]
  * ```
  *
- * ## See also
- *
- * - {@link apply} - Applies the generated patch to a document
- * - {@link JsonPatchOperation} - The operation types in the patch
- *
+ * @see {@link apply} - Applies the generated patch to a document
+ * @see {@link JsonPatchOperation} - The operation types in the patch
  * @category transforming
  * @since 4.0.0
  */
@@ -290,26 +274,26 @@ export function get(oldValue: Schema.Json, newValue: Schema.Json): JsonPatch {
 }
 
 /**
- * Apply a JSON Patch to a document.
+ * Applies a JSON Patch to a JSON document.
  *
- * Executes a sequence of patch operations on a JSON document, returning a new document with all transformations applied.
+ * **When to use**
  *
- * ## When to use this
+ * Use `apply` to execute patches generated by {@link get}, transform documents
+ * with manually constructed patches, or process patch operations from external
+ * sources.
  *
- * - Applying patches generated by {@link get}
- * - Transforming documents with manually constructed patches
- * - Implementing patch-based update mechanisms
- * - Processing patch operations from external sources
+ * **Details**
  *
- * ## Behavior
+ * Executes patch operations sequentially, so later operations see changes made
+ * by earlier operations. It never mutates the input document; array and object
+ * operations copy the affected containers. An empty patch returns the original
+ * reference, and a root replace (`path: ""`) returns the provided value
+ * directly.
  *
- * - Never mutates the input document; returns a new value
- * - Returns the original reference if patch is empty (no allocation)
- * - Operations applied sequentially; later operations see earlier changes
- * - Root replace (`path: ""`) returns the provided value directly
- * - Throws errors for invalid paths, missing properties, or out-of-bounds array indices
- * - Array operations preserve immutability by copying affected arrays
- * - Object operations preserve immutability by copying affected objects
+ * **Gotchas**
+ *
+ * Invalid paths, missing properties, and out-of-bounds array indices throw
+ * errors.
  *
  * **Example** (Applying a patch)
  *
@@ -326,11 +310,8 @@ export function get(oldValue: Schema.Json, newValue: Schema.Json): JsonPatch {
  * // { items: [1, 2, 3, 4], total: 10 }
  * ```
  *
- * ## See also
- *
- * - {@link get} - Generates patches from value differences
- * - {@link JsonPatchOperation} - The operation types being applied
- *
+ * @see {@link get} - Generates patches from value differences
+ * @see {@link JsonPatchOperation} - The operation types being applied
  * @category transforming
  * @since 4.0.0
  */