Interfaces
Custom loader for entities in the choice list.
Represents a class that loads UserInterface objects from Doctrine source for the authentication system.
Creates Symfony Request and Response instances from PSR-7 ones.
Creates PSR HTTP Request and Response instances from Symfony ones.
Marker interface for service route loaders.
Can be implemented by a security factory to add a listener to the firewall.
UserProviderFactoryInterface is the interface for all user provider factories.
Finds and returns assets in the pipeline.
An asset compiler is responsible for applying any changes to the contents of an asset.
Writes asset files to their public location.
Holds information about the current request.
Base ExceptionInterface for the Asset component.
Asset package interface.
Asset version strategy interface.
Base ExceptionInterface for the BrowserKit component.
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.
Generates ConfigBuilders to help create valid config.
A ConfigBuilder provides helper methods to build a large complex array.
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.
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.
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.
Transforms the {see CompletionSuggestions} object into output readable by the shell completion.
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.
StreamableInputInterface is the interface implemented by all input classes
that have an input stream.
ConsoleOutputInterface is the interface implemented by ConsoleOutput class.
Interface for exceptions.
Interface for nodes.
CSS selector handler interface.
CSS selector parser interface.
XPath expression translator extension interface.
XPath expression translator interface.
Represents a complex argument containing nested values.
Interface that must be implemented by compilation passes.
EnvVarLoaderInterface objects return key/value pairs that are added to the list of available env vars.
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.
TaggedContainerInterface is the interface implemented when a container knows how to deals with tags.
Interface for exceptions.
Formats an exception to be used as response content.
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.
Loads a choice list.
A clickable form element.
Transforms a value between different representations.
Base ExceptionInterface for the Form component.
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.
Allows creating a form based on a name, a class or a property.
The central registry of the Form component.
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.
Sanitizes an untrusted HTML input for safe insertion into a document's DOM.
Transforms an untrusted HTML input string into a DOM tree.
Implements attribute-specific sanitization logic.
Represents the sanitized version of a DOM node in the sanitized tree.
Interface for Request exceptions.
A request limiter which allows peeking ahead.
A special type of limiter that deals with requests.
RequestMatcherInterface is an interface for strategies to match a Request.
Attributes store.
Interface for session with a flashbag.
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.
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.
DataCollectorInterface.
LateDataCollectorInterface.
Interface for HTTP error exceptions.
Interface implemented by rendering strategies able to generate a URL for a fragment.
ResponseCacheStrategyInterface implementations know how to compute the
Response cache HTTP header based on the different response cache headers.
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.
Base ExceptionInterface for the Ldap component.
Base ExceptionInterface for the Lock Component.
LockInterface defines an interface to manipulate the status of a lock.
SharedLockInterface defines an interface to manipulate the status of a shared lock.
StrategyInterface defines an interface to indicate when a quorum is met and can be met.
Exception interface for all exceptions thrown by the component.
Interface for mailers able to send emails synchronously and/or asynchronously.
An Authentication mechanism.
Interface for all mailer transports.
Base Messenger component's exception.
Marker interface for exceptions to indicate that handling a message should have worked.
Marker interface for exceptions to indicate that handling a message will continue to fail.
Exception that holds multiple exceptions thrown by one or more handlers and/or messages.
Maps a message to a list of handlers.
A stamp that should not be included with the Envelope if sent to a transport.
An envelope stamp related to a message.
Used when a receiver has the ability to list messages and find specific messages.
Some transports may have multiple queues. This interface is used to read from only some queues.
Maps a message to a list of senders.
A MIME Header.
Guesses the MIME type of a file.
Interface for classes able to send chat messages synchronously and/or asynchronously.
Exception interface for all exceptions thrown by the component.
Interface for the Notifier system.
Interface for classes able to send SMS messages synchronously and/or asynchronously.
Marker interface for all exceptions thrown by the OptionsResolver component.
Contains resolved option values.
Interface for exceptions thrown by the password-hasher component.
Marker Interface for the Process Component.
PipesInterface manages descriptors and pipes for the use of proc_open.
Marker interface for the PropertyAccess component.
A sequence of property names or array indices.
Infers the constructor argument type.
Guesses if the property can be accessed or mutated.
Guesses the property's human readable description.
Extract a property's doc block.
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.
Extract read information for the property of a class.
Type Extractor Interface.
Extract write information for the property of a class.
Representing the stored state of the limiter.
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.
Base Scheduler component's exception.
Interface for resolving the authentication status of a given token.
Interface to be implemented by persistent token classes (such as
Doctrine entities representing a remember-me token).
The TokenStorageInterface.
TokenInterface is the interface for the user authentication information.
AccessDecisionManagerInterface makes authorization decisions.
The AuthorizationCheckerInterface.
A strategy for turning a stream of votes into a final decision.
Let voters expose the attributes and types they care about.
VoterInterface is the interface implemented by all voters.
Base ExceptionInterface for the Security component.
RoleHierarchyInterface is the interface for a role hierarchy.
Overrides UserProviderInterface to add an "attributes" argument on loadUserByIdentifier.
EquatableInterface used to test if two objects are equal in security
and re-authentication context.
For users that can be authenticated using a password/salt couple.
For users that can be authenticated using a password.
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.
AccessMap allows configuration of different access control rules for
specific parts of the website.
The token extractor retrieves the token from a request.
Interface for custom authentication failure handlers.
Interface for a custom authentication success handler.
The interface for all authenticators.
This is an extension of the authenticator interface that may
be used by interactive authenticators.
Passport badges allow to add more information to a passport (e.g. a CSRF token).
Credentials are a special badge used to explicitly mark the
credential check of an authenticator.
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.
Can be implemented by firewall listeners.
A class that is able to create and handle "magic" login links.
Handles creating and validating remember-me cookies.
SessionAuthenticationStrategyInterface.
Base ExceptionInterface for the Semaphore Component.
SemaphoreInterface defines an interface to manipulate the status of a semaphore.
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 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.
Loads {@link ClassMetadataInterface}.
AdvancedNameConverterInterfacedeprecated
Gives access to the class, the format and the context in the property name converters.
Defines the interface for property name converters.
Creates a URL-friendly slug from a given string.
This interface is used to get, set, and delete metadata about the Catalogue.
Represents an operation on catalogue(s).
DumperInterface is the interface implemented by all translation dumpers.
Exception interface for all exceptions thrown by the component.
Formats ICU message patterns.
LoaderInterface is the interface implemented by all translation loaders.
MessageCatalogueInterface.
This interface is used to get, set, and delete metadata about the translation messages.
TranslationReader reads translation messages from translation files.
TranslationWriter writes translation messages.
Resolves type for a given subject.
Represents a type composed of several other types.
Represents a type wrapping another type.
Interface to describe UIDs that contain a DateTimeImmutable as part of their behaviour.
Specifies an object able to return the correct ConstraintValidatorInterface
instance given a Constraint object.
A list of constraint violations.
Creates instances of {@link ExecutionContextInterface}.
The context of a validation run.
Base ExceptionInterface for the Validator component.
Stores all metadata needed for validating objects of specific class.
Returns {@link 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.
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.
Describes a workflow instance.
Exception interface for all exceptions thrown by the component.