Custom loader for entities in the choice list.
References Doctrine connections and entity managers.
Represents a class that loads UserInterface objects from Doctrine source for the authentication system.
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.
Holds information about the current request.
Base ExceptionInterface for the Asset component.
Asset package interface.
Asset version strategy interface.
Interface for adapters managing instances of Symfony's {see CacheItem}.
Interface for invalidating cached items using tags.
Interface for a ConfigCache factory. This factory creates an instance of ConfigCacheInterface and initializes the cache if necessary.
Interface for ConfigCache.
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.
Interface for ResourceCheckers.
ResourceInterface is the interface that must be implemented by all Resource classes.
Interface for Resources that can check for freshness autonomously, without special support from external services.
Descriptor interface.
ExceptionInterface.
Formatter interface for console output.
Formatter style interface for defining styles.
HelperInterface is the interface all helpers must implement.
InputAwareInterface should be implemented by classes that depends on the Console Input.
InputInterface is the interface implemented by all input classes.
StreamableInputInterface is the interface implemented by all input classes that have an input stream.
ConsoleOutputInterface is the interface implemented by ConsoleOutput class.
OutputInterface is the interface implemented by all Output classes.
Output style helpers.
Interface for exceptions.
Interface for nodes.
CSS selector handler interface.
CSS selector parser interface.
XPath expression translator extension interface.
XPath expression translator interface.
Attempts to convert fatal errors to exceptions.
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.
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.
ResettableContainerInterface defines additional resetting functionality for containers, allowing to release shared services when the container is not needed anymore.
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.
IOException interface for file and input/output stream related exceptions thrown by the component.
A type that should be converted into a {@link Button} instance.
A list of choices that can be selected in a choice field.
Creates {@link ChoiceListInterface} instances.
Loads a choice list.
A clickable form element.
Transforms a value between different representations.
Base ExceptionInterface for the Form component.
Collects and structures information about forms.
Extracts arrays of information out of forms.
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.
Builds method argument data.
An ArgumentResolverInterface instance knows how to determine the arguments for a specific action.
Responsible for resolving the value of an argument based on its metadata.
A ControllerResolverInterface implementation knows how to determine the controller to execute based on a Request object.
DataCollectorInterface.
LateDataCollectorInterface.
Interface for HTTP error exceptions.
Interface implemented by all rendering strategies.
ResponseCacheStrategyInterface implementations know how to compute the Response cache HTTP header based on the different 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.
ProfilerStorageInterface.
Terminable extends the Kernel request/response cycle with dispatching a post response event after sending the response and before shutting down the kernel.
Compiles a resource bundle.
Reads individual entries of a resource file.
Reads resource bundle files.
Writes resource bundle files.
Base ExceptionInterface for the Intl component.
Gives access to currency-related ICU data.
Gives access to language-related ICU data.
Gives access to locale-related ICU data.
Gives access to region-related ICU data.
Gives access to ICU data.
Entry manager interface.
Base ExceptionInterface for the Ldap component.
LdapClientInterface deprecated
Ldap interface.
Ldap interface.
Marker interface for all exceptions thrown by the OptionsResolver component.
Contains resolved option values.
Marker Interface for the Process Component.
PipesInterface manages descriptors and pipes for the use of proc_open.
Marker interface for the PropertyAccess component.
Writes and reads values to/from an object/array graph.
A sequence of property names or array indices.
Guesses if the property can be accessed or mutated.
Description extractor Interface.
Gets info about PHP class properties.
Extracts the list of properties available for the given class.
Type Extractor Interface.
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.
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.
The TokenStorageInterface.
TokenInterface is the interface for the user authentication information.
AccessDecisionManagerInterface makes authorization decisions.
The AuthorizationCheckerInterface.
VoterInterface is the interface implemented by all voters.
EncoderFactoryInterface to support different encoders for different accounts.
PasswordEncoderInterface is the interface for all encoders.
UserPasswordEncoderInterface is the interface for the password encoder service.
Base ExceptionInterface for the Security component.
RoleHierarchyInterface is the interface for a role hierarchy.
RoleInterface deprecated
RoleInterface represents a role granted to a user.
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.
Implement to throw AccountStatusException during the authentication process.
Represents the interface that all user classes must implement.
Represents a class that loads UserInterface objects from some source for the authentication system.
Manages CSRF tokens.
Generates CSRF tokens.
Stores CSRF tokens.
The interface for all "guard" authenticators.
A marker interface that both guard tokens implement.
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.
Implement this interface for any classes that will be called to "start" the authentication process (see method for more details).
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 interface.
Stores metadata needed for serializing and deserializing attributes.
Stores metadata needed for serializing and deserializing objects of specific class.
Returns a {see ClassMetadataInterface}.
Loads {@link ClassMetadataInterface}.
Defines the interface for property name converters.
Defines the most basic interface a class must implement to be denormalizable.
Class accepting a denormalizer.
Defines the interface of denormalizers.
Defines the most basic interface a class must implement to be normalizable.
Class accepting a normalizer.
Defines the interface of normalizers.
Defines the interface of encoders.
Defines the interface of the Serializer.
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 directory or files to the catalogue.
LoaderInterface is the interface implemented by all translation loaders.
MessageCatalogueInterface.
MetadataAwareInterface.
TranslatorBagInterface.
TranslatorInterface.
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.
Creates instances of {@link ExecutionContextInterface}.
The context of a validation run.
Base ExceptionInterface for the Validator component.
Defines the interface for a group sequence provider.
Persists ClassMetadata instances in a cache.
Stores all metadata needed for validating objects of specific class.
Returns {@link \Symfony\Component\Validator\Mapping\MetadataInterface} instances for values.
Loads validation metadata into {@link ClassMetadata} instances.
A container for validation metadata.
Stores all metadata needed for validating the value of a class property.
Prepares an object for validation.
A configurable builder for ValidatorInterface objects.
A validator in a specific execution context.
Validates PHP values against constraints.
Builds {@link \Symfony\Component\Validator\ConstraintViolationInterface} objects.
DumperInterface used by Data objects.
DataDumperInterface for dumping Data objects.
DumperInterface is the interface implemented by workflow dumper classes.
MarkingStoreInterface is the interface between the Workflow Component and a plain old PHP object: the subject.
Exception interface for all exceptions thrown by the component.