DataCreator

Create a data creator.

Create a fresh construction factory for a data class.

A given creation context supplies its options, but not its hooks, which belong to its own operation.

Create a data object through one fixed construction operation.

Validate a payload without casting or construction.

Get validation rules for a payload without running the Validator.

Resolve one deferred automatic lazy property.

Collect data objects through one root operation.

Create typed items through one internal collection operation.

Collect a deferred source without enumerating it.

Create a deferred item collection with one shared operation memo.

Create one nested node without restarting root validation or authorization.

Collect an eager source through one Fill and validation graph.

Create every eager item through one Fill and validation graph.

Batch relations explicitly selected by data properties.

Fill every eager root collection item into one construction state.

Cast and instantiate every eager root collection item.

Run the fixed operation through its selected exit point.

Normalize and fill one data node into the root construction state.

Factory matching consumes caller keys. Every later source-indexed operation receives a list.

Fill one post-factory value through the general construction path.

Create one fixed array node without entering the general Fill path.

The complete node is checked before conversion so a later miss cannot repeat a nested factory, hook, or constructor when the caller enters general Fill.

Fill one node introduced or changed by a validation payload hook.

Write the raw input of constructor parameters that have no public data property.

Write one resolved data node and recursively fill its declared children.

Write one resolved property and recursively fill its declared children.

Apply one root payload-hook stage and reconcile changed selections.

Reconcile changed eager root collection items.

Reconcile one changed assembled data node without replaying prepare hooks.

Match the named factory again for a node beneath a cast whose input a validation hook replaced.

A recorded match holds the earlier input, so it no longer describes the node.

Reconcile one changed property selection.

Reconcile one changed typed data iterable.

Cast and instantiate the node at the current construction path.

Build one automatic lazy property around the ordinary cast path.

Cast one supplied property value.

Cast every item in one declared data iterable.

Cast every item in one declared non-data iterable.

Cast one declared iterable item.

Build the declared property values a user cast receives for the current node.

Values already cast for this node are used as they are, other supplied input stays raw, and absent properties resolve as construction would resolve them. Contextual constructor values are excluded.

Determine if casting a property can reach a user cast that receives the declared values.

Determine if a type accepts a Castable class.

Determine if casts own the construction of a data object or collection property.

Casts receive such a value before any of its objects are built. Under validation it is prepared and validated first, while its named factories and constructors wait until the casts decline it.

Resolve every declared property against the normalized sources.

Resolve one property from the last source that supplies it, with mapped-key precedence inside each source.

Resolve the raw source aligned with one automatic lazy property.

Match one property against one normalized source.

Validated input must use the mapped name, as its rules do. Otherwise, as upstream, the PHP property name is read when the mapped name is missing.

Get the effective input key for one property.

Pass each normalized source through the class's prepareForPipeline() method.

A model source is first projected to its declared properties, as upstream does.

Build the prepare-data hook input from the values property resolution selects.

Later array sources supply undeclared keys. Each declared property's selected value is written under the spelling resolution reads first, so a hook that returns its input changes nothing.

Merge the array sources, with later sources taking precedence.

Merge the keys of every normalized source for unknown-field detection.

Project a non-enumerable normalized source into declared wire keys.

Recursively fill only values absent from the earlier source.

Find the first compatible named object factory.

Create the object with a matching named factory, or list the payloads for ordinary creation.

Caller keys remain meaningful through factory matching and are discarded afterwards.

Find the first compatible named collection factory.

Invoke one matched named factory without method-binding interception.

Invoke one matched named object factory, which must return the requested object.

Resolve the concrete class selected by an abstract property's discriminator.

When rules compile, a missing discriminator or a null morph() result keeps the abstract class, so validation reports the discriminator instead of creation failing.

Materialize a property default only when morph selection requires it.

Determine if an automatic lazy property needs deferred Fill replay.

Determine if a property uses model relation automatic lazy loading.

Select and record the declared type that receives a union value.

The one container type accepting the value receives it. Otherwise a value no declared type accepts selects the data object type, and any other value is kept.

Retain source metadata for one declared paginator property.

Convert an eager iterable to its keyed values.