Interfaces
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 CacheItem.
Interface for invalidating cached items using tags.
Serializes/unserializes PHP values.
Interface extends psr-6 and psr-16 caches to allow for pruning (deletion) of all expired cache items.
Resets a pool's local state.
Interface for a ConfigCache factory. This factory creates
an instance of ConfigCacheInterface and initializes the
cache if necessary.
Interface for ConfigCache.
An interface that can be implemented by nodes which build other nodes.
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.
Formatter interface for console output that supports word wrapping.
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.
Represents a complex argument containing nested values.
Interface that must be implemented by compilation passes.
RepeatablePassInterface
deprecated
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.
The EnvVarProcessorInterface is implemented by objects that manage environment-like variables.
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.
ContainerBagInterface is the interface implemented by objects that manage service container parameters.
ParameterBagInterface is the interface implemented by objects that manage service container parameters.
ResettableContainerInterface
deprecated
ResettableContainerInterface defines additional resetting functionality
for containers, allowing to release shared services when the container is
not needed anymore.
ServiceSubscriberInterface
deprecated
{@inheritdoc}
TaggedContainerInterface is the interface implemented when a container knows how to deals with tags.
Interface for exceptions.
TraceableEventDispatcherInterface
deprecated
The EventDispatcherInterface is the central point of Symfony's event listener system.
An EventSubscriber knows itself what events it 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 form element whose errors can be cleared.
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.
Allows creating a form based on a name, a class or a property.
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.
Interface for Request exceptions.
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.
Allows the Kernel to be rebooted using a temporary cache directory.
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.
Ldap interface.
Base ExceptionInterface for the Lock Component.
LockInterface defines an interface to manipulate the status of a lock.
StoreInterface defines an interface to manipulate a lock store.
StrategyInterface defines an interface to indicate when a quorum is met and can be met.
Base Message component's exception.
Maps a message to a list of handlers.
Marker interface for message handlers.
Handlers can implement this interface to handle multiple messages.
An envelope stamp related to a message.
If something goes wrong while consuming and handling a message from the AMQP broker, there are two choices: rejecting
or re-queuing the message.
Maps a message to a list of senders.
Creates a Messenger transport.
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.
Guesses the property's human readable description.
Gets info about PHP class properties.
Guesses if the property can be initialized through the constructor.
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.
SimpleAuthenticatorInterface
deprecated
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.
SelfSaltingEncoderInterface is a marker interface for encoders that do not
require a user-generated salt.
UserPasswordEncoderInterface is the interface for the password encoder service.
Base ExceptionInterface for the Security component.
RoleHierarchyInterface is the interface for a role hierarchy.
AdvancedUserInterface
deprecated
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.
SimpleFormAuthenticatorInterface
deprecated
SimplePreAuthenticatorInterface
deprecated
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.
Adds the support of an extra $context parameter for the supportsDecoding method.
Adds the support of an extra $context parameter for the supportsEncoding method.
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.
Knows how to get the class discriminator mapping for classes and objects.
Stores metadata needed for serializing and deserializing objects of specific class.
Returns a {see ClassMetadataInterface}.
Loads {@link ClassMetadataInterface}.
Gives access to the class, the format and the context in the property name converters.
Defines the interface for property name converters.
Marker interface for normalizers and denormalizers that use
only the type and the format in their supports*() methods.
Adds the support of an extra $context parameter for the supportsDenormalization method.
Adds the support of an extra $context parameter for the supportsNormalization method.
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.
ChoiceMessageFormatterInterface
deprecated
Formats ICU message patterns.
LoaderInterface is the interface implemented by all translation loaders.
MessageCatalogueInterface.
MetadataAwareInterface.
TranslationReader reads translation messages from translation files.
TranslatorBagInterface.
TranslatorInterface
deprecated
TranslatorInterface.
TranslationWriter writes translation messages.
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.
ValidatorBuilderInterface
deprecated
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.
Interface to provide contextual data about dump data clones sent to a server.
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.
MetadataStoreInterface is able to fetch metadata for a specific workflow.
SupportStrategyInterface
deprecated
Exception interface for all exceptions thrown by the component.
Covers most simple to advanced caching needs.
Computes and returns the cached value of an item.
Augments PSR-6's CacheItemInterface with support for tags and metadata.
Allows invalidating cached items using tags.
Provides a way to reset an object to its initial state.
A ServiceSubscriber exposes its dependencies via the static {@link getSubscribedServices} method.