---
title: "Phalcon Adr"
version: "5.19"
---
> Documentation Index
> Fetch the complete documentation index at: https://docs.phalcon.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Phalcon Adr
:::info[NOTE]
All classes are prefixed with `Phalcon`
:::
## ADR\Application
Final
Source on GitHub
ADR composition root. Owns (or accepts) a container, exposes a small
registration surface that hides the container's definition API, configures
the convention router, and handles the request through the ADR flow.
When no container is supplied one is created with the ADR defaults
(`AdrProvider`) registered. Type-hinted dependencies autowire; only scalar
parameters need to be declared via `define()`.
- **`Phalcon\ADR\Application`** - implements [`Phalcon\Contracts\ADR\Application`](/5.19/api/phalcon_contracts/#contractsadrapplication)
__Uses__ `Closure` · `Phalcon\ADR\Container\AdrProvider` · `Phalcon\ADR\Events\Event` · `Phalcon\ADR\Exceptions\RouteNotFound` · `Phalcon\Container\Container` · `Phalcon\Container\ContainerFactory` · `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Application` · `Phalcon\Contracts\ADR\Dispatcher` · `Phalcon\Contracts\ADR\Router\AttributeFilter` · `Phalcon\Contracts\ADR\Router\Router` · `Phalcon\Contracts\Events\Manager` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\Request\Bag\AttributeBag` · `Phalcon\Http\Response` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
string
$actionDirectory = ""
protected
string
$baseNamespace = ""
protected
Container
$container
protected
array
$middlewareMap = []
protected
string
$wordSeparator = ""
### Methods
Public · 12
__construct()
```php
public function __construct( Container|null $container = null );
```
bind()
```php
public function bind(
string $interfaceName,
string $concrete
): static;
```
Bind an interface to a concrete class.
define()
```php
public function define(
string $className,
array $parameters = []
): static;
```
Register a class together with explicit values for its constructor
parameters. Type-hinted dependencies autowire; only the supplied
(usually scalar) parameters are declared. Lazy values (e.g.
`new Phalcon\Container\Resolver\Lazy\Env(...)`) may be passed as values.
extend()
```php
public function extend(
string $name,
Closure $extender
): static;
```
Register a post-build extender (decorator) for a service.
factory()
```php
public function factory(
string $name,
Closure $factory
): static;
```
Register a factory closure for a service.
getContainer()
```php
public function getContainer(): Container;
```
Returns the underlying container for definition-level access.
handle()
```php
public function handle( AttributeRequest $request ): ResponseInterface;
```
Routes the request, writes the matched attributes onto it, dispatches
the Action and returns the response. A single try/catch routes any error
through the error responder; if that itself fails, a bare 500 is returned
so nothing escapes uncaught.
secureWith()
```php
public function secureWith(
string $guard,
string $prefix
): static;
```
Attach a guard (middleware) to every Action under a namespace prefix.
set()
```php
public function set(
string $name,
mixed $definition
): static;
```
Register a service with a raw definition (class-string, closure or value).
setActionDirectory()
```php
public function setActionDirectory( string $actionDirectory ): static;
```
Set the filesystem root that backs the base namespace.
setBaseNamespace()
```php
public function setBaseNamespace( string $baseNamespace ): static;
```
Set the base namespace the convention router derives Actions from.
setWordSeparator()
```php
public function setWordSeparator( string $wordSeparator ): static;
```
Set the single delimiter between words in a path segment.
## ADR\Container\AdrProvider
Class
Source on GitHub
Registers the ADR seams in the container; concretes autowire.
Used instead of `Phalcon\Container\Provider\Web` for ADR applications. It
shares the short aliases (`request`/`response`/`router`/`eventsManager`) but
binds the ADR contracts behind them.
- **`Phalcon\ADR\Container\AdrProvider`** - implements [`Phalcon\Contracts\Container\Service\Provider`](/5.19/api/phalcon_contracts/#contractscontainerserviceprovider)
__Uses__ `Phalcon\ADR\Dispatcher` · `Phalcon\ADR\Emitter\SapiEmitter` · `Phalcon\ADR\Responder\JsonResponder` · `Phalcon\ADR\Router\AttributeFilter` · `Phalcon\ADR\Router\Router` · `Phalcon\Contracts\ADR\Dispatcher` · `Phalcon\Contracts\ADR\Emitter\Emitter` · `Phalcon\Contracts\ADR\Responder\Responder` · `Phalcon\Contracts\ADR\Router\AttributeFilter` · `Phalcon\Contracts\ADR\Router\Router` · `Phalcon\Contracts\Container\Service\Collection` · `Phalcon\Contracts\Container\Service\Provider` · `Phalcon\Contracts\Events\Manager` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Contracts\Logger\Logger` · `Phalcon\Events\Manager` · `Phalcon\Html\Escaper` · `Phalcon\Html\Escaper\EscaperInterface` · `Phalcon\Html\TagFactory` · `Phalcon\Http\Request` · `Phalcon\Http\Response` · `Phalcon\Http\ResponseInterface` · `Phalcon\Logger\Adapter\Noop` · `Phalcon\Logger\Logger`
### Method Summary
### Methods
Public · 1
provide()
```php
public function provide( Collection $services ): void;
```
## ADR\Dispatcher
Final
Source on GitHub
Resolves the Action (and middleware) through the container, wraps it in the
pipeline and runs it, firing the `pipeline:*` events. Global middleware is
resolved once and cached; only route middleware resolves per request.
The container resolution is the one deliberate Service Locator: it uses the
resolve-only `IocContainer` contract, so a container swap is a two-method
adapter. Everything else is constructor-injected.
- **`Phalcon\ADR\Dispatcher`** - implements [`Phalcon\Contracts\ADR\Dispatcher`](/5.19/api/phalcon_contracts/#contractsadrdispatcher)
__Uses__ `Phalcon\ADR\Events\Event` · `Phalcon\ADR\Exceptions\NotAnAction` · `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Action` · `Phalcon\Contracts\ADR\Dispatcher` · `Phalcon\Contracts\ADR\Middleware` · `Phalcon\Contracts\Container\Ioc\IocContainer` · `Phalcon\Contracts\Events\Manager` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
IocContainer
$container
protected
Manager
$events
protected
array
$globalMiddleware = []
protected
list<Middleware>|null
$resolvedGlobal = null
### Methods
Public · 2
__construct()
```php
public function __construct(
IocContainer $container,
Manager $events,
array $globalMiddleware = []
);
```
dispatch()
```php
public function dispatch(
string $actionClass,
AttributeRequest $request,
array $routeMiddleware = []
): ResponseInterface;
```
Protected · 2
resolveAll()
```php
protected function resolveAll( array $classes ): array;
```
resolveGlobal()
```php
protected function resolveGlobal(): array;
```
## ADR\Emitter\SapiEmitter
Class
Source on GitHub
Emits a response through the SAPI (headers + body via `Response::send()`).
Refuses to emit once headers have already been sent.
- **`Phalcon\ADR\Emitter\SapiEmitter`** - implements [`Phalcon\Contracts\ADR\Emitter\Emitter`](/5.19/api/phalcon_contracts/#contractsadremitteremitter)
__Uses__ `Phalcon\ADR\Exceptions\HeadersAlreadySent` · `Phalcon\Contracts\ADR\Emitter\Emitter` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Methods
Public · 1
emit()
```php
public function emit( ResponseInterface $response ): void;
```
## ADR\ErrorResponder
Final
Source on GitHub
Turns a thrown exception into a response through the responder chain.
The full diagnostic (class, message, file:line and the exception itself) goes
to the log with a correlation reference; the client receives only a generic
message plus that same reference, unless debug mode is on. Exceptions are
mapped to statuses deterministically: an exact class match first, then the
ancestor chain, so map ordering never matters.
- **`Phalcon\ADR\ErrorResponder`**
__Uses__ `Phalcon\ADR\Exceptions\MethodNotAllowed` · `Phalcon\ADR\Exceptions\RouteNotFound` · `Phalcon\ADR\Payload\Payload` · `Phalcon\ADR\Payload\Status` · `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Payload\Payload` · `Phalcon\Contracts\ADR\Responder\Responder` · `Phalcon\Contracts\Logger\Logger` · `Phalcon\Http\RequestInterface` · `Phalcon\Http\ResponseInterface` · `Throwable`
### Method Summary
### Properties
protected
Responder
$chain
protected
bool
$debug = false
protected
array
$exceptionMap
protected
Logger
$logger
### Methods
Public · 2
__construct()
```php
public function __construct(
Responder $chain,
Logger $logger,
bool $debug = false,
array $exceptionMap = []
);
```
handle()
```php
public function handle(
RequestInterface $request,
ResponseInterface $response,
Throwable $exception
): ResponseInterface;
```
Protected · 4
correlationId()
```php
protected function correlationId( RequestInterface $request ): string;
```
defaultMap()
```php
protected function defaultMap(): array;
```
details()
```php
protected function details(
Throwable $exception,
string $ref,
string $status = Status::ERROR
): array;
```
reason()
```php
protected function reason( string $status ): string;
```
The message that goes with the status. Reporting `Internal Server Error`
next to a `404` tells the client the opposite of what happened.
## ADR\EventfulHandler
Final
Source on GitHub
The terminal handler of the pipeline: fires the `adr:*` events around the
Action's execution.
- **`Phalcon\ADR\EventfulHandler`** - implements [`Phalcon\Contracts\ADR\Handler`](/5.19/api/phalcon_contracts/#contractsadrhandler)
__Uses__ `Phalcon\ADR\Events\Event` · `Phalcon\Contracts\ADR\Action` · `Phalcon\Contracts\ADR\Handler` · `Phalcon\Contracts\Events\Manager` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
Action
$action
protected
Manager
$events
### Methods
Public · 2
__construct()
```php
public function __construct(
Action $action,
Manager $events
);
```
__invoke()
```php
public function __invoke( AttributeRequest $request ): ResponseInterface;
```
## ADR\Events\Event
Class
Source on GitHub
The ADR event vocabulary, fired through the native events manager.
- **`Phalcon\ADR\Events\Event`**
### Constants
string
ADR_AFTER_EXECUTE_ACTION = "adr:afterExecuteAction"
string
ADR_BEFORE_EXECUTE_ACTION = "adr:beforeExecuteAction"
string
APPLICATION_AFTER_HANDLE = "application:afterHandle"
string
APPLICATION_BEFORE_HANDLE = "application:beforeHandle"
string
PIPELINE_AFTER_DISPATCH = "pipeline:afterDispatch"
string
PIPELINE_BEFORE_DISPATCH = "pipeline:beforeDispatch"
## ADR\Exceptions\ActionDirectoryNotSet
Class
Source on GitHub
Thrown when the router is asked to match without an action directory; the
convention cannot resolve sub-namespaces without one.
- `\Exception`
- [`Phalcon\ADR\Exceptions\Exception`](#adrexceptionsexception)
- **`Phalcon\ADR\Exceptions\ActionDirectoryNotSet`**
### Method Summary
### Methods
Public · 1
__construct()
```php
public function __construct();
```
## ADR\Exceptions\Exception
Class
Source on GitHub
Generic exception for the ADR component, and the base for every typed ADR
exception.
- `\Exception`
- **`Phalcon\ADR\Exceptions\Exception`** - implements [`Phalcon\Contracts\ADR\Exceptions\ADRThrowable`](/5.19/api/phalcon_contracts/#contractsadrexceptionsadrthrowable)
- [`Phalcon\ADR\Exceptions\ActionDirectoryNotSet`](#adrexceptionsactiondirectorynotset)
- [`Phalcon\ADR\Exceptions\HeadersAlreadySent`](#adrexceptionsheadersalreadysent)
- [`Phalcon\ADR\Exceptions\MethodNotAllowed`](#adrexceptionsmethodnotallowed)
- [`Phalcon\ADR\Exceptions\NotAnAction`](#adrexceptionsnotanaction)
- [`Phalcon\ADR\Exceptions\OutputAlreadySent`](#adrexceptionsoutputalreadysent)
- [`Phalcon\ADR\Exceptions\RouteNotFound`](#adrexceptionsroutenotfound)
__Uses__ `Exception` · `Phalcon\Contracts\ADR\Exceptions\ADRThrowable`
## ADR\Exceptions\HeadersAlreadySent
Class
Source on GitHub
Thrown when the emitter is asked to send a response after headers have
already been sent.
- `\Exception`
- [`Phalcon\ADR\Exceptions\Exception`](#adrexceptionsexception)
- **`Phalcon\ADR\Exceptions\HeadersAlreadySent`**
### Method Summary
### Methods
Public · 1
```php
public function __construct();
```
## ADR\Exceptions\MethodNotAllowed
Class
Source on GitHub
Thrown when a route matches the path but not the request method.
- `\Exception`
- [`Phalcon\ADR\Exceptions\Exception`](#adrexceptionsexception)
- **`Phalcon\ADR\Exceptions\MethodNotAllowed`**
### Method Summary
### Methods
Public · 1
__construct()
```php
public function __construct();
```
## ADR\Exceptions\NotAnAction
Class
Source on GitHub
Thrown when the dispatcher resolves a class that is not an ADR Action.
- `\Exception`
- [`Phalcon\ADR\Exceptions\Exception`](#adrexceptionsexception)
- **`Phalcon\ADR\Exceptions\NotAnAction`**
### Method Summary
### Methods
Public · 1
__construct()
```php
public function __construct( string $className = "" );
```
## ADR\Exceptions\OutputAlreadySent
Class
Source on GitHub
Thrown when the emitter is asked to send a response after output has already
been sent.
- `\Exception`
- [`Phalcon\ADR\Exceptions\Exception`](#adrexceptionsexception)
- **`Phalcon\ADR\Exceptions\OutputAlreadySent`**
### Method Summary
### Methods
Public · 1
__construct()
```php
public function __construct();
```
## ADR\Exceptions\RouteNotFound
Class
Source on GitHub
Thrown when no route matches the request.
- `\Exception`
- [`Phalcon\ADR\Exceptions\Exception`](#adrexceptionsexception)
- **`Phalcon\ADR\Exceptions\RouteNotFound`**
### Method Summary
### Methods
Public · 1
__construct()
```php
public function __construct();
```
## ADR\Front\AbstractHttpFront
Abstract
Source on GitHub
Boots a container, builds the Application, handles the request and emits the
response. Userland front controllers override `loadEnvironment()`,
`registerProviders()` and optionally `getApplication()`; bootstrap is
`exit((new AppFront(dirname(__DIR__)))->run());`.
- **`Phalcon\ADR\Front\AbstractHttpFront`** - implements [`Phalcon\Contracts\Front\FrontController`](/5.19/api/phalcon_contracts/#contractsfrontfrontcontroller)
- [`Phalcon\ADR\Front\HttpFront`](#adrfronthttpfront)
__Uses__ `Phalcon\ADR\Application` · `Phalcon\ADR\Container\AdrProvider` · `Phalcon\Container\Container` · `Phalcon\Contracts\ADR\Application` · `Phalcon\Contracts\ADR\Emitter\Emitter` · `Phalcon\Contracts\Front\FrontController` · `Phalcon\Contracts\Http\AttributeRequest` · `Throwable`
### Method Summary
### Properties
protected
Container|null
$container = null
protected
string
$projectRoot = ""
### Methods
Public · 3
__construct()
```php
public function __construct( string $projectRoot );
```
boot()
```php
final public function boot(): Container;
```
Builds the container, loads the environment and registers the providers,
returning the container for consumers that need it before (or instead
of) `run()`. The container is built once and cached, so calling `boot()`
and then `run()` reuses the same instance.
run()
```php
final public function run(): int;
```
Protected · 5
buildContainer()
```php
protected function buildContainer(): Container;
```
getApplication()
```php
protected function getApplication( Container $container ): ApplicationInterface;
```
Builds the Application the front will hand the request to. Override to
configure it (`setBaseNamespace()`/`secureWith()`) or to wire a different
`Phalcon\Contracts\ADR\Application` implementation.
handleBootError()
```php
protected function handleBootError( \Throwable $exception ): int;
```
loadEnvironment()
```php
protected function loadEnvironment( Container $container ): void;
```
registerProviders()
```php
protected function registerProviders( Container $container ): void;
```
## ADR\Front\HttpFront
Class
Source on GitHub
Concrete default HTTP front controller. Boots the ADR provider and runs the
application with the framework defaults; subclass to override
`loadEnvironment()` or `registerProviders()`.
- [`Phalcon\ADR\Front\AbstractHttpFront`](#adrfrontabstracthttpfront)
- **`Phalcon\ADR\Front\HttpFront`**
## ADR\Input\Input
Class
Source on GitHub
Generic, string-keyed input bag for an Action.
`fromRequest()` merges the request query, parsed body and route attributes
into a single bag (later sources win). Extend it to build a typed, per-domain
input value object: the factories use late static binding, so a subclass's
`fromRequest()` / `fromArray()` return that subclass.
- **`Phalcon\ADR\Input\Input`**
__Uses__ `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\Request\Bag\AttributeBag`
### Method Summary
### Properties
protected
array
$data = []
### Methods
Public · 6
```php
public function __construct( array $data = [] );
```
```php
public static function fromArray( array $data ): static;
```
```php
public static function fromRequest( AttributeRequest $request ): static;
```
```php
public function get(
string $key,
mixed $defaultValue = null
): mixed;
```
```php
public function has( string $key ): bool;
```
```php
public function toArray(): array;
```
## ADR\Middleware\CorsMiddleware
Class
Source on GitHub
CORS middleware. Inert by default: it emits nothing until an origin allowlist
is configured, and only for requests whose `Origin` is on it. The allowed
origin is always echoed back explicitly, so credentials are never paired with
a wildcard origin. Preflight `OPTIONS` requests are answered directly.
- **`Phalcon\ADR\Middleware\CorsMiddleware`** - implements [`Phalcon\Contracts\ADR\Middleware`](/5.19/api/phalcon_contracts/#contractsadrmiddleware)
__Uses__ `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Handler` · `Phalcon\Contracts\ADR\Middleware` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\Response` · `Phalcon\Http\ResponseInterface` · `Phalcon\Traits\Support\Helper\Arr\GetTrait`
### Method Summary
### Properties
protected
bool
$allowCredentials = false
protected
list<string>
$allowedHeaders = []
protected
list<string>
$allowedMethods = []
protected
list<string>
$allowedOrigins = []
protected
int
$maxAge = 0
### Methods
Public · 2
__construct()
```php
public function __construct( array $config = [] );
```
__invoke()
```php
public function __invoke(
AttributeRequest $request,
Handler $next
): ResponseInterface;
```
Protected · 2
```php
protected function applyHeaders(
ResponseInterface $response,
string $origin
): void;
```
isAllowed()
```php
protected function isAllowed( string $origin ): bool;
```
## ADR\Middleware\MethodOverrideMiddleware
Class
Source on GitHub
Thin enabler for the native `_method` override.
`Request::getMethod()` already honors `X-HTTP-Method-Override` and, when the
parameter-override flag is on, the `_method` field. This middleware only
turns that flag on, and only for a `POST` request whose `_method` names a
safe verb (`PUT`/`PATCH`/`DELETE`), so `_method` cannot spoof an arbitrary
method.
- **`Phalcon\ADR\Middleware\MethodOverrideMiddleware`** - implements [`Phalcon\Contracts\ADR\Middleware`](/5.19/api/phalcon_contracts/#contractsadrmiddleware)
__Uses__ `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Handler` · `Phalcon\Contracts\ADR\Middleware` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
array
$allowed = [...]
### Methods
Public · 1
__invoke()
```php
public function __invoke(
AttributeRequest $request,
Handler $next
): ResponseInterface;
```
## ADR\Middleware\RequestIdMiddleware
Class
Source on GitHub
Ensures every request carries an `X-Request-Id`, reusing an incoming one or
generating it, exposing it on the request attributes and the response.
- **`Phalcon\ADR\Middleware\RequestIdMiddleware`** - implements [`Phalcon\Contracts\ADR\Middleware`](/5.19/api/phalcon_contracts/#contractsadrmiddleware)
__Uses__ `Phalcon\Contracts\ADR\Handler` · `Phalcon\Contracts\ADR\Middleware` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\Request\Bag\AttributeBag` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Methods
Public · 1
__invoke()
```php
public function __invoke(
AttributeRequest $request,
Handler $next
): ResponseInterface;
```
## ADR\Middleware\TimingMiddleware
Class
Source on GitHub
Adds an `X-Response-Time` header measuring how long the rest of the pipeline
took to produce the response.
- **`Phalcon\ADR\Middleware\TimingMiddleware`** - implements [`Phalcon\Contracts\ADR\Middleware`](/5.19/api/phalcon_contracts/#contractsadrmiddleware)
__Uses__ `Phalcon\Contracts\ADR\Handler` · `Phalcon\Contracts\ADR\Middleware` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Methods
Public · 1
__invoke()
```php
public function __invoke(
AttributeRequest $request,
Handler $next
): ResponseInterface;
```
## ADR\Payload\Payload
Class
Source on GitHub
Immutable payload produced by the domain layer.
Every `with*()` method returns a new instance, leaving the receiver
unchanged. Named factories provide a concise way to create a payload for the
commonly used statuses.
- **`Phalcon\ADR\Payload\Payload`** - implements [`Phalcon\Contracts\ADR\Payload\Payload`](/5.19/api/phalcon_contracts/#contractsadrpayloadpayload)
__Uses__ `Phalcon\Contracts\ADR\Payload\Payload` · `Throwable`
### Method Summary
### Properties
protected
Throwable|null
$exception = null
protected
mixed
$extras = null
protected
mixed
$input = null
protected
mixed
$messages = null
protected
mixed
$result = null
protected
mixed
$status = null
### Methods
Public · 31
accepted()
```php
public static function accepted( mixed $result = null ): PayloadContract;
```
Creates a payload with the `ACCEPTED` status.
authenticated()
```php
public static function authenticated( mixed $result = null ): PayloadContract;
```
Creates a payload with the `AUTHENTICATED` status.
authorized()
```php
public static function authorized( mixed $result = null ): PayloadContract;
```
Creates a payload with the `AUTHORIZED` status.
created()
```php
public static function created( mixed $result = null ): PayloadContract;
```
Creates a payload with the `CREATED` status.
deleted()
```php
public static function deleted( mixed $result = null ): PayloadContract;
```
Creates a payload with the `DELETED` status.
error()
```php
public static function error( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `ERROR` status.
forbidden()
```php
public static function forbidden( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `NOT_AUTHORIZED` status (authenticated but
not allowed - HTTP 403).
found()
```php
public static function found( mixed $result = null ): PayloadContract;
```
Creates a payload with the `FOUND` status.
getException()
```php
public function getException(): Throwable|null;
```
Gets the exception thrown in the domain layer, if any.
```php
public function getExtras(): mixed;
```
Gets the arbitrary extra domain information.
```php
public function getInput(): mixed;
```
Gets the domain input.
getMessages()
```php
public function getMessages(): mixed;
```
Gets the domain messages.
getResult()
```php
public function getResult(): mixed;
```
Gets the domain result.
getStatus()
```php
public function getStatus(): mixed;
```
Gets the payload status.
invalid()
```php
public static function invalid( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `NOT_VALID` status.
notAccepted()
```php
public static function notAccepted( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `NOT_ACCEPTED` status.
notCreated()
```php
public static function notCreated( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `NOT_CREATED` status.
notDeleted()
```php
public static function notDeleted( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `NOT_DELETED` status.
notFound()
```php
public static function notFound( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `NOT_FOUND` status.
notUpdated()
```php
public static function notUpdated( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `NOT_UPDATED` status.
processing()
```php
public static function processing( mixed $result = null ): PayloadContract;
```
Creates a payload with the `PROCESSING` status.
success()
```php
public static function success( mixed $result = null ): PayloadContract;
```
Creates a payload with the `SUCCESS` status.
unauthenticated()
```php
public static function unauthenticated( mixed $messages = null ): PayloadContract;
```
Creates a payload with the `NOT_AUTHENTICATED` status (identity not
established - HTTP 401).
updated()
```php
public static function updated( mixed $result = null ): PayloadContract;
```
Creates a payload with the `UPDATED` status.
valid()
```php
public static function valid( mixed $result = null ): PayloadContract;
```
Creates a payload with the `VALID` status.
withException()
```php
public function withException( Throwable $exception ): PayloadContract;
```
Returns a copy of the payload with the given exception.
```php
public function withExtras( mixed $extras ): PayloadContract;
```
Returns a copy of the payload with the given extras.
```php
public function withInput( mixed $input ): PayloadContract;
```
Returns a copy of the payload with the given input.
withMessages()
```php
public function withMessages( mixed $messages ): PayloadContract;
```
Returns a copy of the payload with the given messages.
withResult()
```php
public function withResult( mixed $result ): PayloadContract;
```
Returns a copy of the payload with the given result.
withStatus()
```php
public function withStatus( mixed $status ): PayloadContract;
```
Returns a copy of the payload with the given status.
## ADR\Payload\PayloadFactory
Class
Source on GitHub
Thin, injectable factory mirroring the `Payload` named factories.
It exists so that payload creation can be registered as a service in the DI
container and substituted in tests, rather than calling the static factories
directly.
- **`Phalcon\ADR\Payload\PayloadFactory`**
__Uses__ `Phalcon\Contracts\ADR\Payload\Payload`
### Method Summary
### Methods
Public · 19
accepted()
```php
public function accepted( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `ACCEPTED` status.
authenticated()
```php
public function authenticated( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `AUTHENTICATED` status.
authorized()
```php
public function authorized( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `AUTHORIZED` status.
created()
```php
public function created( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `CREATED` status.
deleted()
```php
public function deleted( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `DELETED` status.
error()
```php
public function error( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `ERROR` status.
forbidden()
```php
public function forbidden( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `NOT_AUTHORIZED` status (HTTP 403).
found()
```php
public function found( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `FOUND` status.
invalid()
```php
public function invalid( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `NOT_VALID` status.
notAccepted()
```php
public function notAccepted( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `NOT_ACCEPTED` status.
notCreated()
```php
public function notCreated( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `NOT_CREATED` status.
notDeleted()
```php
public function notDeleted( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `NOT_DELETED` status.
notFound()
```php
public function notFound( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `NOT_FOUND` status.
notUpdated()
```php
public function notUpdated( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `NOT_UPDATED` status.
processing()
```php
public function processing( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `PROCESSING` status.
success()
```php
public function success( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `SUCCESS` status.
unauthenticated()
```php
public function unauthenticated( mixed $messages = null ): PayloadInterface;
```
Creates a payload with the `NOT_AUTHENTICATED` status (HTTP 401).
updated()
```php
public function updated( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `UPDATED` status.
valid()
```php
public function valid( mixed $result = null ): PayloadInterface;
```
Creates a payload with the `VALID` status.
## ADR\Payload\Status
Class
Source on GitHub
Holds the status codes for the payload.
The two failure-related statuses are distinct, following the Aura.Payload
lineage:
- `ERROR` means an exception was raised while the domain layer was running.
By convention, `Payload::withException()` pairs with the `ERROR` status.
- `FAILURE` means the domain layer ran to completion but declined the
request (for example, a business rule was not satisfied); no exception
was raised.
@see Payload
- **`Phalcon\ADR\Payload\Status`**
### Constants
string
ACCEPTED = "ACCEPTED"
string
AUTHENTICATED = "AUTHENTICATED"
string
AUTHORIZED = "AUTHORIZED"
string
CREATED = "CREATED"
string
DELETED = "DELETED"
string
ERROR = "ERROR"
string
FAILURE = "FAILURE"
string
FOUND = "FOUND"
string
METHOD_NOT_ALLOWED = "METHOD_NOT_ALLOWED"
string
NOT_ACCEPTED = "NOT_ACCEPTED"
string
NOT_AUTHENTICATED = "NOT_AUTHENTICATED"
string
NOT_AUTHORIZED = "NOT_AUTHORIZED"
string
NOT_CREATED = "NOT_CREATED"
string
NOT_DELETED = "NOT_DELETED"
string
NOT_FOUND = "NOT_FOUND"
string
NOT_UPDATED = "NOT_UPDATED"
string
NOT_VALID = "NOT_VALID"
string
PROCESSING = "PROCESSING"
string
SUCCESS = "SUCCESS"
string
UPDATED = "UPDATED"
string
VALID = "VALID"
## ADR\Pipeline
Final
Source on GitHub
Self-recursive middleware runner. It is itself a Handler: it carries an index
and hands a new Pipeline (advanced by one) forward as the `next` handler, so
`next` is always a real Handler - no anonymous classes or callables.
When the middleware is exhausted it invokes the terminal handler (the Action).
- **`Phalcon\ADR\Pipeline`** - implements [`Phalcon\Contracts\ADR\Handler`](/5.19/api/phalcon_contracts/#contractsadrhandler)
__Uses__ `Phalcon\Contracts\ADR\Handler` · `Phalcon\Contracts\Http\AttributeRequest` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
int
$index = 0
protected
array
$middleware = []
protected
Handler
$terminal
### Methods
Public · 2
__construct()
```php
public function __construct(
array $middleware,
Handler $terminal,
int $index = 0
);
```
__invoke()
```php
public function __invoke( AttributeRequest $request ): ResponseInterface;
```
## ADR\Responder\AbstractFormattedResponder
Abstract
Source on GitHub
Base for content-type responders: composes Status, Redirect and Format
responders into a chain. Subclasses bind the formatter(s).
- [`Phalcon\ADR\Responder\ChainResponder`](#adrresponderchainresponder)
- **`Phalcon\ADR\Responder\AbstractFormattedResponder`**
- [`Phalcon\ADR\Responder\JsonResponder`](#adrresponderjsonresponder)
- [`Phalcon\ADR\Responder\TextResponder`](#adrrespondertextresponder)
### Method Summary
### Methods
Public · 1
```php
public function __construct( array $formatters = [] );
```
## ADR\Responder\ChainResponder
Class
Source on GitHub
Composes single-purpose responders. Each link receives the request, the
response threaded so far, and the payload, and returns the response.
- **`Phalcon\ADR\Responder\ChainResponder`** - implements [`Phalcon\Contracts\ADR\Responder\Responder`](/5.19/api/phalcon_contracts/#contractsadrresponderresponder)
- [`Phalcon\ADR\Responder\AbstractFormattedResponder`](#adrresponderabstractformattedresponder)
__Uses__ `Phalcon\Contracts\ADR\Payload\Payload` · `Phalcon\Contracts\ADR\Responder\Responder` · `Phalcon\Http\RequestInterface` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
Responder[]
$links = []
### Methods
Public · 3
__construct()
```php
public function __construct( array $links = [] );
```
__invoke()
```php
public function __invoke(
RequestInterface $request,
ResponseInterface $response,
Payload $payload
): ResponseInterface;
```
with()
```php
public function with( Responder $link ): ChainResponder;
```
## ADR\Responder\FormatResponder
Class
Source on GitHub
Negotiates a formatter against the request `Accept` header and renders the
payload as the response body + content type.
If no formatter accepts the header it falls back to the first (default)
formatter, so the content type and body are never left unset.
- **`Phalcon\ADR\Responder\FormatResponder`** - implements [`Phalcon\Contracts\ADR\Responder\Responder`](/5.19/api/phalcon_contracts/#contractsadrresponderresponder)
__Uses__ `Phalcon\Contracts\ADR\Payload\Payload` · `Phalcon\Contracts\ADR\Responder\Responder` · `Phalcon\Http\RequestInterface` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
array
$formatters = []
### Methods
Public · 2
```php
public function __construct( array $formatters = [] );
```
```php
public function __invoke(
RequestInterface $request,
ResponseInterface $response,
Payload $payload
): ResponseInterface;
```
## ADR\Responder\Formatter\JsonFormatter
Class
Source on GitHub
Renders a payload as JSON.
- **`Phalcon\ADR\Responder\Formatter\JsonFormatter`** - implements [`Phalcon\Contracts\ADR\Responder\Formatter\Formatter`](/5.19/api/phalcon_contracts/#contractsadrresponderformatterformatter)
__Uses__ `Phalcon\Contracts\ADR\Payload\Payload` · `Phalcon\Contracts\ADR\Responder\Formatter\Formatter`
### Method Summary
### Methods
Public · 3
```php
public function accepts( string $acceptHeader ): bool;
```
contentType()
```php
public function contentType(): string;
```
```php
public function format( Payload $payload ): string;
```
## ADR\Responder\Formatter\TextFormatter
Class
Source on GitHub
Renders a payload as plain text.
- **`Phalcon\ADR\Responder\Formatter\TextFormatter`** - implements [`Phalcon\Contracts\ADR\Responder\Formatter\Formatter`](/5.19/api/phalcon_contracts/#contractsadrresponderformatterformatter)
__Uses__ `Phalcon\Contracts\ADR\Payload\Payload` · `Phalcon\Contracts\ADR\Responder\Formatter\Formatter`
### Method Summary
### Methods
Public · 3
accepts()
```php
public function accepts( string $acceptHeader ): bool;
```
contentType()
```php
public function contentType(): string;
```
format()
```php
public function format( Payload $payload ): string;
```
## ADR\Responder\JsonResponder
Class
Source on GitHub
A formatted responder bound to the JSON formatter.
- [`Phalcon\ADR\Responder\ChainResponder`](#adrresponderchainresponder)
- [`Phalcon\ADR\Responder\AbstractFormattedResponder`](#adrresponderabstractformattedresponder)
- **`Phalcon\ADR\Responder\JsonResponder`**
__Uses__ `Phalcon\ADR\Responder\Formatter\JsonFormatter`
### Method Summary
### Methods
Public · 1
__construct()
```php
public function __construct();
```
## ADR\Responder\Redirect
Class
Source on GitHub
Value object describing a redirect. An Action sets it on the payload; the
RedirectResponder turns it into a `Location` header and status code.
- **`Phalcon\ADR\Responder\Redirect`**
### Method Summary
### Properties
protected
int
$status = 302
protected
string
$url
### Methods
Public · 6
__construct()
```php
public function __construct(
string $url,
int $status = 302
);
```
permanent()
```php
public static function permanent( string $url ): Redirect;
```
seeOther()
```php
public static function seeOther( string $url ): Redirect;
```
status()
```php
public function status(): int;
```
temporary()
```php
public static function temporary( string $url ): Redirect;
```
url()
```php
public function url(): string;
```
## ADR\Responder\RedirectResponder
Class
Source on GitHub
Applies a `Redirect` value object carried on the payload result: sets the
status code and the `Location` header. A no-op when the result is not a
redirect.
- **`Phalcon\ADR\Responder\RedirectResponder`** - implements [`Phalcon\Contracts\ADR\Responder\Responder`](/5.19/api/phalcon_contracts/#contractsadrresponderresponder)
__Uses__ `Phalcon\Contracts\ADR\Payload\Payload` · `Phalcon\Contracts\ADR\Responder\Responder` · `Phalcon\Http\RequestInterface` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Methods
Public · 1
__invoke()
```php
public function __invoke(
RequestInterface $request,
ResponseInterface $response,
Payload $payload
): ResponseInterface;
```
## ADR\Responder\StatusMapper
Final
Source on GitHub
Maps a domain `Status` to an HTTP status code.
`Status` is the single source of truth: the default map covers every
`Status` constant. Any status that is not mapped resolves to 500, never a
silent 200. Every entry can be overridden through the constructor.
- **`Phalcon\ADR\Responder\StatusMapper`**
__Uses__ `Phalcon\ADR\Payload\Status` · `Phalcon\Contracts\ADR\ADRTypes`
### Method Summary
### Properties
### Methods
Public · 2
__construct()
```php
public function __construct( array $overrides = [] );
```
toHttpCode()
```php
public function toHttpCode( string $status ): int;
```
Returns the HTTP status code for the given domain status.
An unmapped status resolves to 500 (server error), never a silent 200.
## ADR\Responder\StatusResponder
Class
Source on GitHub
Sets the response HTTP status code from the payload status, via StatusMapper.
- **`Phalcon\ADR\Responder\StatusResponder`** - implements [`Phalcon\Contracts\ADR\Responder\Responder`](/5.19/api/phalcon_contracts/#contractsadrresponderresponder)
__Uses__ `Phalcon\Contracts\ADR\Payload\Payload` · `Phalcon\Contracts\ADR\Responder\Responder` · `Phalcon\Http\RequestInterface` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
StatusMapper
$mapper
### Methods
Public · 2
__construct()
```php
public function __construct( StatusMapper|null $mapper = null );
```
__invoke()
```php
public function __invoke(
RequestInterface $request,
ResponseInterface $response,
Payload $payload
): ResponseInterface;
```
## ADR\Responder\TextResponder
Class
Source on GitHub
A formatted responder bound to the text formatter.
- [`Phalcon\ADR\Responder\ChainResponder`](#adrresponderchainresponder)
- [`Phalcon\ADR\Responder\AbstractFormattedResponder`](#adrresponderabstractformattedresponder)
- **`Phalcon\ADR\Responder\TextResponder`**
__Uses__ `Phalcon\ADR\Responder\Formatter\TextFormatter`
### Method Summary
### Methods
Public · 1
__construct()
```php
public function __construct();
```
## ADR\Responder\ViewResponder
Final
Source on GitHub
Renders a template from the payload and returns it as an HTML response.
The HTML sibling of `JsonResponder`: serialization is swapped for rendering,
the status mapping and the `Responder` contract stay the same. It depends on
the neutral `Renderer` contract only, so the ADR component never imports the
MVC view.
- **`Phalcon\ADR\Responder\ViewResponder`** - implements [`Phalcon\Contracts\ADR\Responder\Responder`](/5.19/api/phalcon_contracts/#contractsadrresponderresponder)
__Uses__ `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Payload\Payload` · `Phalcon\Contracts\ADR\Responder\Responder` · `Phalcon\Contracts\View\Renderer` · `Phalcon\Http\RequestInterface` · `Phalcon\Http\ResponseInterface`
### Method Summary
### Properties
protected
Renderer
$renderer
protected
StatusMapper
$statusMapper
protected
string
$template = ""
### Methods
Public · 3
__construct()
```php
public function __construct(
Renderer $renderer,
StatusMapper $statusMapper,
string $template = ""
);
```
__invoke()
```php
public function __invoke(
RequestInterface $request,
ResponseInterface $response,
Payload $payload
): ResponseInterface;
```
withTemplate()
```php
public function withTemplate( string $template ): static;
```
Returns a copy of the responder bound to the given template. The action
names the view; the payload stays free of presentation concerns.
Protected · 1
viewData()
```php
protected function viewData( Payload $payload ): array;
```
Flattens the payload into the variables handed to the template. The
extras travel as they are, so an action can hand the view whatever the
result should not carry.
## ADR\Router\AttributeFilter
Final
Source on GitHub
Reads an Action's optional static `params()` declaration and transforms the
router's positional tail segments: regex match (miss => RouteNotFound), cast
to a scalar type, then an optional converter closure. Declaration order names
the attributes; a declared parameter with no segment is skipped; surplus
segments pass through under their positional keys. An Action without
`params()` is returned unchanged.
- **`Phalcon\ADR\Router\AttributeFilter`** - implements [`Phalcon\Contracts\ADR\Router\AttributeFilter`](/5.19/api/phalcon_contracts/#contractsadrrouterattributefilter)
__Uses__ `Phalcon\ADR\Exceptions\RouteNotFound` · `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Router\AttributeFilter`
### Method Summary
### Methods
Public · 1
filter()
```php
public function filter(
string $actionClass,
array $attributes
): array;
```
Protected · 1
cast()
```php
protected function cast(
string $value,
string $type
): float|int|string;
```
## ADR\Router\Router
Final
Source on GitHub
Convention router. `method + static path -> Action class`; the path tail
becomes positional request attributes. Middleware is resolved from a
namespace-prefix map (group semantics); global middleware stays on the
pipeline. No route table.
## The convention
Every static path segment is a namespace segment, and the class name is the
verb followed by all of those segments concatenated:
GET / -> Get
GET /profiles -> Profiles\GetProfiles
GET /company/all -> Company\All\GetCompanyAll
GET /company/all/7 -> Company\All\GetCompanyAll with ["7"]
POST /session/forgot-password -> Session\ForgotPassword\PostSessionForgotPassword
## Guarantees
- One path names exactly one class; that class names exactly one path.
- `classFor()` and `pathFor()` are pure functions of their input. Neither
touches the filesystem, and neither consults any Action but the one it was
given, so adding or deleting an Action can never move another one's URL.
- There is no candidate list and no first-that-exists. Nothing can be
shadowed.
## Constraints - these are load-bearing, not style
- **Arguments always trail the static path.** `/album/edit/1`, never
`/album/1/edit`. A class name encodes which segments exist, not where a
value sits among them; putting an argument in the middle would require
consulting some other Action to find the boundary, and that is exactly the
coupling this convention exists to avoid.
- **`params()` never affects routing.** It constrains, casts and converts
attributes after a match. A wrong declaration is a validation bug, never a
404.
- **No route table, no compile step, no cache.** Resolution is a string
derivation plus one `class_exists`. In PHP's shared-nothing model a table
must be rebuilt or reloaded on every request, and that cost dominates
matching - which is why this router is faster in practice than a cached
table-driven one.
- **Nothing may be layered onto the naming convention** to express argument
position, arity or ordering. Any such declaration is a path template in
disguise, and a path template belongs in a declared-route router, not here.
The cost of all of this is `/album/edit/1` rather than `/album/1/edit`. That
is a spelling difference, not a capability one - and it is not a deviation
from any standard. REST is Fielding's dissertation, not an RFC; RFC 3986 and
RFC 9110 both leave path structure entirely to the origin server.
- **`Phalcon\ADR\Router\Router`** - implements [`Phalcon\Contracts\ADR\Router\Router`](/5.19/api/phalcon_contracts/#contractsadrrouterrouter)
__Uses__ `Phalcon\ADR\Exceptions\ActionDirectoryNotSet` · `Phalcon\ADR\Exceptions\MethodNotAllowed` · `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Router\Router` · `Phalcon\Contracts\ADR\Router\RouterMatch` · `Phalcon\Http\RequestInterface`
### Method Summary
### Properties
protected
string
$actionDirectory = ""
protected
string
$baseNamespace = ""
protected
array
$middlewareMap = []
protected
string
$wordSeparator = "-"
### Methods
Public · 9
candidatesFor()
```php
public function candidatesFor(
string $method,
string $path
): array;
```
Every Action class this router would try for the given method and path,
in the order it tries them. The first that exists wins at match time.
Namespace descent consults the filesystem, so the list depends on the
action directory.
classFor()
```php
public function classFor(
string $method,
string $path
): string;
```
The class this convention names for a fully static path, derived without
consulting the filesystem.
candidatesFor() cannot answer this. It walks the action directory to find
where static segments end, so a path whose directories do not exist yet
yields nothing - and a generator needs the name precisely in order to
create them. Every static segment is a namespace segment, so the answer
is unambiguous and pathFor() inverts it exactly.
Placeholders are the caller's concern: pass the static prefix only.
match()
```php
public function match( RequestInterface $request ): RouterMatchInterface|null;
```
methodFor()
```php
public function methodFor( string $className ): string|null;
```
pathFor()
```php
public function pathFor( string $className ): string|null;
```
setActionDirectory()
```php
public function setActionDirectory( string $actionDirectory ): RouterInterface;
```
setBaseNamespace()
```php
public function setBaseNamespace( string $baseNamespace ): RouterInterface;
```
setMiddlewareMap()
```php
public function setMiddlewareMap( array $middlewareMap ): RouterInterface;
```
setWordSeparator()
```php
public function setWordSeparator( string $wordSeparator ): RouterInterface;
```
Protected · 9
actionParams()
```php
protected function actionParams( string $className ): array;
```
An Action's declared positional parameters, or an empty array when it
declares none.
This is what lets an argument sit *between* two static segments: the
walk needs to know how many segments a level consumes before it can
carry on matching. `params()` is static and already exists for filtering
and casting, so nothing new is asked of an Action - but declaring it now
decides routing, not just validation.
camelize()
```php
protected function camelize( string $segment ): string;
```
decamelize()
```php
protected function decamelize( string $part ): string;
```
deriveCandidates()
```php
protected function deriveCandidates(
string $method,
string $path
): array;
```
The single derivation of the routing convention.
Every static path segment becomes a namespace segment, and the class name
is the verb followed by all of those segments concatenated - so
`/company/all` is `Company\All\GetCompanyAll` and nothing else. One path
yields exactly one class, and pathFor() inverts it exactly.
Segments are consumed while the matching directory exists; whatever
remains is a dynamic argument. That walk decides where static ends and
dynamic begins - it no longer chooses between competing class shapes,
because there is only one.
hasSubNamespace()
```php
protected function hasSubNamespace( string $subNamespace ): bool;
```
locate()
```php
protected function locate(
string $method,
string $path
): array|null;
```
middlewareFor()
```php
protected function middlewareFor( string $className ): array;
```
verbOf()
```php
protected function verbOf( string $className ): string|null;
```
The class-name-form verb the given Action class carries, or null when the
class is not one this convention would have produced.
The class name is the verb followed by every namespace segment, so the
namespace alone reconstructs the static path and the class name only has
to agree with it. Anything that does not agree is not a class this
convention would ever have produced.
Shared by pathFor() and methodFor() so that rule is stated once.
verbs()
```php
protected function verbs(): array;
```
The HTTP verbs the convention recognizes, in class-name form.
## ADR\Router\RouterMatch
Final
Source on GitHub
Immutable result of a successful route match.
- **`Phalcon\ADR\Router\RouterMatch`** - implements [`Phalcon\Contracts\ADR\Router\RouterMatch`](/5.19/api/phalcon_contracts/#contractsadrrouterroutermatch)
__Uses__ `Phalcon\Contracts\ADR\ADRTypes` · `Phalcon\Contracts\ADR\Router\RouterMatch`
### Method Summary
### Properties
protected
string
$action = ""
protected
array
$attributes = []
protected
array
$middleware = []
protected
string|null
$name = null
### Methods
Public · 5
__construct()
```php
public function __construct(
string $action,
array $attributes = [],
array $middleware = [],
string|null $name = null
);
```
getAction()
```php
public function getAction(): string;
```
getAttributes()
```php
public function getAttributes(): array;
```
getMiddleware()
```php
public function getMiddleware(): array;
```
getName()
```php
public function getName(): string|null;
```
Source: https://docs.phalcon.io/5.19/api/phalcon_adr/index.mdx