Classes

A generic Setup Exception

See {SubprocessProjectionCatchUpTrigger} for the side calling this class

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

See {SubprocessProjectionCatchUpCommandController} for the inner part

The Doctrine DBAL client adapter

The Doctrine DBAL client adapter

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 expression based node label generator that is used as default if a label expression is configured.

The ContentRepository Package

A class holding utility methods.

For full docs and context, see {RaceTrackerCatchUpHook}

We had some race conditions in projections, where {DoctrineCheckpointStorage} was not working properly.

For full docs and context, see {RaceTrackerCatchUpHook}

For full docs and context, see {RaceTrackerCatchUpHook}

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

Common interface for all Content Repository command handlers

Common (marker) interface for all commands of the Content Repository

The content dimension zookeeper

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

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 inter dimensional 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

The configuration based content dimension source

A set of content dimension constraints, indexed by dimension id

The content dimension source interface

A set of content dimension value variation edges

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

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 ContentRepositoryService is an object which is layered on top of a {ContentRepository}, but which interacts with the CR internals in an intricate way.

This interface is implemented by events which contain ContentStreamId and NodeAggregateId.

This interface must be implemented by all commands which are working with individual nodes, such that they are filterable whether they are applying their action to a NodeIdToPublish.

Stores the command in the event's metadata for events on a content stream. This is an important prerequisite for the rebase functionality-

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

This interface is implemented by commands which can be rebased to other Content Streams. This is basically all node-based commands.

INTERNALS. Only to be used from WorkspaceCommandHandler!!!

A content stream's event stream name

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

An assignment of NodeAggregateIds to NodePaths

The exception to be thrown if a node aggregate currently disables a given dimension space point but wasn't expected to do

The exception to be thrown if a node aggregate currently does not disable a given dimension space point but was expected to do

An assignment of "old" to "new" NodeAggregateIds

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.

See the docs of {NodeAggregateWasMoved} for a full description.

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

This is what the ES CR uses to access a database. It needs to be filled from the external world

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

The property type value object as declared in a NodeType

Interface for rendering a node label string based on some strategy

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.

This is an internal API with which you can hook into the catch-up process of a Projection.

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

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

The node path is a list of NodeNames. It can be either absolute or relative.

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 implementation

An immutable, type-safe collection of Subtree objects

The context parameters value object

Node Hidden State Read Model.

Node Hidden State database record

Interface for a class that (asynchronously) triggers a catchup of affected projections after a {ContentRepository::handle()} call.

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}

An immutable set of Content Repository projections ({ProjectionInterface}

Additional marker interface to add to a {ProjectionInterface}.

Workspace Runtime Cache

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 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 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's type is ambiguous

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 name is already occupied 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

A "node type not found" exception

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 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, the node name is "foo".

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

Description for a workspace

Human-Readable title of a workspace

"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.

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. If the property mame is prefixed with _, internal node properties like start time, end time, hidden are accessed.

"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.

An abstract node privilege acting as a base class for other node privileges restricting operations and data on nodes.

Base class for privileges restricting node properties.

A privilege to restrict node creation

An Eel context matching expression for the CreateNodePrivilege

A create node privilege subject

A privilege to restrict editing of nodes and their properties

A privilege to restrict editing of node properties.

An Eel context matching expression for the node privileges

A node privilege subject

An Eel context matching expression for the node privileges including node properties.

A node privilege subject which can restricted to a single node property

A node privilege to restricting reading of nodes.

A privilege to restrict reading of node properties.

A privilege to remove nodes

This service provides API methods to check for privileges on nodes and permissions for node actions.

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

• INFO log level should be used for logging deprecations by default
• WARNING log level should be used if we cannot provide useful fallback behavior.

Implementation to return the metadata for non rendered nodes.

Class Fusion AFX Dsl

Class AfxException

Class AfxParserException

Class Expression

Class Expression

Class Identifier

Class Node

Class NodeList

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

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

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

This runtime factory takes care of instantiating a 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.

Abstract implementation of a collection renderer for Fusion.

Base class for all Fusion objects

A Fusion ActionUri object

The old "COA" object

Renders a string of xml attributes from the properties of this Fusion object.

A Fusion Augmenter-Object

CanRender Fusion-Object

Case Fusion Object

Render a Fusion collection of nodes

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.

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"

Evaluate sub objects to an array (instead of a string as ArrayImplementation does)

Render a Fusion collection of nodes as an array

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

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

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

Event Sourced Node Controller; as Replacement of NodeController

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

Controller for the history module of Neos, displaying the timeline of changes.

The Neos Workspaces module controller

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 generic Neos Domain exception

Domain Model of a Domain.

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

A plugin view definition

Domain model of a site

Domain Model of a User

Interface for a user of the content repository. Users can be owners of workspaces.

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

A preferences container for a user.

The workspace name value for Neos contexts Directly translatable to CR workspace names

The Site Repository

The Site Repository

The User Repository

Generate a Fusion prototype definition for a given node type

Strategy for matching domains

The Fusion Service

Implementation of the NodeSearchServiceInterface for greater backwards compatibility

Interface for the node search service for finding nodes based on a fulltext search

A service for manipulating sites

Service to build and find UserInterfaceMode objects

A service for managing users

"sort" operation working on ContentRepository nodes.

Base class for generic events

Helper Model which groups a number of events on a given day. Used especially in the view.

A specific event which is used for ContentRepository Nodes (i.e. content).

The repository for events

Main entry point for generating events

Monitors Neos.ContentRepository changes

Monitors entity changes

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}.

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.

TODO: BASE EXCEPTION

Resolver which does not do anything.

Resolver which does not do anything.

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.

Builds URIs to nodes, taking workspace (live / shared / user) into account.

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

Base class for Menu and DimensionsMenu

This service flushes Fusion content caches triggered by node changes.

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

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

Caching helper to make cache tag generation easier.

Eel helper for the linking service

Eel helper for ContentRepository Nodes

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

Render Content Dimension Names, Node Labels

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

The menu item state value object

A Fusion Menu object

Create a link to a node

A Fusion Plugin object.

A Fusion PluginView.

!!! Only needed for uncached Fusion segments; as in Fusion ContentCache, the PropertyMapper is used to serialize and deserialize the context.

Node Type post processor that looks for properties flagged with "showInCreationDialog" and sets the "creationDialog" configuration accordingly

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

This Processor updates the PluginViews NodeType with the existing Plugins and it's corresponding available Views

The Neos Package

Change Read Model

A stream wrapper for nodetypes.

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

This service flushes Route caches triggered by node changes.

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 homepage" exception

A "no site" exception

A "no site node" exception

A "no such dimension value" exception

A "no such node" exception

A "no workspace" exception

Aspect to convert a node object to its context node path. This is used in URI building in order to make linking to nodes a lot easier.

A privilege covering general access to Neos Backend Modules

A subject for the ModulePrivilege

A privilege to show (document) nodes in the navigate component of the Neos backend.

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

The service for keeping track of editors' content streams

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.

Converter to convert node references to their identifiers

Convert a boolean to a JavaScript compatible string representation.

Central authority for interactions with plugins.

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

An View specialized on single or multiple Nodes in a tree structure

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.

!!! Only needed for uncached Fusion segments; as in Fusion ContentCache, the PropertyMapper is used to serialize and deserialize the context.

A collection of helper methods for the Neos backend assets

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

Utility functions for dealing with users in the Content Repository.

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

Displays a text-based "bar graph" giving an indication of the amount and type of changes done to something. Created for use in workspace management.

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

Abstract ViewHelper for all Neos rendering state helpers.

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