Custom loader for entities in the choice list.
References Doctrine connections and entity managers.
Interface for finding all the templates.
EngineInterface is the interface each engine must implement.
SecurityFactoryInterface is the interface for all security authentication listener.
UserProviderFactoryInterface is the interface for all user provider factories.
An interface that must be implemented by all node parents
An interface that must be implemented by nodes which can have children
Configuration interface
Common Interface among all nodes.
This interface must be implemented by nodes which can be used as prototypes.
LoaderInterface is the interface implemented by all loader classes.
LoaderResolverInterface selects a loader for a given resource.
ResourceInterface is the interface that must be implemented by all Resource classes.
Descriptor interface.
Formatter interface for console output.
Formatter style interface for defining styles.
HelperInterface is the interface all helpers must implement.
InputInterface is the interface implemented by all input classes.
ConsoleOutputInterface is the interface implemented by ConsoleOutput class.
OutputInterface is the interface implemented by all Output classes.
Interface for exceptions.
Interface for nodes.
CSS selector handler interface.
CSS selector parser interface.
XPath expression translator extension interface.
XPath expression translator interface.
Interface that must be implemented by compilation passes
Interface that must be implemented by passes that are run as part of an RepeatedPass.
ContainerAwareInterface should be implemented by classes that depends on a Container.
ContainerInterface is the interface implemented by service container classes.
DumperInterface is the interface implemented by service container dumper classes.
Base ExceptionInterface for Dependency Injection component.
ConfigurationExtensionInterface is the interface implemented by container extension classes.
ExtensionInterface is the interface implemented by container extension classes.
IntrospectableContainerInterface defines additional introspection functionality for containers, allowing logic to be implemented based on a Container's state.
Lazy proxy instantiator, capable of instantiating a proxy given a container, the service definitions and a callback that produces the real service instance.
Lazy proxy dumper capable of generating the instantiation logic PHP code for proxied services.
ParameterBagInterface.
Scope Interface.
TaggedContainerInterface is the interface implemented when a container knows how to deals with tags.
The EventDispatcherInterface is the central point of Symfony's event listener system.
An EventSubscriber knows himself what events he is interested in.
Exception interface for all exceptions thrown by the component.
A type that should be converted into a {@link Button} instance.
A clickable form element.
Transforms a value between different representations.
Base ExceptionInterface for the Form component.
Contains choices that can be selected in a form field.
Marks classes able to provide CSRF protection
The configuration of a {@link Form} object.
Interface for extensions which provide types, type extensions and a guesser.
A builder for FormFactoryInterface objects.
A form group bundling multiple forms in a hierarchical structure.
The central registry of the Form component.
Adapter for rendering form templates with a specific templating engine.
Renders a form into HTML.
Submits forms if they were submitted.
Creates ResolvedFormTypeInterface instances.
A wrapper for a form type and its extensions.
A type that should be converted into a {@link SubmitButton} instance.
Guesses the file extension corresponding to a given mime type
Guesses the mime type of a file
RequestMatcherInterface is an interface for strategies to match a Request.
Attributes store.
FlashBagInterface.
Session Bag store.
Interface for the session.
StorageInterface.
BundleInterface.
CacheClearerInterface.
Interface for classes able to warm up the cache.
Interface for classes that support warming their cache.
A ControllerResolverInterface implementation knows how to determine the controller to execute based on a Request object.
DataCollectorInterface.
Interface for HTTP error exceptions.
Interface implemented by all rendering strategies.
EsiResponseCacheStrategyInterface implementations know how to compute the Response cache HTTP header based on the different ESI response cache headers.
Interface implemented by HTTP cache stores.
HttpKernelInterface handles a Request to convert it to a Response.
The Kernel is the heart of the Symfony system.
DebugLoggerInterface.
LoggerInterface deprecated
LoggerInterface.
ProfilerStorageInterface.
Terminable extends the Kernel request/response cycle with dispatching a post response event after sending the response and before shutting down the kernel.
Base ExceptionInterface for the Intl component.
Compiles a resource bundle.
Gives access to currency-related ICU data.
Gives access to language-related ICU data.
Gives access to locale-related ICU data.
Reads resource bundle files.
Reads individual entries of a resource file.
Gives access to region-related ICU data.
Gives access to ICU data.
Stores contextual information for resource bundle compilation.
Contains instruction for compiling a resource bundle.
Writes resource bundle files.
Marker interface for the Options component.
Marker Interface for the Process Component.
Marker interface for the PropertyAccess component.
Writes and reads values to/from an object/array graph.
A sequence of property names or array indices.
ExceptionInterface
ConfigurableRequirementsInterface must be implemented by URL generators that can be configured whether an exception should be generated when the parameters do not match the requirements. It is also possible to disable the requirements check for URL generation completely.
GeneratorDumperInterface is the interface that all generator dumper classes must implement.
UrlGeneratorInterface is the interface that all URL generator classes must implement.
MatcherDumperInterface is the interface that all matcher dumper classes must implement.
RedirectableUrlMatcherInterface knows how to redirect the user.
RequestMatcherInterface is the interface that all request matcher classes must implement.
UrlMatcherInterface is the interface that all URL matcher classes must implement.
RouteCompilerInterface is the interface that all RouteCompiler classes must implement.
RouterInterface is the interface that all Router classes must implement.
AclCache Interface
This interface represents an access control list (ACL) for a domain object.
Provides a common interface for retrieving ACLs.
Interface for audit loggers
This interface adds auditing capabilities to the ACL.
ACEs can implement this interface if they support auditing capabilities.
This method can be implemented by domain objects which you want to store ACLs for if they do not have a getId() method, or getId() does not return a unique identifier.
This class represents an individual entry in the ACL list.
Interface for entries which are restricted to specific fields
This interface adds mutators for the AclInterface.
Provides support for creating and storing ACL instances.
Represents the identity of an individual domain object instance.
Retrieves the object identity for a given domain object
Interface used by permission granting implementations.
This interface provides an additional level of indirection, so that we can work with abstracted versions of security objects and do not have to save the entire objects.
Interface for retrieving security identities from tokens
This is the interface that must be implemented by permission maps.
AuthenticationManagerInterface is the interface for authentication managers, which process Token authentication.
Interface for resolving the authentication status of a given token.
AuthenticationProviderInterface is the interface for all authentication providers.
Interface to be implemented by persistent token classes (such as Doctrine entities representing a remember-me token)
Interface for TokenProviders
TokenInterface is the interface for the user authentication information.
AccessDecisionManagerInterface makes authorization decisions.
VoterInterface is the interface implemented by all voters.
EncoderFactoryInterface to support different encoders for different accounts.
PasswordEncoderInterface is the interface for all encoders.
RoleHierarchyInterface is the interface for a role hierarchy.
RoleInterface represents a role granted to a user.
The SecurityContextInterface.
Adds extra features to a user class related to account status flags.
EquatableInterface used to test if two objects are equal in security and re-authentication context.
UserCheckerInterface checks user account when authentication occurs.
Represents the interface that all user classes must implement.
Represents a class that loads UserInterface objects from some source for the authentication system.
Interface that needs to be implemented by all secure random number generators.
AccessMap allows configuration of different access control rules for specific parts of the website.
Interface for custom authentication failure handlers.
Interface for a custom authentication success handler
This is used by the ExceptionListener to translate an AccessDeniedException to a Response object.
AuthenticationEntryPointInterface is the interface used to start the authentication scheme.
This interface must be implemented by firewall maps.
Interface that must be implemented by firewall listeners
Interface that needs to be implemented by LogoutHandlers.
LogoutSuccesshandlerInterface.
Interface that needs to be implemented by classes which provide remember-me capabilities.
SessionAuthenticationStrategyInterface
Defines the interface of decoders
Defines the interface of encoders
Defines the interface of encoders that will normalize data themselves
Base exception
Defines the most basic interface a class must implement to be denormalizable
Defines the interface of denormalizers.
Defines the most basic interface a class must implement to be normalizable
Defines the interface of normalizers.
Defines the interface of encoders
Defines the interface of the Serializer
Asset package interface.
DebuggerInterface is the interface you need to implement to debug template loader instances.
EngineInterface is the interface each engine must implement.
HelperInterface is the interface all helpers must implement.
LoaderInterface is the interface all loaders must implement.
StreamingEngineInterface provides a method that knows how to stream a template.
TemplateNameParserInterface converts template names to TemplateReferenceInterface instances.
Interface to be implemented by all templates.
Represents an operation on catalogue(s).
DumperInterface is the interface implemented by all translation dumpers.
Exception interface for all exceptions thrown by the component.
Extracts translation messages from a template directory to the catalogue.
LoaderInterface is the interface implemented by all translation loaders.
MessageCatalogueInterface.
MetadataAwareInterface.
TranslatorInterface.
An object backed by a PHP class.
Specifies an object able to return the correct ConstraintValidatorInterface instance given a Constraint object.
A violation of a constraint that happened during validation.
A list of constraint violations.
Base ExceptionInterface for the Validator component.
Stores the validator's state during validation.
Stores the node-independent state of a validation run.
Defines the interface for a group sequence provider.
Persists ClassMetadata instances in a cache
Returns {@link MetadataInterface} instances for values.
A container for validation metadata.
Prepares an object for validation.
A container for {@link PropertyMetadataInterface} instances.
A container for validation metadata of a property.
Validates values against constraints defined in {@link MetadataInterface} instances.
A configurable builder for ValidatorInterface objects.
Validates values and graphs of objects and arrays.
Exception interface for all exceptions thrown by the component.