// config/app.php

use Burzum\CakeServiceLayer\Annotator\ClassAnnotatorTask\ServiceAwareClassAnnotatorTask;
use Burzum\CakeServiceLayer\Generator\Task\ServiceTask;
use Cake\Cache\Engine\FileEngine;
use Cake\Database\Connection;
use Cake\Database\Driver\Mysql;
use Cake\Log\Engine\FileLog;
use Cake\Mailer\Transport\MailTransport;

  'IdeHelper' => [
        'generatorTasks' => [
            ServiceTask::class
        ],
        'classAnnotatorTasks' => [
            ServiceAwareClassAnnotatorTask::class
        ],
    ],

// src/Application.php

use Authentication\AuthenticationService;
use Authentication\AuthenticationServiceInterface;
use Authentication\AuthenticationServiceProviderInterface;
use Authentication\Identifier\IdentifierInterface;
use Authentication\Middleware\AuthenticationMiddleware;
use Cake\Core\Configure;
use Cake\Core\ContainerInterface;
use Cake\Datasource\FactoryLocator;
use Cake\Error\Middleware\ErrorHandlerMiddleware;
use Cake\Http\BaseApplication;
use Cake\Http\Middleware\BodyParserMiddleware;
use Cake\Http\Middleware\CsrfProtectionMiddleware;
use Cake\Http\MiddlewareQueue;
use Cake\ORM\Locator\TableLocator;
use Cake\Routing\Middleware\AssetMiddleware;
use Cake\Routing\Middleware\RoutingMiddleware;
use Cake\Routing\Router;
use Psr\Http\Message\ServerRequestInterface;


    public function bootstrap(): void
    {
        // Call parent to load bootstrap from files.
        parent::bootstrap();

        if (PHP_SAPI === 'cli') {
            $this->bootstrapCli();
            try {
                $this->addPlugin('IdeHelper');
            } catch (\Throwable $e) {
            }
        } else {
            FactoryLocator::add(
                'Table',
                (new TableLocator())->allowFallbackClass(false)
            );
        }

        /*
         * Only try to load DebugKit in development mode
         * Debug Kit should not be installed on a production system
         */
        if (Configure::read('debug')) {
            $this->addPlugin('DebugKit');
        }

        // Load more plugins here
        $this->addPlugin('Authentication');
        $this->addPlugin('BootstrapUI');
        $this->addPlugin('Cake/Queue');
        $this->addPlugin('Muffin/Trash'); // soft-deletion
        $this->addPlugin('Burzum/CakeServiceLayer');
    }

// src/Service/MyUsersService.php

<?php

declare(strict_types=1);

namespace App\Service;

// use App\Model\Table\UsersTable;
use Burzum\CakeServiceLayer\Service\ServiceAwareTrait;
use Cake\Http\ServerRequest;
use Cake\ORM\Locator\LocatorAwareTrait;

class MyUsersService
{
    use LocatorAwareTrait, ServiceAwareTrait;

    protected $request;
    protected $Users;

    public function __construct(ServerRequest &$request)
    {
        $this->request = $request;
        $this->loadService('Pagination', [$request]);
        // $this->loadModel('Users'); // Undefined method loadModel I'm using CakePHP 4.4.15
        $this->Users = $this->fetchTable('Users');
    }

    public function getListForUser($userId, $queryParams)
    {
        $query = $this->Users->find();
        return $this->Pagination->paginate($query, $queryParams); // here I get the Intelliphense message : Undefined Property '$Pagination'.
    }
}

// src/Controller/UsersController.php

    use MailerAwareTrait, ServiceAwareTrait;

    public const ACT_NOTIFY = 'notify';
    public const ACT_IMPERSONATE = 'impersonate';

    public function initialize(): void
    {
        parent::initialize();

        $this->loadService('MyUsers', [$this->getRequest()]);
        $this->paginate += [
            'contain' => ['Roles'],
            'limit' => 3, // 20 by default
        ];
    }

    public function index()
    {
        $users =
            $this->MyUsers->getListForUser(
                $this->getLoggedInUserAsUser()->id,
                $this->getRequest()
            );
        $this->set('users', 'paginationKeys');
    }

$connection = new Guzzle();
$git = new Git($connection);
$releaser = new Releaser($git, $this->getMailer('Notification'));
...

$releaser = $this->loadService('Releaser');
...

$git = $this->getMockBuilder(Git::class)->dis...->getMock();
$git->expects($this->once())->method('moduleExists')->willReturn(true);

$mailer = $this->getMockBuilder(Mailer::class)->getMock();
$releaser = new Releaser($git, $mailer);
...

namespace App\Test\TestCase\Controller;

use App\Controller\DemoController;
use App\Service\Bar\BazService;
use Burzum\Cake\TestSuite\MockedServiceLocator;
use Cake\Core\Configure;
use Cake\TestSuite\IntegrationTestCase;

    /**
     * Test index method
     *
     * @return void
     */
    public function testIndex()
    {
        $this->disableErrorHandlerMiddleware();

        $this->get('/demo');

        $this->assertResponseCode(200);

        $x = Configure::read('test-string');
        $this->assertSame('original', $x);
    }

    /**
     * Test index method
     *
     * @return void
     */
    public function testIndexMocked()
    {
        $this->disableErrorHandlerMiddleware();

        $mockedService = $this->getMockBuilder(BazService::class)->setMethods(['doSth'])->getMock();
        $mockedService->expects($this->once())->method('doSth')->willReturn('faked');

        Configure::write('Services.' . 'Bar/Baz', $mockedService);

        $this->get('/demo');

        $this->assertResponseCode(200);

        $x = Configure::read('test-string');
        $this->assertSame('faked', $x);
    }

    /**
     * Test index method
     *
     * @return void
     */
    public function testIndexMockedAlternative()
    {
        DemoController::setDefaultServiceLocator(MockedServiceLocator::class);

        $this->disableErrorHandlerMiddleware();

        $mockedService = $this->getMockBuilder(BazService::class)->setMethods(['doSth'])->getMock();
        $mockedService->expects($this->once())->method('doSth')->willReturn('faked');

        MockedServiceLocator::mock(BazService::class, $mockedService);

        $this->get('/demo');

        $this->assertResponseCode(200);

        $x = Configure::read('test-string');
        $this->assertSame('faked', $x);
    }

class HandsetsService
{
    use ModelAwareTrait;
    use ServicePaginatorTrait;

    /**
     * @var \Cake\ORM\Table
     */
    protected $Handsets;

    /**
     * Constructor
     */
    public function __construct()
    {
        $this->initialize();
    }

    /**
     * Initialize
     *
     * @return void
     */
    public function initialize()
    {
        $this->Handsets = $this->loadModel('Handsets');
    }

    /**
     * Listagem paginada dos aparelhos
     *
     * @return \Cake\Datasource\ResultSetInterface|array
     */
    public function listing()
    {
        $query = $this->Handsets->find('enableds');
        $query->contain(['Users']);

        $result = $this->paginate($query);

        return $result;
    }
}

class HandsetsController extends AppController
{
    use ServiceAwareTrait;

    public function initialize(): void
    {
        $this->loadService('Handsets');
    }

    /**
     * Index method
     *
     * @return \Cake\Http\Response|null|void Renders view
     */
    public function index()
    {
        $handsets = $this->Handsets->listing();

        $this->set(compact('handsets'));
    }
}

$eventManager = EventManager::instance();
$eventManager->on('Controller.initialize', function ($event) use ($eventManager) {
    $controller = $event->getSubject();
    $eventManager->on('Service.afterPaginate', function ($event) use ($controller) {
        $controller->setRequest($event->getSubject()->addPagingParamToRequest($controller->getRequest()));
    });
});

EventManager::instance()->on('Controller.initialize', function ($event) {
    $controller = $event->getSubject();
    $controller->getEventManager()->on('Service.afterPaginate', function ($event) use ($controller) {
        $controller->setRequest($event->getSubject()->addPagingParamToRequest($controller->getRequest()));
    });
});

if (isset($this->{$name})) {
    //trigger_error(__CLASS__ . '::$%s is already in use.', E_USER_WARNING);
    return $this->{$name};
}