Phalcon events

/**
 * @var ManagerInterface|null
 */
protected $eventsManager;

public function getEventsManager(): ManagerInterface | null;

public function setEventsManager( ManagerInterface $eventsManager ): void;

protected function fireManagerEvent( string $eventName, mixed $data = null, bool $cancellable = bool ): mixed | bool;

Phalcon\Events\Event;

$event = new Event("db:afterQuery", $this, ["data" => "mydata"], true);
if ($event->isCancelable()) {
    $event->stop();
}

/**
 * Is event cancelable?
 *
 * @var bool
 */
protected $cancelable;

/**
 * Event data
 *
 * @var mixed
 */
protected $data;

/**
 * Event source
 *
 * @var object|null
 */
protected $source;

/**
 * Is event propagation stopped?
 *
 * @var bool
 */
protected $stopped = false;

/**
 * Event type
 *
 * @var string
 */
protected $type;

public function __construct( string $type, mixed $source = null, mixed $data = null, bool $cancelable = bool );

public function getData(): mixed;

public function getSource(): object | null;

public function getType(): string;

public function isCancelable(): bool;

if ($event->isCancelable()) {
    $event->stop();
}

public function isPropagationStopped(): bool;

public function isStopped(): bool;

public function setData( mixed $data = null ): EventInterface;

public function setType( string $type ): EventInterface;

public function stop(): EventInterface;

if ($event->isCancelable()) {
    $event->stop();
}

/**
 * @var bool
 */
protected $collect = false;

/**
 * @var bool
 */
protected $enablePriorities = false;

/**
 * Re-entrancy depth of fire()/fireAll(). 0 means no fire is in
 * progress. Incremented on every fire entry, decremented on exit.
 * Used to keep nested fire() calls from clobbering the outer
 * caller's `$this->responses` accumulator.
 *
 * @var int
 */
protected $fireDepth = ;

/**
 * Manager-level kill switch. When true, every fire()/fireAll()/
 * fireQueue() call returns immediately (null or empty array) without
 * dispatching. Cleared by resume(). Survives across fire() calls,
 * unlike Event::stop() which only stops the current dispatch chain.
 *
 * @var bool
 */
protected $halted = false;

/**
 * When true, a listener returning literal `false` (with the event's
 * `cancelable` flag on) short-circuits the dispatch loop and pins
 * the fire() return as `false`. Default off — preserves the pre-5.13
 * "last-wins" contract for codebases that rely on later listeners
 * overriding an earlier false return [#17019].
 *
 * @var bool
 */
protected $stopOnFalse = false;

/**
 * When true, fire()/fireAll() throw on dispatch of an event that
 * has zero matching listeners. Catches typos in dev. Default off.
 *
 * @var bool
 */
protected $strict = false;

/**
 * Parsed-eventType cache. Memoizes the strpos + substr work done in
 * fire() so the same event name fired repeatedly (the common case
 * for db:beforeQuery, model:afterSave, etc.) collapses to a single
 * hash lookup.
 *
 * Shape: `eventNameCache[$eventType] = [typePrefix, eventName]`
 *
 * Unbounded by design — distinct event types in a typical Phalcon
 * application are well under 100 keys, and the cache never needs
 * invalidation (parse is deterministic for a given eventType string).
 *
 * @var array
 */
protected $eventNameCache;

/**
 * Memoized method_exists() results for the OBJECT_METHOD dispatch
 * path in dispatch(). Keyed by `handlerClass => [methodName => bool]`.
 * A class doesn't gain methods at runtime so the lookup is permanent.
 *
 * @var array
 */
protected $methodExistsCache;

/**
 * Memoized getSubscribedEvents() maps keyed by Subscriber class name.
 * The static method's return is stable for the lifetime of a class
 * definition, so the cache never needs invalidation.
 *
 * @var array
 */
protected $subscriberEventsCache;

/**
 * Listener storage. Shape:
 *
 *   events[$eventType] = [
 *       [handler, type, priority]            // types 0, 1, 3
 *       [handler, type, priority, className] // type 2 carries
 *                                            // resolved class name
 *       ...
 *   ]
 *
 * Kept sorted by priority descending when priorities are enabled
 * (FIFO within the same priority); otherwise listeners are simply
 * appended in attach order.
 *
 * `type` is classified once at attach() time so dispatch() can
 * route via a simple branch:
 *
 *   0 — Closure: direct invocation via `{handler}(args)`, no
 *       arg-array alloc per call
 *   1 — [obj, method] array callable: direct dynamic dispatch
 *       `handler[0]->{handler[1]}(args)`
 *   2 — plain object: dynamic dispatch via method named after the
 *       event (the classic Phalcon listener pattern); class name is
 *       captured at attach time to skip get_class() per fire
 *   3 — generic callable (string fn name, invokable object,
 *       [class, staticMethod]): call_user_func_array
 *
 * @var array
 */
protected $events;

/**
 * @var array
 */
protected $responses;

/**
 * @var array
 */
protected $subscribers;

public function addSubscriber( Subscriber $subscriber ): void;

public function arePrioritiesEnabled(): bool;

final public function attach( string $eventType, mixed $handler, int $priority = static-constant-access ): void;

public function clearSubscribers(): void;

public function collectResponses( bool $collect ): void;

public function detach( string $eventType, mixed $handler ): void;

public function detachAll( string $type = null ): void;

public function enablePriorities( bool $enablePriorities ): void;

final public function fire( string $eventType, object $source, mixed $data = null, bool $cancelable = bool );

$eventsManager->fire("db", $connection);

public function fireAll( string $eventType, object $source, mixed $data = null, bool $cancelable = bool ): array;

$results = $eventsManager->fireAll("db:beforeQuery", $connection);

final public function fireQueue( array $queue, EventInterface $event );

public function getListeners( string $type ): array;

public function getResponses(): array;

public function getSubscribers(): array;

public function halt(): void;

public function hasListeners( string $type ): bool;

public function isCollecting(): bool;

public function isHalted(): bool;

public function isStopOnFalse(): bool;

public function isStrict(): bool;

public function isValidHandler( mixed $handler ): bool;

public function removeSubscriber( Subscriber $subscriber ): void;

public function resume(): void;

public function setStopOnFalse( bool $flag ): void;

public function setStrict( bool $strict ): void;