Could you translate this http client php symfony using kotlin spring boot feign client, forget about the interface PingableTrackingPlatformClientInterface and his methods (doHealthcheck / getTrackingPlatformName): 

<?php

declare(strict_types=1);

namespace App\Infra\TrackingPlatform\Aftership\Client;

use App\Domain\Model\TrackingMethod\TrackingPlatform;
use App\Infra\TrackingPlatform\Aftership\Client\Exception\AftershipException;
use App\Infra\TrackingPlatform\Aftership\Client\Exception\AftershipResponseException;
use App\Infra\TrackingPlatform\PingableTrackingPlatformClientInterface;
use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use Manomano\AvailabilityBundle\Health\Check\HealthCheckResponse;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\NullLogger;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

class AftershipHttpClient implements PingableTrackingPlatformClientInterface, LoggerAwareInterface
{
    use LoggerAwareTrait;

    public function __construct(protected Client $client)
    {
        $this->setLogger(new NullLogger());
    }

    /**
     * @param array<string, mixed> $trackingData
     *
     * @throws AftershipException
     * @throws AftershipResponseException
     *
     * @return array<string, mixed>
     */
    public function createTracking(array $trackingData): array
    {
        // sanitizing string values by trimming spaces
        $trackingData = array_map(
            static fn ($trackingDataValue) => \is_string($trackingDataValue) ? trim($trackingDataValue) : $trackingDataValue,
            $trackingData
        );

        $response = $this->doRequest(Request::METHOD_POST, 'trackings', $trackingData);

        return $this->getTrackingContent($response);
    }

    /**
     * @param array<string, mixed> $optionalParameters
     *
     * @throws AftershipException
     * @throws AftershipResponseException
     *
     * @return array<string, mixed>
     */
    public function getTrackingBySlugAndTrackingNumber(
        string $slug,
        string $trackingNumber,
        array $optionalParameters = []
    ): array {
        $url = sprintf(
            'trackings/%s/%s?%s',
            urlencode($slug),
            urlencode($trackingNumber),
            http_build_query($optionalParameters)
        );
        $response = $this->doRequest(Request::METHOD_GET, $url);

        return $this->getTrackingContent($response);
    }

    /**
     * @throws AftershipException
     * @throws AftershipResponseException
     *
     * @return array<string, mixed>
     */
    public function getTracking(string $id): array
    {
        $url = sprintf('trackings/%s', $id);
        $response = $this->doRequest(Request::METHOD_GET, $url);

        return $this->getTrackingContent($response);
    }

    public function doHealthCheck(): HealthCheckResponse
    {
        try {
            $response = $this->doRequest(Request::METHOD_GET, '');
            if (Response::HTTP_OK !== $response->getStatusCode()) {
                throw new \Exception(
                    sprintf('The healthcheck failed with a %d status code.', $response->getStatusCode())
                );
            }
        } catch (\Exception $exception) {
            return HealthCheckResponse::down($this->getTrackingPlatformName(), $exception->getMessage());
        }

        return HealthCheckResponse::up($this->getTrackingPlatformName());
    }

    /**
     * @throws AftershipException
     *
     * @return array<string, mixed>
     */
    public function getCouriers(): array
    {
        $response = $this->doRequest(Request::METHOD_GET, 'couriers');

        /**
         * @var array{
         *      data: array{couriers: array<string,mixed>}
         * } $content
         */
        $content = json_decode((string) $response->getBody(), true, 512, \JSON_THROW_ON_ERROR);

        return $content['data']['couriers'];
    }

    /**
     * @throws AftershipException
     *
     * @return array<string, mixed>
     */
    public function getAllCouriers(): array
    {
        $response = $this->doRequest(Request::METHOD_GET, 'couriers/all');

        /**
         * @var array{
         *      data: array{couriers: array<string,mixed>}
         * } $content
         */
        $content = json_decode((string) $response->getBody(), true, 512, \JSON_THROW_ON_ERROR);

        return $content['data']['couriers'];
    }

    public function getTrackingPlatformName(): string
    {
        return TrackingPlatform::aftership()->getName();
    }

    /**
     * @param array<string, mixed> $requestBody
     *
     * @throws AftershipException
     * @throws AftershipResponseException
     */
    private function doRequest(string $method, string $uri, ?array $requestBody = null): ResponseInterface
    {
        try {
            $response = $this->client->request(
                $method,
                $uri,
                null !== $requestBody ? ['json' => $requestBody] : []
            );
        } catch (RequestException $e) {
            if (null === ($response = $e->getResponse())) {
                throw new AftershipException(sprintf('Aftership API request failed: "%s"', $e->getMessage()), 0, $e);
            }

            $this->handleResponseError($response, $e);
        } catch (\Throwable $e) {
            $this->logger->debug(
                sprintf('[AfterShipHttpClient] Error while requesting API: "%s"', $e->getMessage()),
                [
                    'exception' => $e,
                    'exception_message' => $e->getMessage(),
                    'aftership_request_method' => $method,
                    'aftership_request_uri' => $uri,
                    'aftership_request_body' => json_encode($requestBody, \JSON_THROW_ON_ERROR),
                ]
            );

            throw new AftershipException(sprintf('Aftership API request failed: "%s"', $e->getMessage()), 0, $e);
        }

        return $response;
    }

    /**
     * @return array<string, mixed>
     */
    private function getTrackingContent(ResponseInterface $response): array
    {
        /**
         * @var array<string,mixed> $content
         */
        $content = json_decode((string) $response->getBody(), true);

        return isset($content['data']) && \is_array($content['data'])
                ? $content['data']
                : [];
    }

    /**
     * @throws AftershipException
     * @throws AftershipResponseException
     */
    private function handleResponseError(ResponseInterface $response, RequestException $e): void
    {
        /**
         * @var null|array{
         *     data: array{
         *           id: string|null
         *      },
         *     meta: array{
         *          code: int|null,
         *          message: string|null
         *     }
         * } $content
         */
        $content = json_decode((string) $response->getBody(), true, 512, \JSON_THROW_ON_ERROR);
        if (null === $content) {
            throw new AftershipException(
                sprintf('Aftership API response is empty, received HTTP error code "%d"', $response->getStatusCode()),
                $response->getStatusCode(),
                $e
            );
        }

        $responseException = new AftershipResponseException(response: $content, previous: $e);

        $this->logger->debug(
            sprintf('[AfterShipHttpClient] %s', $responseException->getMessage()),
            [
                'exception_message' => $e->getMessage(),
                'aftership_error_code' => $responseException->getErrorCode(),
                'aftership_error_message' => $responseException->getMessage(),
                'aftership_request_method' => $e->getRequest()->getMethod(),
                'aftership_request_uri' => $e->getRequest()->getUri(),
                'aftership_request_body' => (string) $e->getRequest()->getBody(),
            ]
        );

        throw $responseException;
    }
}