Classes

Set up a content repository

Command controller for tasks related to node migration.

Manage subscriptions (mainly projections)

Take the node types after loading and replace i18n labels with the namespaced parts.

Implementation detail of {NodeTypeEnrichmentService}

An implementation of the ObjectNormalizer that supports Flow proxy classes

Abstract Migration Configuration as a base for different configuration sources.

Interface for Migration Configurations to allow different configuration sources.

Migration Configuration using YAML files.

Migration factory.

The ContentRepository Package

Service for the Node Migration generator

Wrapper for a concrete implementation of the {ContentSubgraphInterface} that builds up an in memory cache while fetching nodes in order to speed up successive calls.

Ensures that the {SubgraphCachePool} is flushed always when content changes. This CatchUpHook is triggered when projections change.

Factory for {FlushSubgraphCachePoolCatchUpHook}, auto-registered in Settings.yaml for GraphProjection

Parent Node ID + Node Name => Child Node

NodeAggregateId -> Node cache

Node ID -> Node Path cache

NOTE: we do NOT directly cache the Parent Node; but only the Parent Node ID; as then, the NodeByNodeIdCache can be used properly

• thus it might increase the cache hit rate to split this apart.

Accessors to in Memory Cache

The CR registry subject provider trait for behavioral tests

For full docs and context, see {RaceTrackerCatchUpHook}

Value object for a list of {TraceEntry} objects, as stored in-order in the Redis stream

Value object for a single trace entry, as stored in Redis.

We had some race conditions in projections We saw some non-deterministic, random errors when running the tests - unluckily only on Linux, not on OSX: On OSX, forking a new subprocess in {SubprocessProjectionCatchUpTrigger} is WAY slower than in Linux; and thus the race conditions which appears if two projector instances of the same class run concurrently won't happen (or are way less likely).

For full docs and context, see {RaceTrackerCatchUpHook}

For full docs and context, see {RaceTrackerCatchUpHook}

Testing projection to assert (via primary key) that each event is only handled once, also in error cases via rollback

Implementation Detail of {ContentRepository::handle}, which does the command dispatching to the different {CommandHandlerInterface} implementation.

Common interface for all Content Repository command handlers

Encapsulates the access to the read model which is used by the command handlers for soft constraints

Contract for a hook that is invoked just before any command is processed via {ContentRepository::handle()}

Collection of {CommandHookInterface} instances, functioning as a delegating command hook implementation

Common interface for all commands of the content repository

The CommandSimulator is used during the publishing process, for partial publishing and workspace rebasing.

Main Entry Point to the system. Encapsulates the full event-sourced Content Repository.

A point in the dimension space with coordinates DimensionName => DimensionValue.

The content dimension zookeeper

The value object describing the weight of a variation edge between subgraphs A and B

A point in the dimension space with coordinates DimensionName => DimensionValue.

A set of points in the dimension space.

The exception to be thrown if two content subgraph variation weights are to be compared that cannot, e.g. if they compose of different dimension combinations

The exception to be thrown if a dimension space point is tried to be used as a specialization of another one but isn't

A dimension space point was not found

The interdimensional variation graph domain model Represents the specialization and generalization mechanism between dimension space points

A node's origin dimension space point. Defines in which point in the dimension space the node originates (= is "at home"). Every node has exactly ONE OriginDimensionSpacePoint, but one or more {DimensionSpacePoint}s where the node is visible.

A set of points in the dimension space, occupied by nodes in a node aggregate

A weighted dimension space point

The configuration based content dimension source

The content dimension domain model

A set of content dimension constraints, indexed by dimension id

Content dimension constraints across multiple dimensions

The content dimension id value object

The content dimension source interface

A content dimension value in a single ContentDimension; e.g. the value "de" in the dimension "language".

The value object describing the specialization depth between two content dimension values

A directed edge connecting two dimension space points declaring them specialization and generalization

A set of content dimension value variation edges

A collection of content dimension values, indexed by dimension identifier

The exception to be thrown if an invalid content dimension id was attempted to be initialized

The exception to be thrown if an invalid content dimension value was attempted to be initialized

The exception to be thrown if an invalid content dimension value specialization depth was tried to be initialized

The exception to be thrown if content dimension values are tried to be initialized empty

The exception to be thrown if an invalid generalization of a content dimension value was tried to be initialized

If you want to publish an event with certain metadata, you can use DecoratedEvent

Common interface for all Content Repository "domain events"

Central authority to convert Content Repository domain events to Event Store EventData and EventType, vice versa.

A set of Content Repository "domain events", part of {EventsToPublish}

Result of {CommandHandlerInterface::handle()} that basically represents an {EventStoreInterface::commit()} call but allows for intercepting and decorating events in {ContentRepository::handle()}

A set of Content Repository "domain events"

Main factory to build a {ContentRepository} object.

Implementation detail of {ContentRepositoryServiceFactoryInterface}

A ContentRepositoryService is an object which is layered on top of a {ContentRepository}, but which interacts with the CR internals in an intricate way.

A single dimension space point with allowed specializations

A set of dimension space points with allowed specializations

This interface is implemented by events which contain ContentStreamId.

This interface is implemented by events which contain NodeAggregateId.

This interface is implemented by events which contain WorkspaceName.

A tuple of succeeding sibling ID to dimension space point

A collection of interdimensional siblings.

This interface is implemented by events which can be published to different workspaces.

Common (marker) interface for all commands that need to be serialized for rebasing to other workspaces

ContentStreamWasCreated signifies the creation of the "ROOT" content streams.

A content stream's event stream name

Add a Dimension Space Point Shine-Through; basically making all content available not just in the source(original) DSP, but also in the target-DimensionSpacePoint.

Move a dimension space point to a new location; basically moving all content to the new dimension space point.

Add a Dimension Space Point Shine-Through; basically making all content available not just in the source(original) DSP, but also in the target-DimensionSpacePoint.

Moved a dimension space point to a new location; basically moving all content to the new dimension space point.

The exception to be thrown if a dimension space point is found in the projection; thus we cannot allow a global operation on it.

Creates a new node aggregate with a new node.

The properties of {CreateNodeAggregateWithNode} are directly serialized; and then this command is called and triggers the actual processing.

An assignment of NodeAggregateIds to NodePaths

A node aggregate with its initial node was created

Disable the given node aggregate in the given content stream in a dimension space point using a given strategy

Enable the given node aggregate in the given content stream in a dimension space point using a given strategy

Add property values for a given node.

Set property values for a given node.

Property values to write, supports arbitrary objects. Will be then converted to {SerializedPropertyValues} inside the events and persisted commands.

"Raw" / Serialized property value as saved in the event log // in projections.

"Raw" property values as saved in the event log // in projections.

When a node property is changed, this event is triggered.

The "Move node aggregate" command

A node aggregate was moved in a content stream

Create a named reference from source to one or multiple destination nodes.

Set property values for a given node.

A single node references to write

Node references to write for a specific reference name

Node references to write

"Raw" / Serialized node reference as saved in the event log // in projections.

A collection of SerializedNodeReferencesForName objects, to be used when creating reference relations.

A collection of all references for a ReferenceName

Named references with optional properties were created from source node to destination node(s)

The "Remove node aggregate" command

All variants in a NodeAggregate have the same (optional) NodeName, which this can be changed here.

The "Change node aggregate type" command

Create a variant of a node in a content stream

A node generalization variant was created

A node specialization variant was created

The exception to be thrown if a dimension space point is already occupied by a node in a node aggregate but is supposed not to be

Create root node aggregate with node command

Change visibility of the root node aggregate. A root node aggregate must be visible in all configured dimensions.

A root node aggregate is now visible in other dimensions. Needed when configured dimensions change.

A root node aggregate and its initial node were created

Provides authorization decisions for the current user, for one Content Repository.

A privilege that is returned by the {AuthProviderInterface}

A simple auth provider that just statically returns the same user id that it was given upon construction time and grants all privileges

Add a {SubtreeTag} to a node aggregate and its descendants

Remove a {SubtreeTag} from a node aggregate and its descendants.

A tag that can be added to Node aggregates that is inherited by all its descendants

A type-safe collection of {SubtreeTag} instances

A {SubtreeTag} was added to a node aggregate and effectively to its descendants

A {SubtreeTag} was removed from a node aggregate and effectively from its descendants Note: This event means that a tag and all inherited instances were removed. If the same tag was added for another Subtree below this aggregate, this will still be set!

Exception to denote that the workspace operation was skipped. No events were published.

Command to create a root workspace.

Create a new workspace, based on an existing baseWorkspace

Event triggered to indicate that a root workspace, i.e. a workspace without base workspace, was created.

Event triggered to indicate that a workspace was created, based on a base workspace.

A workspaces event stream name

Changes the base workspace of a given workspace, identified by $workspaceName.

Delete a workspace

Event triggered when the base workspace of a given workspace has changed.

Event triggered to indicate that the owner of a workspace has changed.

Event triggered to indicate that a workspace got removed.

Event triggered to indicate that a workspace title or description has changed.

Discard a set of nodes in a workspace

Discard a workspace's changes

Publish a set of nodes in a workspace

Publish a workspace

Rebase a workspace

Thrown if the partial publish/discard cannot work because the events cannot be reordered as filtered.

Thrown if the workspace was outdated and an automatic rebase failed due to conflicts.

Simple file-based tracer that writes human-readable trace logs incrementally.

Interface for tracing performance and execution flow in the Content Repository.

Understands collections of objects in the array notation used by Flow.

The property type value object as declared in a NodeType

Performs node type constraint checks against a given set of constraints

A Node Type

Manager for node types

Name of a Node Type; e.g. "Neos.Neos:Content"

A collection of NodeType names

A NodeType postprocessor can be used in order to programmatically change the configuration of a node type for example to provide dynamic properties.

Thrown if a catchup hook fails

This is an api with which you can hook into the catch-up process of a projection.

Internal helper class for running multiple CatchUpHooks inside a Projection update cycle.

An absolute node path, composed of the root node's type and a relative path from there.

This is the MAIN ENTRY POINT for the Content Repository. This class exists only once per Content Repository.

This low level interface gives access to the content graph and workspaces

This is the most important read model of a content repository.

A set of coverage of an origin dimension space point within a node aggregate

Immutable filter DTO for {ContentSubgraphInterface::countAncestorNodes()}

Immutable filter DTO for {ContentSubgraphInterface::countBackReferences()}

Immutable filter DTO for {ContentSubgraphInterface::countChildNodes()}

Immutable filter DTO for {ContentSubgraphInterface::countDescendantNodes()}

Immutable filter DTO for {ContentSubgraphInterface::countReferences()}

Immutable filter DTO for {ContentSubgraphInterface::findAncestorNodes()}

Immutable filter DTO for {ContentSubgraphInterface::findBackReferences()}

Immutable filter DTO for {ContentSubgraphInterface::findChildNodes()}

Immutable filter DTO for {ContentSubgraphInterface::findClosestNode()}

Immutable filter DTO for {ContentSubgraphInterface::findDescendantNodes()}

Immutable filter DTO for {ContentSubgraphInterface::findPrecedingSiblingNodes()}

Immutable filter DTO for {ContentSubgraphInterface::findReferences()}

Immutable filter DTO for {ContentGraphInterface::findRootNodeAggregates()}

Immutable filter DTO for {ContentSubgraphInterface::findSubtree()}

Immutable filter DTO for {ContentSubgraphInterface::findSucceedingSiblingNodes()}

Implementation detail of {NodeTypeCriteria}, to be used inside implementations of ContentSubgraphInterface.

The list of node type criteria needed for various find() operations on the {ContentSubgraphInterface}.

The name of an {OrderingField} this is usually either a node property name or one of the timestamp fields

Pagination filter criteria for the {ContentSubgraphInterface} API

An exception that is thrown if a specified query could not be parsed by the PropertyValueCriteriaParser

Parser token for the PropertyValueCriteriaParser

Binary operation that conjunctively combines two criteria: "prop1 = 'foo' AND prop2 = 'bar'"

Unary operation that negates a criteria: "NOT (prop1 = 'foo' OR prop1 = 'bar')" Or: "prop1 != 'foo'"

Binary operation that disjunctively combines two criteria: "prop1 = 'foo' OR prop2 = 'bar'"

Criteria that matches if a property contains the specified string (case-sensitive) "prop1 *= 'foo'"

Common marker interface for property value filter criteria

Criteria that matches if a property ends with the specified string (case-sensitive) "prop1 $= 'foo'"

Criteria that matches if a property is equal to the specified value "stringProp = 'foo' OR intProp = 123 OR floatProp = 123.45 OR boolProp = true"

Criteria that matches if a property is greater than the specified value "stringProp > 'foo' OR intProp > 123 OR floatProp > 123.45"

Criteria that matches if a property is greater than or equal to the specified value "stringProp >= 'foo' OR intProp >= 123 OR floatProp >= 123.45"

Criteria that matches if a property is less than the specified value "stringProp< < 'foo' OR intProp < 123 OR floatProp < 123.45"

Criteria that matches if a property is less than or equal to the specified value "stringProp <= 'foo' OR intProp <= 123 OR floatProp <= 123.45"

Criteria that matches if a property starts with the specified string (case-sensitive) "prop1 ^= 'foo'"

Performs property checks against a given set of constraints

Parser to turn a string based property value filter into an AST

A search term for use in Filters for the {ContentSubgraphInterface} API.

Performs search term check against the nodes properties

Main read model of the {ContentSubgraphInterface}.

Node aggregate read model. Returned mainly from {ContentGraphInterface}.

An immutable, type-safe collection of NodeAggregate objects

The relative node path is a collection of node names {NodeName}.

A set of {SubtreeTag} instances that are attached to a node.

An immutable, type-safe collection of Node objects

A set of origin of a covered dimension space point within a node aggregate

interface because different impls.

The property collection that provides access to the serialized and deserialized properties of a node

A reference to a given node by a name and with optional reference properties

An immutable, 0-indexed, type-safe collection of Reference objects

Creation and modification timestamps of a node

The visibility constraints define how nodes in the content subgraph are accessed.

Common interface for a Content Repository projection. This API is NOT exposed to the outside world, but is the contract between {ContentRepository} and the individual projections.

(Marker) interface for the state (aka Read Model) of a projection {ProjectionInterface}

Collection of all states (aka read models) of all projections for a Content Repository

The setup status of a projection.

An immutable set of Content Repository projections ({ProjectionInterface}

Set up and manage a content repository

For implementation details of the content stream states and removed state, see {ContentStreamForPruning}.

This model reflects if content streams are currently in use or not. Each content stream is first CREATED or FORKED, and then moves to the IN_USE or REBASE_ERROR states; or is removed directly in case of temporary content streams.

Identifies a given content repository

The status information of a content repository. Examined via {ContentRepositoryMaintainer::status()}

The exception to be thrown if an invalid absolute node path was tried to be initialized

The exception to be thrown if a content stream already exists but is not expected to

The exception to be thrown if a content stream does not exists yet but is expected to

The exception to be thrown if a content stream is closed but was tried to be used

The exception to be thrown if a content stream is not closed but was expected to be

The exception to be thrown if a dimension space point is not yet occupied by a node in a node aggregate but is supposed to be

An "Invalid node type postprocessor" exception

The exception to be thrown if a requested node aggregate does not currently exist

The exception to be thrown if a requested node aggregate does already exist

The exception to be thrown if a node aggregate does currently not cover a given dimension space point but is supposed to be

The exception to be thrown if a node aggregate does currently not cover the given dimension space point set but is supposed to

The exception to be thrown if a node aggregate does currently not occupy a given dimension space point but is supposed to be

The exception to be thrown if a node aggregate was tried to be fetched but is ambiguous

The exception to be thrown if a node aggregate is a descendant of a reference node aggregate but wasn't expected to be

The exception to be thrown if a node aggregate is not a child of a parent node aggregate but was expected to be

The exception to be thrown if a node aggregate is not a sibling of a reference node aggregate but was expected to be

The exception to be thrown if a node aggregate is classified NOT as root but was expected to be

The exception to be thrown if a node aggregate is classified as root but wasn't expected to be

The exception to be thrown if a node aggregate is classified as tethered but wasn't expected to be

The exception to be thrown if a node aggregate is not classified as tethered but was expected to be

An Exception for node configuration errors.

This exception is thrown if sub-node constraints are violated

The exception to be thrown if a node name is already covered by a node in a node aggregate but is supposed not to be

The exception to be thrown if a node type is abstract but was not supposed to be

A "node type is final" exception

The exception to be thrown if a root node is tried to be created with a node type which is not of type root

The exception to be thrown if a non-root node is tried to be created with a node type which is of type root

The exception to be thrown if a given node type was not found

The exception to be thrown if a property was attempted to be set but cannot be

The exception to be thrown if a property type is invalid

The exception to be thrown if a reference was attempted to be set but cannot be

The exception to be thrown if a tethered node aggregate is attempted to be removed

The exception to be thrown if any workspace contains changes but was not supposed to

A factory for UUIDs

This describes a node's read model identity namely:

The NodeAggregateId supersedes the Node Identifier from Neos <= 9.x.

An immutable collection of NodeAggregateIds, indexed by their value

The Node name is the "path part" of the node; i.e. when accessing the node "/foo" via path {NodePath}, the node name is "foo".

Content Stream Read Model

The ContentStreamId is the identifier for a Content Stream, which is a central concept in the Event-Sourced CR introduced with Neos 5.0.

Workspace Read Model

Name of a workspace.

An immutable, type-safe collection of Workspace objects

Note that the SubscriptionStatus might not be actually Detached yet, as for the marking of detached, setup or catchup has to be run.

This is the internal core for the catchup

Thrown if the subscribers could not be catchup without encountering errors.

A collection of the registered subscribers.

A collection of the status of the subscribers.

Provide doctrine DBAL column schema definitions for common types in the content repository to produce consistent columns across projections.

"backReferenceNodes" operation working on Nodes

"backReferences" operation working on Nodes

"children" operation working on ContentRepository nodes. It iterates over all context elements and returns all child nodes or only those matching the filter expression specified as optional argument.

"closest" operation working on ContentRepository nodes. For each node in the context, get the first node that matches the selector by testing the node itself and traversing up through its ancestors.

"context" operation working on ContentRepository nodes. Modifies the ContentRepository Context of each node in the current FlowQuery context by the given properties and returns the same nodes by identifier if they can be accessed in the new Context (otherwise they will be skipped).

This filter implementation contains specific behavior for use on ContentRepository nodes. It will not evaluate any elements that are not instances of the Node.

"find" operation working on ContentRepository nodes. This operation allows for retrieval of nodes specified by a path, identifier or node type (recursive).

"has" operation working on Node. Reduce the set of matched elements to those that have a child node that matches the selector or given subject.

"nextAll" operation working on ContentRepository nodes. It iterates over all context elements and returns each following sibling or only those matching the filter expression specified as optional argument.

"next" operation working on ContentRepository nodes. It iterates over all context elements and returns the immediately following sibling.

"nextUntil" operation working on ContentRepository nodes. It iterates over all context elements and returns each following sibling until the matching sibling is found.

"parent" operation working on ContentRepository nodes. It iterates over all context elements and returns each direct parent nodes or only those matching the filter expression specified as optional argument.

"parents" operation working on ContentRepository nodes. It iterates over all context elements and returns the parent nodes or only those matching the filter expression specified as optional argument.

"parentsUntil" operation working on ContentRepository nodes. It iterates over all context elements and returns the parent nodes until the matching parent is found.

"prevAll" operation working on ContentRepository nodes. It iterates over all context elements and returns each preceding sibling or only those matching the filter expression specified as optional argument

"prev" operation working on ContentRepository nodes. It iterates over all context elements and returns the immediately preceding sibling.

"prevUntil" operation working on ContentRepository nodes. It iterates over all context elements and returns each preceding sibling until the matching sibling is found.

Used to access properties of a ContentRepository Node.

"referenceNodes" operation working on Nodes

Used to access properties of a ContentRepository Reference

"references" operation working on Nodes

Removes the given Node from the current context.

"siblings" operation working on ContentRepository nodes. It iterates over all context elements and returns all sibling nodes or only those matching the filter expression specified as optional argument.

"sortByTimestamp" operation working on ContentRepository nodes.

"sort" operation working on ContentRepository nodes.

"unique" operation working on Nodes

Subject provider for behavioral tests

The node creation trait for behavioral tests

Features context

The feature trait to test projected nodes

The content stream closing feature trait for behavioral tests

The node creation trait for behavioral tests

The node modification trait for behavioral tests

The node move trait for behavioral tests

The node referencing trait for behavioral tests

The node removal trait for behavioral tests

The node renaming trait for behavioral tests

The tagging trait for behavioral tests

The workspace creation feature trait for behavioral tests

The content stream forking feature trait for behavioral tests

Sort points in given set

Compact syntax to declare content dimensions in gherkin tables.

The node discriminator value object

The node discriminator value object collection

Custom context trait for "Node Migration" related concerns

The feature trait to test the subgraph traversal API

The feature trait to test node aggregates

The feature trait to test projected nodes

Custom context trait for "Structure Adjustments" related concerns

Content Repository AuthProvider implementation for tests This is a mutable class in order to allow to adjust the behaviour during runtime for testing purposes

Clock implementation for tests This is a mutable class in order to allow to adjust the behaviour during runtime for testing purposes

Fake factory for testing. Note that the factory MUST be initialised BEFORE the content repository is fetched.

Fake factory for testing. Note that the factory MUST be initialised BEFORE the content repository is fetched.

The general provider class for node subjects.

Class Diff

Abstract Diff Renderer

Array renderer for HTML based diffs

Inline HTML Diff Renderer

Inline HTML Diff Renderer

Text Context Diff Renderer

Unified Diff Renderer

A Diff Sequence Matcher

Class Fusion AFX Dsl

Class AfxException

Class AfxParserException

Class Expression

Class Expression

Class Identifier

Class Prop

Class Spread

Class StringLiteral

A primitive lexer that recognizes Afx-specific characters while iterating through a string

Class Parser

Class AfxService

A parser which extracts cache segments by searching for start and end markers in the given content.

A wrapper around a Neos Flow cache which provides additional functionality for caching partial content (segments) rendered by the Fusion Runtime.

Listener to clear Fusion caches if important files have changed

Serializer for Fusion's \@cache.context values

Helper around the ParsePartials Cache.

Helper around the ParsePartials Cache.

Identifier for the ParsePartials Cache.

Integrate the ContentCache into the Fusion Runtime

This dsl factory takes care of instantiating a Fusion dsl transpilers.

Contract for a Fusion DSL parser

Renders the element as an empty string

Handles exceptions

Wrap the exception to retain the fusion path at which it was originally thrown

A special exception handler that is used on the outer path to catch all unhandled exceptions and uses other exception handlers depending on the context.

Renders the exception as HTML.

Creates text representations of the given exceptions.

Just rethrows the given exception

Creates xml comments from exceptions

This holds the parsed Fusion Configuration and can be used to pass it to the Runtime via {RuntimeFactory::createFromConfiguration()}

Fusion differentiates between dynamic context variables and fixed Fusion globals.

Legacy stub to replace the original {ControllerContext} inside Fusion {Runtime::getControllerContext()}.

Creates exception messages for the Fusion parser

'Fluent' exception for the Fusion Parser.

This exception is thrown when the Parser encounters an unexpected character

Resolve files after a pattern.

Builds the merged array tree for the Fusion runtime

Parses a Fusion File to object ast-nodes

The Fusion Parser

Fusion Runtime

A DTO for transporting internal debugging messages

This is a purely internal helper to provide baseUris for Caching.

An exception thrown by Fusion processors or generally in the Fusion context.

This exception is thrown for errors related to the Content Cache

This exception is thrown if the PHP implementation class for a given Fusion object could not be found; i.e. it was not set using @class.

This exception is thrown if the the object type for a given Fusion path could not be determined, f.e. if the user forgets to define "page = Page" in his Fusion.

This exception wraps an inner exception during rendering.

This exception is thrown if a Fusion path needs to contain exactly a specific object type; f.e. a "Case" Fusion object expects all their children being Fusion objects and does not support Eel Expressions or simple objects.

This exception is thrown if a non-supported array access method was called on FusionPathProxy.

Base class for Fusion objects that need access to arbitrary properties, like DataStructureImplementation.

Base class for all Fusion objects

A Fusion ActionUri object

A Fusion Augmenter-Object

CanRender Fusion-Object

Case Fusion Object

A Fusion Component-Object

Fusion object to render and array of key value pairs by evaluating all properties

A Fusion object for debugging fusion-values via the browser console

A Fusion object for dumping debugging fusion-values

A Fusion object for debugging fusion-values

Extended Fluid Template View for use in Fusion.

You should implement this interface with a View that should allow access to the Fusion object it is rendered from (and so the Fusion runtime).

A proxy object representing a Fusion path inside a Fluid Template. It allows to render arbitrary Fusion objects or Eel expressions using the already-known property path syntax.

A proxy for Fusions private props.

Response Head generate a standard HTTP response head

Fusion object to render a list of items as single concatenated string

Render a Fusion collection of using the itemRenderer

Map a collection of items using the itemRenderer

Implementation class for matching strings in Fusion and return the matched value

Matcher object for use inside a "Case" statement

Memo object that returns the result of previous calls with the same "discriminator"

Reduce an array to a single value.

Renderer Fusion Object

A Fusion object to create resource URIs

A Fusion object for tag based content

Fusion object rendering a fluid template

A Fusion UriBuilder object

Value object for simple type handling as Fusion objects

The Neos Fusion Package

A tool that can augment HTML for example by adding arbitrary attributes.

This trait is to be used in ViewHelpers that need to get information from the Fusion runtime context.

Render a Fusion object with a relative Fusion path, optionally pushing new variables onto the Fusion context.

View for using Fusion for standard MVC controllers.

A trait to add backend translation based on the backend users settings

Controller for tag handling

Controller for asset handling

Controller for browsing images in the ImageEditor

Controller for tag handling

Controller for asset usage handling

The ImageMapper provides basic information about an image object as array of simple types.

A container for the state the media browser is in.

Controller for the paginate view helper

This ViewHelper renders a pagination for asset proxy objects

Renders an HTML tag from a given Asset Proxy instance

Controller for asynchronous thumbnail handling

Doctrine event listener for getting image size and type if needed

An abstract adjustment which provides a constructor for setting options

An abstract image adjustment

Interface for an Asset Adjustment

An adjustment for cropping an image

Interface for an Image Adjustment

An adjustment for quality of an image

An adjustment for resizing an image

An Asset, the base for all more specific assets in this package.

Class AssetCollection

A user-managed Asset which is stored in the Asset Repository

Interface for a stand-in object of remote or already imported assets from an asset source.

Interface for an Asset Proxy which depicts an asset whose original binary data is stored in a remote location

Interface for an Asset Proxy which provides an URI to the original binary data

Interface for an Asset Proxy which supports IPTC Metadata

Exceptions of asset sources which are thrown on connection problems should implement this interface so that they can be handled specifically.

Asset source for Neos native assets

Interface for an Asset Repository which supports collections

An interface for Asset Proxy Repositories which support sorting.

An interface of an asset which was derived from an original asset

An Audio asset

Trait for methods regarding the dimensions of an asset

A Document, e.g. PDF files, binaries, .

Constraints for the Assets that can't be changed by the user while navigating the Media module / endpoints (other than filters)

A DTO for storing information related to a usage of an asset.

File Type Icon

An image

Interface of an Image

A user defined variant (working copy) of an original Image asset

Trait for methods regarding the quality of an asset

Base interface for any class which is based on a PersistentResource.

A Tag, to organize Assets

A system-generated preview version of an Asset

Thumbnail configuration value object

Abstract Thumbnail Generator

A system-generated preview version of a Document (PDF, AI and EPS)

A system-generated preview version of a font document.

A generic thumbnail generator to get Icon of the given document

A system-generated preview version of an Image

Thumbnail Generate Interface

Interface for models which provide methods for thumbnails

An interface which defines that an asset has support for variants

A Video asset

A repository for AssetCollections

A repository for Assets

A repository for Audio

A repository for Documents

A repository for Images

A repository for Tags

A repository for Thumbnails

A repository for Videos

An asset service that handles for example commands on assets, retrieves information about usage of assets and rendering thumbnails.

A service for Asset Sources and Asset Proxies

Service that retrieves an icon for the file type of a given filename

An image service that acts as abstraction for the Imagine library

A thumbnail generation service.

An internal thumbnail service.

Abstract asset usage strategy

Describes a strategy to find an asset model class based on the resource and optional source properties.

Interface for asset usage strategies

A mapping strategy based on configured expressions.

A strategy to detect the correct thumbnail generator

Conjunction validator that loads all implementations of the \Neos\Media\Domain\Validator\AssetValidatorInterface and merges all their results

Interface to implement to hook into the asset model validation

Validator for Audio objects

Validator for Image objects

Validator for Video objects

A Value Object for storing configuration of a Variant Preset

This is a helper for accessing assets from the media library

A generic Neos.Media exception

A Neos.Media exception for the Asset Service

A Neos.Media exception for the Asset Source Service

A Neos.Media exception for the Asset Variant Generator

A Neos.Media exception for image file errors

A Neos.Media exception for the Image Service

A Neos.Media exception for the thumbnail service if the given asset is not able to generate a thumbnail.

A Neos.Media exception for the Thumbnail Service

The Media Package

Condition generator covering Asset <-> AssetCollection relations (M:M relations are not supported by the Flow PropertyConditionGenerator yet)

A SQL condition generator, supporting special SQL constraints for asset collections

A SQL condition generator, supporting special SQL constraints for assets

Condition generator covering Asset <-> Tag relations (M:M relations are not supported by the Flow PropertyConditionGenerator yet)

Condition generator covering Asset >-< AssetCollection relations (M:M relations are not supported by the Flow PropertyConditionGenerator yet)

A SQL condition generator, supporting special SQL constraints for tags

Privilege for restricting reading of AssetCollections

Privilege for restricting reading of Assets

Privilege for restricting reading of Tags

This converter transforms Neos.Media AssetInterface instances to arrays.

This converter transforms to \Neos\Media\Domain\ValueObject\Configuration\AspectRatio objects from string.

This converter transforms Neos.Media AssetCollection instances to arrays.

This converter transforms to \Neos\Media\Domain\Model\ImageInterface (Image or ImageVariant) objects.

This converter transforms to \Neos\Media\Domain\Model\Image objects.

This converter transforms \Neos\Media\Domain\Model\ImageInterface (Image or ImageVariant) objects to array representations.

This converter transforms to \Neos\Media\Domain\Model\ImageInterface (Image or ImageVariant) objects.

This converter transforms \Neos\Media\Domain\Model\ImageInterface (Image or ImageVariant) objects to json representations.

This converter transforms to \Neos\Media\Domain\Model\ImageVariant objects.

Converts an array of processing instructions to matching adjustments

This converter transforms to \Neos\Media\Domain\Model\Tag objects.

This converter transforms Neos.Media Tag instances to arrays.

Validator that checks the orientation (square, portrait, landscape) of a given image.

Validator that checks size (resolution) of a given image

Validator that checks the type of a given image

Renders an HTML tag for a file type icon for a given Neos.Media's asset instance

View Helper which creates a simple checkbox ().

Renders a DateTime formatted relative to the current date

Renders an HTML tag from a given Neos.Media's image instance

Renders an HTML tag from a given Neos.Media's asset instance

Renders the src path of a thumbnail image of a given Neos.Media image instance

Renders the src path of a thumbnail image of a given Neos.Media asset instance

Aspect to memoize values from SiteRepository without the overhead of a query cache

Central authority to look up or remove asset usages in specific a ContentRepository

Implementation of the Neos AssetUsageStrategyInterface in order to protect assets in use to be deleted via the Media Module.

Central authority to look up or remove asset usages in all configured Content Repositories

The package stores the usage of an asset per node and property in a dimension space point. It only stores the usage in the highest/base workspace (usually "live") as long as there are no changes in the same property in a lower/dependent workspace (e.g. user workspace). This allows to get easily an answer to the following questions:

Domain command controller for the Neos.Neos package

The Site Command Controller

The User Command Controller

The Workspace Command Controller

A trait to add backend translation based on the backend users settings

The Neos Backend controller

The Neos ContentModule controller; providing backend functionality for the Content Module.

The Impersonate controller

A helper class for menu generation in backend controllers / view helpers

A generic Neos Controller exception

A "Disabled Module" exception

A "Node Creation" exception

Cache warmup for rendering

A controller which allows for logging into the backend

The Neos Configuration module controller

The Neos Dimension module controller

The Neos Sites Management module controller

The Neos User Admin module controller that allows for managing Neos users

A trait to do easy backend module translations

The Neos User Settings module controller

Rudimentary REST service for assets

Rudimentary REST service for assets

REST service controller for managing content dimensions

Rudimentary REST service for nodes

A trait to do easy backend module translations

A generic Neos Domain exception

The exception to be thrown if a tethered node aggregate with further whether nodes, determined by their ancestor is attempted to be copied.

Export processor exports Neos {Site} instances as json

Import processor that creates the "live" workspace if it doesn't exist

Import processor that creates and persists a Neos {Site} instance

The discarding result DTO

Domain Model of a Domain.

Evaluated permissions a specific user has on a node, usually evaluated by the {ContentRepositoryAuthorizationService}

The publishing result DTO

Describes the mode in which the Neos interface is rendering currently, mainly distinguishing between edit and preview modes currently.

Domain model of a site

This is the node name underneath "/sites" which uniquely identifies the specific site; and which is defined by the user.

Domain Model of a User

Globally unique identifier of a Neos user

A preferences container for a user.

Description for a workspace

Neos-specific metadata of a workspace

Evaluated permissions a specific user has on a workspace, usually evaluated by the {ContentRepositoryAuthorizationService}

Assignment of a workspace role to a Neos user or user group

A set of {WorkspaceRoleAssignment} instances

The identifier of a workspace role subject that identifiers a group of users or a single user {WorkspaceRoleSubjectType}

A set of {WorkspaceRoleSubject} instances

Human-Readable title of a workspace

The expression based node label generator that is used as default if a label expression is configured.

Pruning processor that removes all events from the given cr and resets the projections

Pruning processor that removes role and metadata for a specified content repository

Pruning processor that removes all Neos {Site} instances referenced by the current content repository

The Site Repository

The Site Repository

The User Repository

Implementation detail of {WorkspaceService} and {ContentRepositoryAuthorizationService}

Generate a Fusion prototype definition for a given node type

Strategy for matching domains

Service to copy node recursively - as there is no equivalent content repository core command.

An assignment of "old" to "new" NodeAggregateIds

Model about a non materialized node.

Service to build and find RenderingMode objects

A service for manipulating sites

A service for managing users

Central authority for publishing/discarding workspace changes from Neos

Central authority to interact with Content Repository Workspaces within Neos

Neos specific content repository subtree tag definitions {SubtreeTag}

Additional Neos' specific content repository constraints for subtree tagging

Neos specific content repository visibility constraints {VisibilityConstraints}

Service that detects which soft removals in a content repository can be safely transformed to hard removals and executes those.

A generic Neos exception

Default implementation for cross-site linking.

The {CrossSiteLinkerInterface} is responsible for adjusting a built URL in case it needs to be generated for a different Site. It's directly called from {EventSourcedFrontendNodeRoutePartHandler}.

Entry Point to the dimension resolution process - called from {EventSourcedFrontendNodeRoutePartHandler}.

API Contract for creating a {DimensionResolverInterface} from Settings (usually Neos.Neos.sites.*.contentDimensions.resolver.factoryClassName and Neos.Neos.sites.*.contentDimensions.resolver.options).

Common interface for content dimension resolvers which are hooked into the Frontend Routing.

See {DimensionResolverInterface} for documentation.

TODO: BASE EXCEPTION

Helper class implementing a Resolver Chain.

Resolver which does not do anything.

Resolver which does not do anything.

URI path segment based dimension value resolver

Factory for {UriPathResolver}.

TODO: BASE EXCEPTION

A route part handler for finding nodes in the website's frontend. Like every RoutePartHandler, this handles both directions:

• from URL to NodeAddress (via {EventSourcedFrontendNodeRoutePartHandler::matchWithParameters})
• from NodeAddress to URL (via {EventSourcedFrontendNodeRoutePartHandler::resolveWithParameters})

Marker interface which can be used to replace the currently used FrontendNodeRoutePartHandler, to e.g. use the one with localization support.

Can resolve the target for a given shortcut.

Neos abstraction to simplify node uri building.

Immutable filter DTO for {NodeUriBuilder::uriFor()}

This error will be thrown in {SiteDetectionResult::fromRequest()}

This is basically a singleton which globally, at the beginning of the request, decides which Site and Content Repository is active.

Accessor for retrieving the currently resolved Site and Content Repository for the current Frontend Request.

Base class for Menu and DimensionsMenu

The cache tag value object

The cache tag value object set

This service flushes Fusion content caches triggered by node changes.

Also contains a pragmatic performance booster for some "batch" operations, where the cache flushing is not needed:

Serializer for Fusion's \@cache.context values

The cache entry identifier data transfer object for nodes

Adds meta data attributes to the processed Property to enable in place editing

Adds meta data attributes to the processed Content Element

A Fusion Object that converts link references in the format "://" to proper URIs

A menu item for dimension menus Compared to the default {MenuItem} it has no menuLevel property, but one for the targetDimensions

Fusion implementation for a dimensions menu.

Provides a nicely formatted html error message including all wrappers of an content element (i.e. menu allowing to discard the broken element)

A special exception handler that is used on the outer path to catch all unhandled exceptions and uses other exception handlers depending on the login status.

The exception to be thrown if an invalid menu item state was given

Some Functional Programming Array helpers for Eel contexts

BackendUser helper for translations in the backend

Caching helper to make cache tag generation easier.

Helper for nodes in various content dimensions.

Eel helper for ContentRepository Nodes

Provides a chainable interface to build a label for a nodetype with a fallback mechanism.

Eel helper for accessing the Site object

Render an AssetInterface: object. Accepts the same parameters as the uri.image ViewHelper of the Neos.Media package: asset, width, maximumWidth, height, maximumHeight, allowCropping, allowUpScaling.

A menu item

A Fusion Menu object

Create a link to a node

A Fusion Plugin object.

Add default editor configurations for properties based on type and editor

Map all icon- prefixed icon names to the corresponding names in the used icon implementation

Apply presets from configuration to nodeTypes

The Neos Package

Read model for pending changes

Finder for changes

Read model for a set of pending changes

The visualization model for the interdimensional variation graph

The visualization model for the interdimensional variation graph

The IntraDimensionalFallbackGraph presentation model for SVG

The string-based visual node path

A stream wrapper for nodetypes.

A route part handler for finding nodes specifically in the website's frontend.

A Neos routing exception

An "invalid dimension preset combination" exception

An "invalid request path" exception

An "invalid shortcut" exception that is thrown if a shortcut node can't be resolved to an URL

An exception for nodes missing a required property

A "no site" exception

A "no site node" exception

A "no such dimension value" exception

A "no such node" exception

A "no workspace" exception

Route value normaliser to additionally handle node objects and convert them to node address strings

Central point which does ContentRepository authorization decisions within Neos.

Common base class for privileges that evaluate {SubtreeTagPrivilegeSubject}s

The privilege to edit any matching node in the Content Repository.

A privilege covering general access to Neos Backend Modules

A subject for the ModulePrivilege

The privilege to read any matching node from the Content Repository.

A subject for the {ReadNodePrivilege}

Implementation of Content Repository {AuthProviderInterface} which ties the authorization to Neos.

Implementation of the {AuthProviderFactoryInterface} in order to provide authentication and authorization for Content Repositories

An aspect which centralizes the logging of security relevant actions.

The content element editable service adds the necessary markup around a content element such that it can be edited using the inline editing of the Neos Backend.

The content element wrapping service adds the necessary markup around a content element such that it can be edited using the Content Module of the Neos Backend.

Abstract Service Controller

Data Source Controller

Service Controller for user preferences

Data source interface for getting data.

Data source interface for providing generic data

Takes care of cleaning up ImageVariants.

Impersonate Service

A service for creating URIs pointing to nodes and assets.

Converts a Date to a JavaScript compatible representation, meaning also to convert it to UTC timezone.

Renders the Node Type Schema in a format the User Interface understands; additionally pre-calculating node constraints

The user service provides general context information about the currently authenticated backend user.

The XLIFF service provides methods to find XLIFF files and parse them to json

Converts the given entity to a JSON representation containing the identity and object type

An Object Converter for Node Addresses which can be used for routing (but also for other purposes) as a plugin for the Property Mapper.

A collection of helper methods for the Neos backend assets

Utility trait for retrieving node types for nodes with a built-in fallback mechanism

Utility to generate a valid, non-conflicting uriPathSegment for nodes.

Validator for http://tools.ietf.org/html/rfc1123 compatible host names

Validator for node names

Validator for package keys

Validator for passwords

Validator for Neos users

Renders a label for the given authentication provider identifier

Generates a color code for a given string

ViewHelper for rendering the current version identifier for the configuration cache.

Render HTML markup for the full configuration tree in the Neos Administration -> Configuration Module.

Returns a shortened md5 of the built CSS file

Render a bread crumb path by using the labels of documents leading to the given node path

Condition ViewHelper that can evaluate whether the currently authenticated user can access a given Backend module

ViewHelper for rendering the current backend users interface language.

Returns true, if the current user is allowed to edit the given user, false otherwise.

ViewHelper for the backend JavaScript configuration. Renders the required JS snippet to configure the Neos backend.

Returns translated message using source message or key ID.

Render user initials for a given username

ViewHelper for rendering the current version identifier for the xliff cache.

Renders a wrapper around the inner contents of the tag to enable frontend editing.

A view helper for manually wrapping content editables.

View helper to check if a given value is an array.

A view helper for creating links to modules.

A view helper for creating links with URIs pointing to nodes.

ViewHelper to find the closest document node to a given node

Viewhelper to render a label for a given Node

ViewHelper to find out if Neos is rendering the backend.

ViewHelper to find out if Neos is rendering an edit mode.

ViewHelper to find out if Neos is rendering a preview mode.

ViewHelper to find out if Neos is rendering the live website.

A View Helper to render a fluid template based on the given template path and filename.

A view helper for creating links to modules.

A view helper for creating URIs pointing to nodes.

A Fusion view for Neos

A view specialised on a JSON representation of Assets.

A view specialised on a JSON representation of Nodes.

A view specialised on a JSON representation of Workspaces.

Command controller for the Kickstart generator

Service to generate site packages

The Neos Workspace module controller