Abstracts the task of creating a BackendInterface implementation with it's options.

An abstract caching backend

A caching backend which stores cache entries by using APCu.

A contract for a Cache Backend

A caching backend which stores cache entries in files

A contract for a cache backend which can be frozen.

A contract for a cache backend which provides Iterator functionality.

An iterable, taggable multi backend, falling back to multiple backends if errors occur.

A caching backend which stores cache entries by using Memcache/Memcached.

A multi backend, falling back to multiple backends if errors occur.

A caching backend which forgets everything immediately

A PDO database cache backend

A contract for a cache backend which is capable of storing, retrieving and including PHP source code.

A caching backend which stores cache entries in Redis using the phpredis PHP extension.

RequireOnceFromValueTrait

A caching backend which stores cache entries in files, but does not support or care about expiry times and tags.

A contract for a Cache Backend which supports tagging.

A taggable multi backend, falling back to multiple backends if errors occur.

A caching backend which stores cache entries during one script run.

A contract for a Cache Backend which allows to be set up

A contract for a Cache Backend which allows to retrieve its status

Interface for objects which are cache aware and are collaborative when it comes to storing them in a cache.

This cache factory takes care of instantiating a cache frontend and injecting a certain cache backend. After creation of the new cache, the cache object is registered at the cache manager.

This cache factory takes care of instantiating a cache frontend and injecting a certain cache backend. After creation of the new cache, the cache object is registered at the cache manager.

Global Configuration about the environment to be used by caches.

A generic Cache exception

A "Class Already Loaded" exception

A "Duplicate Identifier" exception

An "Invalid Backend" exception

An "Invalid Cache" exception

An "Invalid Data" exception

A "No Such Cache" exception

A "Not Supported by Backend" exception

An abstract cache

An iterator for cache entries

Contract for a Cache (frontend)

A cache frontend tailored to PHP code.

A cache frontend for strings. Nothing else.

A cache frontend for any kinds of PHP variables

A factory for the PSR-6 compatible cache pool.

A cache item (entry).

An implementation of the CacheItemPoolInterface from the PSR-6 specification to be used with our provided backends.

An invalid argument (usually an inacceptable cache key) was given to a PSR cache.

A simple cache frontend Note: This does not follow the \Neos\Cache\Frontend\FrontendInterface this package provides.

A factory for PSR-16 simple caches.

This Abstract Parser class contains definitions for absolutely basic types, like quoted strings or identifiers

A compiling expression parser

An evaluator that compiles expressions down to PHP code

A Eel evaluation context

An Eel evaluator interface

Eel parser

Some exception that occurred during evaluation of an expression

A general Eel exception

Fizzle parser

FlowQuery is jQuery for PHP, a selector and traversal engine for object sets.

Contract for a FlowQuery operation which is applied onto a set of objects.

FlowQuery Operation Resolver

FlowQuery Operation Resolver Interface

Convenience base class for FlowQuery Operations. You should set $shortName and optionally also $final and $priority when subclassing.

Adds the given items to the current context.

Count the number of elements in the context.

Get the first element inside the context.

Get a (non-wrapped) element from the context.

Check whether the at least one of the context elements match the given filter.

Get the last element inside the context.

"children" operation working on generic objects. It iterates over all context elements and returns the values of the properties given in the filter expression that has to be specified as argument or in a following filter operation.

Filter operation, limiting the set of objects. The filter expression is expected as string argument and used to reduce the context to matching elements by checking each value against the filter.

Access properties of an object using ObjectAccess.

Removes the given items from the current context.

Slice the current context

Removes duplicate items from the current context.

Array helpers for Eel contexts

Configuration helpers for Eel contexts

Date helpers for Eel contexts

Helper to read files.

JSON helpers for Eel contexts

Math helpers for Eel contexts

Helper for security related information

String helpers for Eel contexts

Type helper for Eel contexts

An interpreting expression parser

An expression evalutator that interprets expressions

An exception that is thrown when methods are accessed which are not allowed

Package base class of the Eel package.

Some exception that occurred during parsing of an expression

A protected evaluation context

Interface for classes that are aware of a protected Eel context

Utility to reduce boilerplate code needed to set default context variables and evaluate a string that possibly is an EEL expression.

A validator which checks for the correct syntax of an eel expression (without the wrapping ${…}).

An object representation of a generic error. Subclass this to create more specific errors if necessary.

An object representation of a generic message. Usually, you will use Error, Warning or Notice instead of this one.

An object representation of a generic notice. Subclass this to create more specific notices if necessary.

Result object for operations dealing with objects, such as the Property Mapper or the Validators.

An object representation of a generic warning. Subclass this to create more specific warnings if necessary.

Declares a method as an after advice to be triggered after any pointcut matching the given expression.

Declares a method as an after returning advice to be triggered after any pointcut matching the given expression returns.

Declares a method as an after throwing advice to be triggered after any pointcut matching the given expression throws an exception.

Declares a method as an around advice to be triggered around any pointcut matching the given expression.

Marks a class as an aspect.

Used to disable autowiring for Dependency Injection on the whole class or on the annotated property only.

Declares a method as an before advice to be triggered before any pointcut matching the given expression.

Marks an object as an entity.

Marks a CLI command as a cache-flushing command.

Marks a property as being (part of) the identity of an object.

Used to ignore validation on a specific method argument or class property.

Used to enable property injection.

Used to enable property injection for cache frontends.

Used to mark a command as internal - it will not be shown in CLI help output.

Introduces the given interface or property into any target class matching the given pointcut expression.

Marks a property or class as lazy-loaded.

Used to map the request body to a single action argument.

Declares a named pointcut. The annotated method does not become an advice but can be used as a named pointcut instead of the given expression.

Used to disable proxy building for an object.

Used to set the scope of an object.

Used to control the behavior of session handling when the annotated method is called.

Marks a method as a signal for the signal/slot implementation of Flow. The method will be augmented as needed (using AOP) to be a usable signal.

Action methods marked with this annotation will not be secured against CSRF.

Marks a property as transient - it will never be considered by the persistence layer for storage and retrieval.

Controls how a property or method argument will be validated by Flow.

Marks the annotate class as a value object.

Base class for Advices.

The advice chain holds a number of subsequent advices that match a given join point and calls the advices in the right order.

This is the interface for a generic AOP advice. It is never implemented directly.

Implementation of the After Advice.

Implementation of the After Returning Advice.

Implementation of the After Throwing Advice.

Implementation of the Around Advice.

Implementation of the Before Advice.

Contains boilerplate code for AOP execution and is added to AOP proxy classes.

An advisor is the combination of a single advice and the pointcut where the advice will become active.

An aspect is represented by class tagged with the "aspect" annotation.

An abstract class with builder functions for AOP method interceptors code builders.

A method interceptor build for constructors with advice.

An AOP interceptor code builder for methods enriched by advices.

A filterable index of class names

The main class of the AOP (Aspect Oriented Programming) framework.

A generic AOP Framework Exception

A "Circular PointcutReference" Exception

A "Invalid Argument" Exception

A "Invalid Constructor Signature" Exception

A "Invalid Pointcut Expression" Exception

An "Invalid Target Class" Exception

A "unknown pointcut" Exception

A "Void Implementation" Exception

Implementation of the interface introduction declaration.

In Flow the join point object contains context information when a point cut matches and the registered advices are executed.

Contract for a join point

The pointcut defines the set of join points (ie. "situations") in which certain code associated with the pointcut (ie. advices) should be executed. This set of join points is defined by a pointcut expression which is matched against class and method signatures.

A class filter which fires on classes annotated with a certain annotation

A simple class filter which fires on class names defined by a regular expression

A class type filter which fires on class or interface names

The pointcut expression parser parses the definition of the place and circumstances where advices can be inserted later on. The input of the parse() function is a string from a pointcut- or advice annotation and returns a pointcut filter composite.

A filter which refers to another pointcut.

This composite allows to check for match against a row pointcut filters by only one method call. All registered filters will be invoked and if one filter doesn't match, the overall result is "no".

The contract for an AOP Pointcut Filter class

A method filter which fires on methods annotated with a certain annotation

A little filter which filters for method names

A settings filter which fires on configuration setting set to true or equal to the given condition.

An evaluator for AOP runtime expressions

Implementation of the property introduction declaration.

Contract and marker interface for the AOP Proxy classes

Implementation of the trait introduction declaration.

This cache factory takes care of instantiating a cache frontend and injecting a certain cache backend. In a Flow context you should use the CacheManager to get a Cache.

The Cache Manager

Represents a command

Represents a CommandArgumentDefinition

A controller which processes requests from the command line

Transitional interface for command controllers.

A helper for CLI Commands

A request handler which can handle command line requests.

A wrapper for Symfony ConsoleOutput and related helpers

An interface which allows a CommandController to tweak command descriptions before they are displayed to the user.

A command dispatcher.

An "Infinite Loop" exception

Represents a CLI request.

Builds a CLI request object from the raw command call

A CLI specific response implementation

A special request handler which handles "slave" command requests as used by the interactive shell.

Command controller for managing caches

Configuration command controller for the Neos.Flow package

Command controller for core commands

Command controller for tasks related to database handling

Command controller for tasks related to Doctrine

A Command Controller which provides help for available commands

Command controller for PSR-15 (middleware) related commands

Package command controller to handle packages from CLI

PersistentResource command controller for the Neos.Flow package

Command controller for tasks related to routing

Configuration command controller for the Neos.Flow package

Command controller for tasks related to security

Command controller for starting the development-server

Command controller for managing sessions

Signal command controller for the Neos.Flow package

Command controller for listing active type converters

Utility to access composer information like composer manifests (composer.json) and the lock file.

A generic Composer Exception

An Invalid Configuration Exception

An "package manifest could not be converted to JSON" exception

An "Invalid Package Key" exception

An Invalid Configuration Exception

Class for Composer install scripts

A general purpose configuration manager

A validator for all configuration entries using Schema

A generic Configuration Exception

A Container Is Locked exception

An Invalid Configuration Exception

An Invalid Configuration Type Exception

A No Such File exception

A No Such Option exception

A Parse Error exception

A Recursion exception

A Schema Validation Exception

The interface for a configuration loader

Configuration source based on YAML files

The Flow Context object.

A Sub Process exception

Initialization scripts for modules of the Flow package

A boot sequence, consisting of individual steps, each of them initializing a specific part of the application.

A Step within a Sequence

General purpose central core hyper Flow bootstrap class

Class Loader implementation for test classes.

The Lock Manager controls the master lock of the whole site which is mainly used to regenerate code caches in peace.

Class loader for Flow proxy classes.

The interface for a request handler

An abstract exception handler

A basic but solid exception handler which catches everything which falls through the other exception handlers and provides useful debugging information.

A debugging utility class

Global error handler for Flow

An exception which represents a PHP error.

Contract for an exception handler

A quite exception handler which catches but ignores any exception.

Marks Exceptions having a HTTP status code to return.

Marks Exceptions having a reference code to look up.

A generic Flow Exception

Supports to get a baseUri from various possible sources.

Cache-Control HTTP header generation/parsing

An HTTP client simulating a web browser

A Request Engine which uses cURL in order to send requests to external HTTP servers.

An exception for the Curl Engine

A generic HTTP exception

An HTTP exception occuring if an endless Location: redirect is suspect to happen

A Request Engine which uses Flow's request dispatcher directly for processing HTTP requests internally.

Interface for a Request Engine which can be used by a HTTP Client implementation for sending requests and returning responses.

Implementation of a PSR-7 HTTP stream

Represents a HTTP Cookie as of RFC 6265

A generic HTTP exception

Headers deprecated

Container for HTTP header fields

Helper to unify different HTTP request arguments.

Helper for dealing with HTTP media type resolution.

Helper to extract various information from PSR-7 requests.

Helper to extract various information from PSR-7 responses.

Helper functions about request safety and security.

Helper to re-organize uploaded file data for requests.

Helper to extract information from Uris.

The interface for a request handler which handles and works with HTTP requests

A generic HTTP InvalidArgument exception

A HTTP middleware exception

Allows to override the request HTTP Method via different overrides in this order:

  • a "__method" argument passes in via request body
  • X-Http-Method-Override header
  • X-Http-Method header

Creates a new MiddlewaresChain according to the specified settings

Adds the "X-Flow-Powered" to the response.

Parses the request body and adds the result to the ServerRequest instance.

A HTTP middleware that handles authentication exceptions that were thrown by the dispatcher (\Neos\Flow\Mvc\Dispatcher::dispatch()) and

  • rethrows the exception if no token with Entry Point is authenticated
  • or otherwise invokes the Entry Point of all authenticated tokens

A middleware that handles the session in a HTTP request

HTTP component that makes sure that the current response is standards-compliant. It is usually the last component in the chain.

Middleware that checks request headers against a configured list of trusted proxy IP addresses.

A request handler which can handle HTTP requests.

Declares attributes Flow uses in PSR-7 ServerRequestInterface to carry derived information about the request.

Generic implementation of the PSR-7 UploadedFileInterface.

Represents a URI Template as per http://tools.ietf.org/html/rfc6570

An abstract class for all concrete classes that parses any kind of XML data.

A model representing data from one or few CLDR files.

A class which parses CLDR file to simple but useful array representation.

The CldrRepository class

The "Invalid CLDR Data" exception

A reader for data placed in "currencyData" tag in CLDR.

A reader for data placed in "dates" tag in CLDR.

The "Invalid DateTime Format" exception

The "Invalid Format Length" exception

The "Invalid Format Type" exception

The "Invalid Plural Rule" exception

The "Unable To Find Format" exception

The "Unsupported Number Format" exception

A reader for data placed in "numbers" tag in CLDR.

A reader for data placed in "plurals" tag in CLDR.

A Configuration instance represents settings to be used with the I18n functionality. Examples of such settings are the locale to be used and overrides for message catalogs.

The Detector class provides methods for automatic locale detection

Translation helpers for Eel contexts

Provides a chainable interface to collect all arguments needed to translate messages using source message or key ID

A generic Locale exception

The "Index Out Of Bounds" exception

The "Invalid Argument" exception

The "Invalid Format Placeholder" exception

The "Unsatisfactory Formatter" exception

The "Invalid Locale Identifier" exception

The "Invalid XML File" exception

The "Unknown Formatter" exception

A class for replacing placeholders in strings with formatted values.

Formatter for date and time.

An interface for formatters.

Formatter for numbers.

Represents a locale

The LocaleCollection class contains all locales available in current Flow installation, and describes hierarchical relations between them.

Converter which transforms strings to a Locale object.

Parser for date and time.

The "Invalid Parse String" exception

The "Unsupported Parser Mode" exception

Parser for numbers.

A Service which provides further information about a given locale and the current state of the i18n and L10n components.

An "Invalid Plural Form" exception

An "Unsupported Translation Method" exception

An interface for providers of translation labels (messages).

The concrete implementation of TranslationProviderInterface which uses XLIFF file format to store labels.

A class for translating messages

The Utility class for locale specific actions

An "Invalid XLIFF Data" exception

A model representing data from an XLIFF file object that may be distributed over several documents in different versions.

A provider service for XLIFF file objects within the application

An Xliff reader

A class which parses XLIFF file to simple but useful array representation.

An abstract Log backend

Extended ANSI console backend with human friendly formatting

Contract for a logger backend interface

A log backend which writes log entries to the console (STDOUT or STDERR)

A log backend which writes log entries into a file

A log backend which writes log entries into a file in an easy to parse json format

A backend which just ignores everything

A generic Log exception

A "Could Not Open Resource" exception

An "Invalid Backend" exception

A "No Such Backend" exception

Format any value as plain text representation.

This actually creates a logger from the Neos.Log package.

Interface for PSR-3 logger factories. Any adapter for logging in Flow should bring such a factory.

PSR-3 supporting logger.

An interface for storages that can store full exceptions and their stack traces.

Stores detailed information about throwables into files.

Contract for a change detection strategy

A change detection strategy based on modification times

Contract for a change detection strategy that allows the FileMonitor to mark a file deleted directly.

A monitor which detects changes in directories or files

Represents an internal request targeted to a controller action

Creates an ActionRequest from a PSR-7 http request and sets appropriate defaults.

The minimal MVC response object.

An abstract base class for HTTP based controllers

An HTTP based multi-action controller.

A controller argument

A composite of controller arguments

The controller context holds information about the request, response, arguments and further details of a controller. Instances of this class act as a container for conveniently passing the information to other classes who need it, usually views being views or view helpers.

Generic interface for controllers

A generic Controller exception

An Inactive Package Exception

An Invalid Controller Exception.

An Invalid Package Exception.

The default property mapping configuration is available inside the Argument-object.

This is a Service which can generate a request hash and check whether the currently given arguments fit to the request hash.

An action controller for RESTful web services

A Special Case of a Controller: If no controller has been specified in the request, this controller is chosen.

A dispatch middleware that runs the current HTTP request through the MVC stack

Dispatches requests to the controller which was specified by the request and returns the response the controller generated.

A generic MVC exception

An "Ambiguous command identifier" exception

Base command exception

This exception is thrown by a controller to stop the execution of the current action and return the control to the dispatcher for the special case of a forward().

An "Infinite Loop" exception

An "invalid action name" exception

An "invalid action visibility" exception

An "Invalid Argument Mixing" exception

An "Invalid Argument Name" exception

An "Invalid Argument Type" exception

An "Invalid Argument Value" exception

An "Invalid Command Identifier" exception

An "Invalid Controller Name" exception

An "Invalid FlashMessage Configuration" exception

An "Invalid Format" exception

An "Invalid Marker" exception

An "Invalid Or Missing Request Hash" exception

An "Invalid Package Key" exception

An "Invalid Part" exception

An "Invalid Request Method" exception

An "Invalid Request Type" exception

An "invalid RoutePartHandler" exception

An "invalid RoutePartValue" exception

An "invalid Route setup" exception

An "Invalid Template Resource" exception

An "Invalid URI Pattern" exception

An "no matching route" exception that is thrown if the router could not find a route that matches/resolves the given uri pattern/route values

A "No Such Action" exception

A "No Such Argument" exception

A "No Such Command" exception

A "No Such Controller" exception

A "No Such View" exception

A "Required Argument missing" exception

This exception is thrown by a controller to stop the execution of the current action and return the control to the dispatcher. The dispatcher catches this exception and - depending on the "dispatched" status of the request - either continues dispatching the request or returns control to the request handler.

An "Unsupported Request Type" exception

A "View not found" exception

This is a container for all Flash Messages.

A middleware that persists any new FlashMessages that have been added during the current request cycle

Contract for FlashMessage storages

Contract for a dispatchable request.

This class is a helper that can be used as a context for an Eel evaluation to match a request using the Eel Syntax. This is primarily used in the requestFilter of the Views.yaml configuration.

abstract Route Part

Allows to annotate controller methods with route configurations

The result of a RoutePartInterface::match() call if the corresponding Route Part matched

Simple DTO wrapping the values required for a Router::resolve() call

The result of a RoutePartInterface::resolve() call if the corresponding Route Part resolved

Simple DTO wrapping the values required for a Router::route() call

RouteLifetime to be associated with matched/resolved routes

This class allows the whole routing behavior to be parametrized.

RouteTags to be associated with matched/resolved routes

This class allows constraints to be applied to a given URI, transforming it accordingly as a result.

Dynamic Route Part

Contract for Dynamic Route Parts

An Invalid Controller Exception.

A Missing actionName Exception.

Identity Route Part This route part can be used to create and resolve ObjectPathMappings.

An ObjectPathMapping model This contains the URI representation of an object (pathSegment)

Repository for object path mapping objects

Contract for Route parts that are aware of Routing RouteParameters

Implementation of a standard route

Contract for all Route Parts.

The default web router

Caching of findMatchResults() and resolve() calls on the web Router.

Contract for a Web Router

Supplier for lazily fetching the routes for the router.

A routing HTTP component

Static Route Part

Extends the routing to be able to add custom routes at runtime.

An URI Builder

A View Configuration Manager

An abstract View

A JSON view

An abstract View

Interface of a view

A specialized Object Manager which is able to do some basic dependency injection for singleton scoped objects. This Object Manager is used during compile time when the proxy class based DI mechanism is not yet available.

Flow Object Configuration

Injection (constructor-) argument as used in a Object Configuration

Object Configuration Builder which can build object configuration objects from information collected by reflection combined with arrays of configuration options as defined in an Objects.yaml file.

Injection property as used in a Object Configuration

A Proxy Class Builder which integrates Dependency Injection.

Boilerplate code for dependency injection

A Proxy Class Builder which integrates Dependency Injection

A generic Object Exception

"Cannot build object" Exception

"Cannot reconstitute object" Exception

"Invalid class" Exception

"Invalid Object Configuration" Exception

"Invalid object" Exception

"Invalid object name" Exception

"Object already registered" Exception

"Unknown Class" Exception

"Unknown Interface" Exception

"Unknown Object" Exception

"Unresolved Dependencies" Exception

"Wrong Scope" Exception

Object Manager

Interface for the Flow Object Manager This is a superset of the PSR-11 ContainerInterface.

Builder for proxy classes which are used to implement Dependency Injection and Aspect-Oriented Programming

A generic Proxy Exception

Methods used to serialize objects used by proxy classes.

Representation of a Proxy Class during rendering time

A marker interface for Proxy Classes

Class ProxyMethodGenerator

The Flow Package

An interface to indicate a bootable package

A generic Package Exception

"Corrupt Package" Exception

An "Invalid Package Key" exception

"Invalid Package Path" Exception

An "Invalid Package State" exception

A "Package Key Already Exists" exception

"Package states file not writable" Exception

A "Protected Package Key" exception

"Unknown Package" Exception

An interface for Flow packages that might have configuration or resources

The generic base package that represents third party packages

A Flow Package

Class for building Packages

Interface for a basic Package class

An interface for packages that are aware of the concept of package keys, eg. "Neos.Flow".

The default Flow Package Manager

A simple package dependency order solver. Just sorts by simple dependencies, does no checking or versions.

The Flow Persistence Manager base class

A container for the list of allowed objects to be persisted during this request.

Pointcut filter matching embeddable value objects

Adds the aspect of persistence magic to relevant objects

A marker interface used to support object persistence

An onFlush listener for Flow's Doctrine PersistenceManager, that validates to be persisted entities against the list of allowed objects.

Converts Doctrine collections to arrays

Cache adapter to use Flow caches as Doctrine cache

Connection factory for Doctrine connection class

A walker to transform a select query into a count query.

Extends the default doctrine JsonArrayType to work with entities.

A datatype that replaces references to entities in arrays with a type/identifier tuple and strips singletons from the data to be stored.

EntityManager configuration handler

EntityManager factory for Doctrine integration

An database connection exception

An generic database exception

An database connection exception

A SQL logger that logs to a Flow logger.

A ClassMetadata instance holds all the object-relational mapping metadata of an entity and it's associations.

A factory for Doctrine to create our ClassMetadata instances, aware of the object manager.

This driver reads the mapping metadata from docblock annotations.

A Class Schema Not Found Exception

The GlobFinder class finds migrations in a directory using the PHP glob() function.

An onFlush listener for Flow's Doctrine PersistenceManager.

Flow's Doctrine PersistenceManager

A Query class for Doctrine 2

A lazy result list that is returned by Query::execute()

The Flow default Repository, based on Doctrine 2

Service class for tasks related to Doctrine

An empty result list

A generic Persistence exception

An Illegal Object Type Exception

An "Invalid Query" Exception

A Known Object Exception

An ObjectValidationFailedException thrown when a validation error is encountered during persistence.

An Unknown Object Exception

The Flow Persistence Manager interface

A persistence query interface.

A lazy result list that is returned by Query::execute()

The Flow default Repository

Contract for a repository

An generic Property related exception

A "Duplicate Object" Exception

A "Duplicate Type Converter" Exception

An "Format not supported" Exception

An "Invalid Data Type" Exception

An "Invalid Format" Exception

An "Invalid Property" Exception

An "Invalid Property Mapping Configuration" Exception

An "Invalid Source" Exception

An "Invalid Target" Exception

A "TargetNotFound" Exception

A "Type Converter" Exception

The Property Mapper transforms simple types (arrays, strings, integers, floats, booleans) to objects or other simple types.

Concrete configuration object for the PropertyMapper.

Configuration object for the property mapper. This interface specifies all methods which are used by the property mapper and by the type converters during the conversion process. Thus, this interface does only contain read-only methods, and no methods to set any of these options.

Interface for type converters, which can convert from a simple type to an object or another simple type.

Type converter which provides sensible default implementations for most methods. If you extend this class you only need to do the following:

Converter which transforms various types to arrays.

TypeConverter which converts generic objects to arrays by converting and returning

Converter which transforms ArrayObjects to arrays.

Converter which transforms simple types to a boolean.

Converter which transforms strings and arrays into a Doctrine ArrayCollection.

Converter which transforms from string, integer and array into DateTime objects.

A "target not found" error that is issued when a referenced object/value could not be fetched

Converter which transforms a float, integer or string to a float.

Converter which transforms to an integer.

Converter which transforms strings to arrays using the configured strategy.

A marker interface for type converters that are used to decode the content of a HTTP request

This converter transforms arrays to simple objects (POPO) by setting properties.

This converter transforms arrays or strings to persistent objects. It does the following:

This converter transforms persistent objects to strings by returning their (technical) identifier.

A type converter which converts a scalar type (string, boolean, float or integer) to an object by instantiating the object and passing the string as the constructor argument.

This converter transforms a session identifier into a real session object.

Converter which transforms simple types to a string.

Converter which recursively transforms typed arrays (array).

A type converter for converting URI strings to Http Uri objects.

Extended version of the ReflectionClass

A class schema

A little parser which creates tag objects from doc comments

A generic Reflection Exception

A "Class loading for reflection failed" exception

An "ClassSchema Constraint Violation" exception

An "Invalid Class" exception

An "Invalid Property Type" exception

An "Invalid Value Object" exception

An "Unknown Class" exception

Extended version of the ReflectionMethod

Extended version of the ReflectionParameter

Extended version of the ReflectionProperty

A service for acquiring reflection based information in a performant way. This service also builds up class schema information which is used by the Flow's persistence layer.

Factory for getting an reflection service instance.

A resource collection

Interface for a resource collection

Generic ResourceManagement Exception

"Invalid Resource Data" Exception

Interface for a resource processing filter

Model representing a persistable resource

Message Collector

The ResourceManager

Interface which defines the basic meta data getters and setters for PersistentResource and Storage/Object objects.

PersistentResource Repository

A type converter for converting strings, array and uploaded files to PersistentResource objects.

Generic Storage Exception

A resource storage based on the (local) file system

A resource storage which stores and retrieves resources from active Flow packages.

Interface for a resource storage

An Object which is stored in a Storage

A resource storage based on the (local) file system

Interface of a PersistentResource Storage which provides import functionality.

A stream wrapper for resources.

A generic stream wrapper sitting between PHP and stream wrappers implementing StreamWrapperInterface.

A stream wrapper interface. Modeled after the PHP streamWrapper class prototype. Check http://php.net/streamwrapper for details on that.

Generic Target Exception

A target which publishes resources by creating symlinks.

A target which publishes resources to a specific directory in a file system.

An account model

A factory for conveniently creating new accounts

The repository for accounts

An aspect which centralizes the logging of security relevant actions.

The central security aspect, that invokes the security interceptors.

Contract for an authentication manager.

Contract for an authentication provider used by the AuthenticationProviderManager.

The default authentication manager, which relies on Authentication Providers to authenticate the tokens stored in the security context.

The authentication provider resolver. It resolves the class name of a authentication provider based on names.

The authentication token resolver. It resolves the class name of a authentication token based on names.

An action controller for generic authentication in Flow

Contract for an authentication entry point

An abstract authentication entry point.

An authentication entry point, that sends an HTTP header to start HTTP Basic authentication.

An authentication entry point, that redirects to another webpage.

An abstract authentication provider.

An authentication provider that authenticates Neos\Flow\Security\Authentication\Token\PasswordToken tokens.

An authentication provider that authenticates Neos\Flow\Security\Authentication\Token\UsernamePassword tokens.

A singleton authentication provider for functional tests with mockable authentication.

Default factory for providers and tokens.

Factory contract for providers and their tokens.

Contract for an authentication token.

An abstract authentication token.

An authentication token used for simple password authentication.

Interface for authentication tokens which only hold a password

Marker interface for authentication tokens which don't need a session.

An authentication token used for functional tests

An authentication token used for simple username and password authentication.

An authentication token used for simple username and password authentication via HTTP Basic Auth.

Interface for authentication tokens which hold a username and password

Contract for an after invocation manager. It is used to check return values of a method against security rules.

Contract for an after invocation processor.

Default Firewall which analyzes the request with a RequestFilter chain.

Contract for firewall

Contract for a security interceptor.

The security interceptor resolver. It resolves the class name of a security interceptor based on names.

This security interceptor always denys access.

This security interceptor always grants access.

This security interceptor always denys access.

This is the main security interceptor, which enforces the current security policy and is usually called by the central security aspect:

This security interceptor invokes the authentication of the authentication tokens in the security context.

An access decision voter manager

Contract for a privilege manager

An abstract base class for privileges

A condition generator used as an eel context to orchestrate the different sql condition generators.

A sql generator to create a sql conjunction condition.

A sql generator to create a sql disjunction condition.

A filter to rewrite doctrine queries according to the security policy.

An evaluator that compiles expressions down to PHP code

A compiling expression parser

A SQL generator to create a condition matching nothing.

A sql generator to create a sql not condition.

A sql generator to create a sql condition for an entity property.

A filter to rewrite doctrine queries according to the security policy.

Contract for a SQL condition generator.

A SQL generator to create a condition matching anything.

An entity privilege

A method privilege, able to restrict method calls based on pointcut expressions

Contract for a privilege used to restrict method calls

Pointcut filter which connects the method privileges to the AOP framework

A method privilege subject

A specialized pointcut expression parser tailored to policy expressions

A privilege parameter

A privilege parameter definition

Contract for a privilege parameter

A privilege parameter of type string

Contract for a privilege

Marker interface for privilege subjects

A privilege target

A RequestFilter is configured to match specific ActionRequests and call a InterceptorInterface if needed.

An access decision manager that can be overridden for tests

This security interceptor switches the current channel between HTTP and HTTPS protocol.

This is the default implementation of a security context, which holds current security information like roles oder details of authenticated users.

Algorithms deprecated

Cryptographic algorithms

Hashing passwords using BCrypt

File based simple encrypted key service

A hash service which should be used to generate and validate hashes.

An RSA key

A password hashing strategy interface

A PBKDF2 based password hashing strategy

Precomposes a hash to be used to prevent timing attacks

RSA related service functions (e.g. used for the RSA authentication provider)

Implementation of the RSAWalletServiceInterface using PHP's OpenSSL extension

This is dummy implementation of a security context, which holds security information like roles oder details of authenticated users.

A generic Security exception

An "AccessDenied" Exception

An "AccessDenied" Exception

A "CircularResourceDefinitionDetected" Exception

A "DecryptionNotAllowed" Exception

A "InvalidArgumentForHashGeneration" Exception

A "InvalidArgumentForRequestHashGeneration" Exception

An "InvalidAuthenticationProvider" Exception

A "InvalidAuthenticationStatus" Exception

A "InvalidHash" Exception, thrown when a HMAC validation failed.

A "NoEntryInPolicy" Exception

An "InvalidPolicyException" Exception

An "InvalidPrivilegeException" Exception

An "InvalidPrivilegeTypeException" Exception

A "InvalidQueryRewritingConstraintException" Exception

An "InvalidRequestPattern" Exception

A "MissingConfiguration" Exception

A "NoAuthenticationProviderFound" Exception

A "NoAuthenticationTokenFound" Exception

A "NoContextAvailable" Exception

A "NoRequestPatternFound" Exception

A "NoInterceptorFound" Exception

A "NoRequestPatternFound" Exception

A "NoSuchRole" Exception, thrown when a roles is not defined.

An "NoTokensAuthenticated" Exception

An "OperationNotPermitted" Exception

A "RoleExists" Exception, thrown when a role already exists.

A "SyntacticallyWrongRequestHash" Exception

An "UnsupportedAuthenticationToken" Exception

The policy service reads the policy configuration. The security advice asks this service which methods have to be intercepted by a security interceptor.

A role. These roles can be structured in a tree.

This converter transforms strings to role instances

Contract for a request pattern.

The request pattern resolver. It resolves the class name of a request pattern based on names.

This class holds an controller object name pattern an decides, if a \Neos\Flow\Mvc\ActionRequest object matches against this pattern

This class holds a request pattern that decides, if csrf protection was enabled for the current request and searches for invalid csrf protection tokens.

This class holds a host URI pattern and decides, if an ActionRequest object matches against this pattern Note: the pattern is a simple wildcard matching pattern, with * as the wildcard character.

Ip

This class holds a CIDR IP pattern an decides, if an ActionRequest object matches against this pattern, comparing the client IP address.

Uri

This class holds an URI pattern an decides, if a \Neos\Flow\Mvc\ActionRequest object matches against this pattern

Adds the aspect of lazy loading to objects with scope session.

Marker interface for a Session Lazy Loading Proxy

An aspect which centralizes the logging of important session actions.

Pointcut filter matching proxyable methods in objects of scope session

A "Data not serializable" Exception

An "Invalid Request Handler" Exception

An "Invalid Request or Response" Exception

A modular session implementation based on the caching framework.

Interface for a session manager

Implementation of a transient session.

A dispatcher which dispatches signals by calling its registered slot methods and passing them the method arguments which were originally passed to the signal method.

"Invalid Slot" Exception

Aspect which connects signal methods with the Signal Dispatcher

A SignalInformation instance carries information about the signal that arrives at a slot during a signal/slot dispatch operation.

A utility class for various algorithms.

Abstraction methods which return system environment variables.

A generic Utility Exception

Ip

A utility class for dealing with IP addresses.

Now

A unique DateTime object which serves as a reliable reference for the time "now" for all parts of Flow and its packages. It also improves testability of code relying on a certain time.

This utility class can be used to extract information about PHP files without having to instantiate/reflect classes.

This object holds a validation error.

A generic validation exception

An "Invalid Subject" Exception

An "Invalid Type Hint" Exception

An "Invalid Validation Configuration" Exception

An "Invalid Validation Options" Exception

A "No Such Filter" Exception

A "No Such Validator" Exception

Validator resolver to automatically find a appropriate validator for a given subject

An abstract composite validator consisting of other validators

Abstract validator

A validator which will not validate Aggregates that are lazy loaded and uninitialized.

Validator for alphanumeric strings.

Validator for a specific boolean value.

A generic collection validator.

Validator to chain many validators in a conjunction (logical and).

Validator for countable things

Validator for checking Date and Time boundaries

Validator for DateTime objects.

Validator to chain many validators in a disjunction (logical or).

Validator for email addresses

The given $value is has one of the allowed file extensions Note: a value of NULL or empty string ('') are considered valid

Validator for file sizes Note: a value of NULL or empty string ('') are considered valid

Validator for floats.

A generic object validator which allows for specifying property validators.

Validator for integers.

A validator for labels.

A validator for locale identifiers.

The given $value is matches the defined media types Note: a value of NULL or empty string ('') are considered valid

Validator for not empty values.

Validator for general numbers

Validator for general numbers.

Contract for a validator

Contract for a poly type validator, able to act on possibly any type.

A validator which accepts any input.

Validator based on regular expressions.

Validator for string length.

Validator for strings.

Validator for "plain" text.

Validator for uniqueness of entities.

Validator for Universally Unique Identifiers.

Contract for a validator

Command controller for Fluid documentation rendering

A generic Fluid Core exception.

This interceptor looks for URIs pointing to package resources and in place of those adds ResourceUriNode instances using the ResourceViewHelper to make those URIs work in the rendered template.

A node representing an additional namespace declaration inside the template.

A special ViewHelperNode that works via injections and is created by the ResourceInterceptor

This interface should be implemented by proxy objects which want to return something different than themselves when being part of a Fluid ObjectAccess chain such as {foo.bar.baz}.

This is needed to support the EscapingFlagProcessor and globally (en|dis)able escaping in the template.

Preprocessor to detect the "escapingEnabled" inline flag in a template.

Note: this detects Namespace declarations AND takes care of CDATA because the class in TYPO3Fluid does so as well.

Interface for rendering contexts that are Flow aware.

A Fluid rendering context specifically to be used in conjunction with Flow.

This view helper is an abstract ViewHelper which implements an if/else condition.

Abstract view helper with locale awareness.

Tag based view helper.

The abstract base class for all view helpers.

A ViewHelper Exception

A "Invalid Variable" exception.

A "Rendering Context not Accessible" exception.

A "Wrong enctype" exception.

Child Node Access Facet. View Helpers should implement this interface if they need access to the direct children in the Syntax Tree at rendering-time.

Provides the variables inside fluid template. Adds TemplateObjectAccessInterface functionality.

Class ViewHelperResolver

This is the base class for all widget controllers.

This object stores the WidgetContext for the currently active widgets of the current user, to make sure the WidgetContext is available in Widget AJAX requests.

A HTTP middleware specifically for Ajax widgets It's task is to interrupt the default dispatching as soon as possible if the current request is an AJAX request triggered by a Fluid widget (e.g. contains the arguments "widgetId" or "widgetContext").

A Fluid Widget exception.

An exception if the widget controller has been changed

An exception if the controller is missing.

An exception if no widget context could be found inside the AjaxWidgetContextHolder.

An exception if no widget context could be found inside the AjaxWidgetContextHolder.

The WidgetContext stores all information a widget needs to know about the environment.

The most general Fluid exception.

The Fluid Package

Common base class for XML generators.

A Fluid Service exception.

XML Schema (XSD) Generator. Will generate an XML schema which can be used for auto-completion in schema-aware editors like Eclipse XML editor.

View helper that outputs its child nodes with \Neos\Flow\var_dump()

View helper which renders the flash messages (if there are any) as an unsorted list.

Used to output an HTML

tag which is targeted at the specified action, in the current controller and package.

Abstract Form View Helper. Bundles functionality related to direct property access of objects in other Form ViewHelpers.

Abstract Form View Helper. Bundles functionality related to direct property access of objects in other Form ViewHelpers.

Creates a button.

View Helper which creates a simple checkbox ().

Renders an <input type="hidden" ...> tag.

View Helper which creates a simple Password Text Box ().

View Helper which creates a simple radio button ().

This ViewHelper generates a ).

A view helper which generates an HTML element.

Applies base64_decode to the input

Formats an integer with a byte count into human-readable form.

Modifies the case of an input string to upper- or lowercase or capitalization.

Use this view helper to crop the text between its opening and closing tags.

Formats a given float to a currency representation.

Formats a \DateTime object.

Applies html_entity_decode() to a value

Applies htmlentities() escaping to a value

This ViewHelper renders the identifier of a persisted object (if it has an identity).

Wrapper for PHPs json_encode function.

Wrapper for PHPs nl2br function.

Formats a number with custom precision, decimal point and grouped thousands.

Formats a string using PHPs str_pad function.

Removes tags from the given string (applying PHPs strip_tags() function)

Encodes the given string according to http://www.faqs.org/rfcs/rfc3986.html (applying PHPs rawurlencode() function)

A view helper for creating links to actions.

Email link view helper.

A view helper for creating links to external targets.

Render the inner parts of a Widget.

ViewHelper that outputs a CSRF token which is required for "unsafe" requests (e.g. POST, PUT, DELETE, ...).

This view helper implements an ifAccess/else condition.

This view helper implements an ifAuthenticated/else condition.

This view helper implements an ifHasRole/else condition.

Returns translated message using source message or key ID.

A view helper for creating URIs to actions.

Email uri view helper.

A view helper for creating URIs to external targets.

A view helper for creating URIs to resources.

This view helper allows to check whether validation errors adhere to the current request.

Validation results view helper

Usage: <f:input id="name" ... />

Controller for the auto-complete widget

Controller for the paginate widget

widget.link ViewHelper This ViewHelper can be used inside widget templates in order to render links pointing to widget actions

This ViewHelper renders a Pagination of objects.

widget.uri ViewHelper This ViewHelper can be used inside widget templates in order to render URIs pointing to widget actions

The abstract base of all Fluid views.

A generic Fluid View exception.

An "Invalid Section" exception

An "Invalid Template Resource" exception

A standalone template view.

Class TemplatePaths

A standard Flow view based on Fluid.

A Flow specific uploaded file.

A factory that implements all interfaces of PSR 17

Command controller for the Kickstart generator

The Kickstart Package

Service for the Kickstart generator

Inflector utilities for the Kickstarter. This is a basic conversion from PHP class and field names to a human readable form.

Validation utilities for the Kickstarter.

Wrapper for PHPs ltrim function.

Wrapper for PHPs ucfirst function.

Humanize a camel cased value

Pluralize a word

Some array functions to help with common tasks

A generic File Utility Exception

An Invalid Position Exception

An Invalid Type Exception

An "Invalid Property Type" exception

File and directory functions

Utility class for converting Internet Media Types to file extensions and vice versa.

Provides methods to call appropriate getter/setter on an object given the property name. It does this following these rules:

This class contains a helper to clear PHP Opcode Caches, auto-detecting the current opcache system in use.

A helper class for handling PDO databases

Flexible array sorter that sorts an array according to a "position" meta data.

Configuration schema generator.

A general purpose Array Validator which can check PHP arrays for validity according to some schema.

PHP type handling functions

Exception thrown by the Unicode methods.

A class with UTF-8 string functions, some inspired by what might be in some future PHP version.

A UTF8-aware TextIterator

A UTF8-aware TextIterator

Exception thrown if a feature is not supported.