diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index b005b900..f6415266 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -23,6 +23,8 @@ jobs:
       - if: github.event_name != 'pull_request'
         run: rm ./.dev-tools/composer.lock
       - run: composer update --no-progress
+      - run: "sed -i 's#constant: 0#constant: 100#g' .dev-tools/phpstan.neon"
+      - run: composer apply-typed_class_constant
       - run: composer analyse
 
   test:
diff --git a/.php-cs-fixer.php b/.php-cs-fixer.php
index 9e9734e5..5c9bc939 100644
--- a/.php-cs-fixer.php
+++ b/.php-cs-fixer.php
@@ -20,6 +20,7 @@
 use PhpCsFixerCustomFixers\Fixer\NoSuperfluousConcatenationFixer;
 use PhpCsFixerCustomFixers\Fixer\PhpdocOnlyAllowedAnnotationsFixer;
 use PhpCsFixerCustomFixers\Fixer\PromotedConstructorPropertyFixer;
+use PhpCsFixerCustomFixers\Fixer\TypedClassConstantFixer;
 use PhpCsFixerCustomFixers\Fixers;
 
 // sanity check
@@ -54,6 +55,7 @@
 unset($rules['modernize_strpos']); // TODO: remove when dropping support to PHP <8.0
 unset($rules['php_unit_attributes']); // TODO: remove when dropping support to PHP <8.0
 unset($rules[PromotedConstructorPropertyFixer::name()]); // TODO: remove when dropping support to PHP <8.0
+unset($rules[TypedClassConstantFixer::name()]); // TODO: remove when dropping support to PHP <8.3
 $rules['trailing_comma_in_multiline'] = ['after_heredoc' => true, 'elements' => ['arguments', 'arrays']]; // TODO: remove when dropping support to PHP <8.0
 
 $rules[PhpdocOnlyAllowedAnnotationsFixer::name()]['elements'][] = 'phpstan-type';
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cb802792..47dee370 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # CHANGELOG for PHP CS Fixer: custom fixers
 
+## v3.26.0
+- Add TypedClassConstantFixer
+
 ## v3.25.0
 - Add ForeachUseValueFixer
 - Add NoUselessWriteVisibilityFixer
diff --git a/README.md b/README.md
index f680dde7..bcf82d7f 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 [![Latest stable version](https://img.shields.io/packagist/v/kubawerlos/php-cs-fixer-custom-fixers.svg?label=current%20version)](https://packagist.org/packages/kubawerlos/php-cs-fixer-custom-fixers)
 [![PHP version](https://img.shields.io/packagist/php-v/kubawerlos/php-cs-fixer-custom-fixers.svg)](https://php.net)
 [![License](https://img.shields.io/github/license/kubawerlos/php-cs-fixer-custom-fixers.svg)](LICENSE)
-![Tests](https://img.shields.io/badge/tests-3691-brightgreen.svg)
+![Tests](https://img.shields.io/badge/tests-3750-brightgreen.svg)
 [![Downloads](https://img.shields.io/packagist/dt/kubawerlos/php-cs-fixer-custom-fixers.svg)](https://packagist.org/packages/kubawerlos/php-cs-fixer-custom-fixers)
 
 [![CI status](https://github.com/kubawerlos/php-cs-fixer-custom-fixers/actions/workflows/ci.yaml/badge.svg)](https://github.com/kubawerlos/php-cs-fixer-custom-fixers/actions/workflows/ci.yaml)
@@ -724,6 +724,18 @@ The string key of an array or generator must be trimmed and have no double space
  ];
 ```
 
+#### TypedClassConstantFixer
+Class constants must have a type.
+```diff
+ <?php
+ class Foo {
+-    public const MAX_VALUE_OF_SOMETHING = 42;
+-    public const THE_NAME_OF_SOMEONE = 'John Doe';
++    public const int MAX_VALUE_OF_SOMETHING = 42;
++    public const string THE_NAME_OF_SOMEONE = 'John Doe';
+ }
+```
+
 
 ## Contributing
 Request a feature or report a bug by creating an [issue](https://github.com/kubawerlos/php-cs-fixer-custom-fixers/issues).
diff --git a/composer.json b/composer.json
index 7866098a..843911d3 100644
--- a/composer.json
+++ b/composer.json
@@ -39,6 +39,10 @@
             "@prepare-dev-tools",
             "php-cs-fixer fix --quiet --rules=php_unit_attributes || exit 0"
         ],
+        "apply-typed_class_constant": [
+            "@prepare-dev-tools",
+            "php-cs-fixer fix --quiet --rules=PhpCsFixerCustomFixers/typed_class_constant || exit 0"
+        ],
         "fix": [
             "@prepare-dev-tools",
             "php-cs-fixer fix --ansi --verbose || exit 0",
diff --git a/src/Fixer/TypedClassConstantFixer.php b/src/Fixer/TypedClassConstantFixer.php
new file mode 100644
index 00000000..0776e859
--- /dev/null
+++ b/src/Fixer/TypedClassConstantFixer.php
@@ -0,0 +1,201 @@
+<?php declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer: custom fixers.
+ *
+ * (c) 2018 Kuba Werłos
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace PhpCsFixerCustomFixers\Fixer;
+
+use PhpCsFixer\FixerDefinition\FixerDefinition;
+use PhpCsFixer\FixerDefinition\FixerDefinitionInterface;
+use PhpCsFixer\FixerDefinition\VersionSpecification;
+use PhpCsFixer\FixerDefinition\VersionSpecificCodeSample;
+use PhpCsFixer\Tokenizer\CT;
+use PhpCsFixer\Tokenizer\Token;
+use PhpCsFixer\Tokenizer\Tokens;
+
+final class TypedClassConstantFixer extends AbstractFixer
+{
+    private const INTEGER_KINDS = [\T_LNUMBER, '+', '-', '*', '(', ')', \T_POW, \T_SL, \T_SR, \T_LINE];
+    private const FLOAT_KINDS = [\T_DNUMBER, ...self::INTEGER_KINDS, '/'];
+    private const STRING_KINDS = [\T_CONSTANT_ENCAPSED_STRING, \T_START_HEREDOC, \T_ENCAPSED_AND_WHITESPACE, \T_END_HEREDOC, \T_LNUMBER, \T_DNUMBER, \T_CLASS_C, \T_DIR, \T_FILE, \T_FUNC_C, \T_METHOD_C, \T_NS_C, \T_TRAIT_C];
+
+    public function getDefinition(): FixerDefinitionInterface
+    {
+        return new FixerDefinition(
+            'Class constants must have a type.',
+            [
+                new VersionSpecificCodeSample(
+                    <<<'PHP'
+                        <?php
+                        class Foo {
+                            public const MAX_VALUE_OF_SOMETHING = 42;
+                            public const THE_NAME_OF_SOMEONE = 'John Doe';
+                        }
+
+                        PHP,
+                    new VersionSpecification(80300),
+                ),
+            ],
+        );
+    }
+
+    /**
+     * Must run after SingleClassElementPerStatementFixer.
+     */
+    public function getPriority(): int
+    {
+        return 0;
+    }
+
+    public function isCandidate(Tokens $tokens): bool
+    {
+        return $tokens->isAllTokenKindsFound([\T_CLASS, \T_CONST]);
+    }
+
+    public function isRisky(): bool
+    {
+        return false;
+    }
+
+    public function fix(\SplFileInfo $file, Tokens $tokens): void
+    {
+        for ($index = $tokens->count() - 1; $index > 0; $index--) {
+            if (!$tokens[$index]->isGivenKind(\T_CLASS)) {
+                continue;
+            }
+
+            $openParenthesisIndex = $tokens->getNextTokenOfKind($index, ['{']);
+            \assert(\is_int($openParenthesisIndex));
+
+            $closeParenthesisIndex = $tokens->findBlockEnd(Tokens::BLOCK_TYPE_CURLY_BRACE, $openParenthesisIndex);
+
+            self::fixClass($tokens, $openParenthesisIndex, $closeParenthesisIndex);
+        }
+    }
+
+    private static function fixClass(Tokens $tokens, int $openParenthesisIndex, int $closeParenthesisIndex): void
+    {
+        for ($index = $closeParenthesisIndex; $index > $openParenthesisIndex; $index--) {
+            if (!$tokens[$index]->isGivenKind(\T_CONST)) {
+                continue;
+            }
+
+            $constantNameIndex = $tokens->getNextMeaningfulToken($index);
+            \assert(\is_int($constantNameIndex));
+
+            $assignmentIndex = $tokens->getNextMeaningfulToken($constantNameIndex);
+            \assert(\is_int($assignmentIndex));
+
+            if (!$tokens[$assignmentIndex]->equals('=')) {
+                continue;
+            }
+
+            $expressionStartIndex = $tokens->getNextMeaningfulToken($assignmentIndex);
+            \assert(\is_int($expressionStartIndex));
+
+            if ($tokens[$expressionStartIndex]->isGivenKind(\T_NS_SEPARATOR)) {
+                $expressionStartIndex = $tokens->getNextMeaningfulToken($expressionStartIndex);
+                \assert(\is_int($expressionStartIndex));
+            }
+
+            $type = self::getTypeOfExpression($tokens, $expressionStartIndex);
+
+            $tokens->insertAt(
+                $constantNameIndex,
+                [
+                    new Token([$type === 'array' ? CT::T_ARRAY_TYPEHINT : \T_STRING, $type]),
+                    new Token([\T_WHITESPACE, ' ']),
+                ],
+            );
+        }
+    }
+
+    private static function getTypeOfExpression(Tokens $tokens, int $index): string
+    {
+        $semicolonIndex = $tokens->getNextTokenOfKind($index, [';']);
+        \assert(\is_int($semicolonIndex));
+
+        $beforeSemicolonIndex = $tokens->getPrevMeaningfulToken($semicolonIndex);
+        \assert(\is_int($beforeSemicolonIndex));
+
+        $foundKinds = [];
+
+        $questionMarkCount = 0;
+        do {
+            if ($questionMarkCount > 1) {
+                return 'mixed';
+            }
+            $kind = $tokens[$index]->getId() ?? $tokens[$index]->getContent();
+            if ($kind === '?') {
+                $questionMarkCount++;
+                $foundKinds = [];
+                continue;
+            }
+            $foundKinds[] = $kind;
+
+            $index = $tokens->getNextMeaningfulToken($index);
+            \assert(\is_int($index));
+        } while ($index < $semicolonIndex);
+
+        if ($foundKinds === [\T_STRING]) {
+            $lowercasedContent = \strtolower($tokens[$beforeSemicolonIndex]->getContent());
+            if (\in_array($lowercasedContent, ['false', 'true', 'null'], true)) {
+                return $lowercasedContent;
+            }
+        }
+
+        return self::getTypeOfExpressionForTokenKinds($foundKinds);
+    }
+
+    /**
+     * @param list<int|string> $tokenKinds
+     */
+    private static function getTypeOfExpressionForTokenKinds(array $tokenKinds): string
+    {
+        if (self::isOfTypeBasedOnKinds($tokenKinds, [], [\T_ARRAY, CT::T_ARRAY_SQUARE_BRACE_OPEN])) {
+            return 'array';
+        }
+
+        if (self::isOfTypeBasedOnKinds($tokenKinds, self::INTEGER_KINDS, [])) {
+            return 'int';
+        }
+
+        if (self::isOfTypeBasedOnKinds($tokenKinds, self::FLOAT_KINDS, [])) {
+            return 'float';
+        }
+
+        if (self::isOfTypeBasedOnKinds($tokenKinds, self::STRING_KINDS, ['.', CT::T_CLASS_CONSTANT])) {
+            return 'string';
+        }
+
+        return 'mixed';
+    }
+
+    /**
+     * @param list<int|string> $expressionTokenKinds
+     * @param list<int|string> $expectedKinds
+     * @param list<int|string> $instantWinners
+     */
+    private static function isOfTypeBasedOnKinds(
+        array $expressionTokenKinds,
+        array $expectedKinds,
+        array $instantWinners
+    ): bool {
+        foreach ($expressionTokenKinds as $index => $expressionTokenKind) {
+            if (\in_array($expressionTokenKind, $instantWinners, true)) {
+                return true;
+            }
+            if (\in_array($expressionTokenKind, $expectedKinds, true)) {
+                unset($expressionTokenKinds[$index]);
+            }
+        }
+
+        return $expressionTokenKinds === [];
+    }
+}
diff --git a/tests/Fixer/TypedClassConstantFixerTest.php b/tests/Fixer/TypedClassConstantFixerTest.php
new file mode 100644
index 00000000..c1d85a9a
--- /dev/null
+++ b/tests/Fixer/TypedClassConstantFixerTest.php
@@ -0,0 +1,345 @@
+<?php declare(strict_types=1);
+
+/*
+ * This file is part of PHP CS Fixer: custom fixers.
+ *
+ * (c) 2018 Kuba Werłos
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Tests\Fixer;
+
+/**
+ * @internal
+ *
+ * @covers \PhpCsFixerCustomFixers\Fixer\TypedClassConstantFixer
+ */
+final class TypedClassConstantFixerTest extends AbstractFixerTestCase
+{
+    public function testIsRisky(): void
+    {
+        self::assertRiskiness(false);
+    }
+
+    /**
+     * @dataProvider provideFixCases
+     *
+     * @requires PHP >= 8.3
+     */
+    public function testFix(string $expected, ?string $input = null): void
+    {
+        $this->doTest($expected, $input);
+    }
+
+    /**
+     * @return iterable<array{0: string, 1?: string}>
+     */
+    public static function provideFixCases(): iterable
+    {
+        yield 'non-class constants are ignored' => ['<?php const FOO = 1;'];
+
+        yield 'array with long syntax' => [
+            '<?php class Foo { public const array BAR = array(true, 1, "foo"); }',
+            '<?php class Foo { public const BAR = array(true, 1, "foo"); }',
+        ];
+
+        yield 'array with short syntax' => [
+            '<?php class Foo { public const array BAR = [true, 1, "foo"]; }',
+            '<?php class Foo { public const BAR = [true, 1, "foo"]; }',
+        ];
+
+        yield 'array as result of an expression' => [
+            '<?php class Foo { public const array BAR = [1 => 2] + array(3 => 4) + [5 => 6]; }',
+            '<?php class Foo { public const BAR = [1 => 2] + array(3 => 4) + [5 => 6]; }',
+        ];
+
+        yield 'array as sum of long syntax array and constant' => [
+            '<?php class Foo { public const array BAR = Baz::C + array(1); }',
+            '<?php class Foo { public const BAR = Baz::C + array(1); }',
+        ];
+
+        yield 'array as sum of short syntax array and constant' => [
+            '<?php class Foo { public const array BAR = Baz::C1 + [2] + Baz::C2; }',
+            '<?php class Foo { public const BAR = Baz::C1 + [2] + Baz::C2; }',
+        ];
+
+        yield 'false' => [
+            '<?php class Foo { public const false BAR = false; }',
+            '<?php class Foo { public const BAR = false; }',
+        ];
+
+        yield 'true' => [
+            '<?php class Foo { public const true BAR = true; }',
+            '<?php class Foo { public const BAR = true; }',
+        ];
+
+        yield 'integer' => [
+            '<?php class Foo { public const int BAR = 123; }',
+            '<?php class Foo { public const BAR = 123; }',
+        ];
+
+        yield 'integer as result of an expression' => [
+            '<?php class Foo { public const int BAR = 1 + 2 - 3 * 4; }',
+            '<?php class Foo { public const BAR = 1 + 2 - 3 * 4; }',
+        ];
+
+        yield 'integer as result of an expression with parentheses' => [
+            '<?php class Foo { public const int BAR = 1000 * (701 + 22); }',
+            '<?php class Foo { public const BAR = 1000 * (701 + 22); }',
+        ];
+
+        yield 'integer with exponentiation operator' => [
+            '<?php class Foo { public const int BAR = 2 ** 10; }',
+            '<?php class Foo { public const BAR = 2 ** 10; }',
+        ];
+
+        yield 'integer with shift left operator' => [
+            '<?php class Foo { public const int BAR = 1 << 16; }',
+            '<?php class Foo { public const BAR = 1 << 16; }',
+        ];
+
+        yield 'integer with shift right operator' => [
+            '<?php class Foo { public const int BAR = 1024 >> 1; }',
+            '<?php class Foo { public const BAR = 1024 >> 1; }',
+        ];
+
+        yield 'float' => [
+            '<?php class Foo { public const float BAR = 2.5; }',
+            '<?php class Foo { public const BAR = 2.5; }',
+        ];
+
+        yield 'float as result of expression' => [
+            '<?php class Foo { public const float BAR = 1 + (2 - 3) * 4 / 5; }',
+            '<?php class Foo { public const BAR = 1 + (2 - 3) * 4 / 5; }',
+        ];
+
+        yield 'null' => [
+            '<?php class Foo { public const null BAR = null; }',
+            '<?php class Foo { public const BAR = null; }',
+        ];
+
+        yield 'NULL' => [
+            '<?php class Foo { public const null BAR = NULL; }',
+            '<?php class Foo { public const BAR = NULL; }',
+        ];
+
+        yield 'values with a leading backslash' => [
+            <<<'PHP'
+                <?php class Foo {
+                    public const false C_FALSE = \false;
+                    public const true C_TRUE = \true;
+                    public const null C_NULL = \null;
+                }
+                PHP,
+            <<<'PHP'
+                <?php class Foo {
+                    public const C_FALSE = \false;
+                    public const C_TRUE = \true;
+                    public const C_NULL = \null;
+                }
+                PHP,
+        ];
+
+        yield 'string with double quotes' => [
+            '<?php class Foo { public const string BAR = "Jane Doe"; }',
+            '<?php class Foo { public const BAR = "Jane Doe"; }',
+        ];
+
+        yield 'string with single quotes' => [
+            "<?php class Foo { public const string BAR = 'John Doe'; }",
+            "<?php class Foo { public const BAR = 'John Doe'; }",
+        ];
+
+        yield 'binary string' => [
+            '<?php class Foo { public const string BAR = b"Jane Doe"; }',
+            '<?php class Foo { public const BAR = b"Jane Doe"; }',
+        ];
+
+        yield 'string with heredoc syntax' => [
+            <<<'PHP'
+                <?php class Foo {
+                    public const string BAR = <<<STRING
+                        the content
+                    STRING;
+                }
+                PHP,
+            <<<'PHP'
+                <?php class Foo {
+                    public const BAR = <<<STRING
+                        the content
+                    STRING;
+                }
+                PHP,
+        ];
+
+        yield 'string with nowdoc syntax' => [
+            <<<'PHP'
+                <?php class Foo {
+                    public const string BAR = <<<'STRING'
+                        the content
+                    STRING;
+                }
+                PHP,
+            <<<'PHP'
+                <?php class Foo {
+                    public const BAR = <<<'STRING'
+                        the content
+                    STRING;
+                }
+                PHP,
+        ];
+
+        yield 'string as reference to other class' => [
+            <<<'PHP'
+                <?php class Foo {
+                    public const string BAR = FooFoo::class;
+                    public const mixed BAZ = CONFIG_66 ? FooFoo::class : -1;
+                }
+                PHP,
+            <<<'PHP'
+                <?php class Foo {
+                    public const BAR = FooFoo::class;
+                    public const BAZ = CONFIG_66 ? FooFoo::class : -1;
+                }
+                PHP,
+        ];
+
+        yield 'string as magic constant' => [
+            <<<'PHP'
+                <?php class Foo {
+                    public const string C1 = __CLASS__;
+                    public const string C2 = __DIR__;
+                    public const string C3 = __FILE__;
+                    public const string C4 = __FUNCTION__;
+                    public const int C5 = __LINE__;
+                    public const float C5_HALF = __LINE__ / 2;
+                    public const string C6 = __METHOD__;
+                    public const string C7 = __NAMESPACE__;
+                    public const string C8 = __TRAIT__;
+                }
+                PHP,
+            <<<'PHP'
+                <?php class Foo {
+                    public const C1 = __CLASS__;
+                    public const C2 = __DIR__;
+                    public const C3 = __FILE__;
+                    public const C4 = __FUNCTION__;
+                    public const C5 = __LINE__;
+                    public const C5_HALF = __LINE__ / 2;
+                    public const C6 = __METHOD__;
+                    public const C7 = __NAMESPACE__;
+                    public const C8 = __TRAIT__;
+                }
+                PHP,
+        ];
+
+        yield 'string as result of concatenations with parentheses' => [
+            '<?php class Foo { public const string BAR = "A" . 1 . ("B" . 0.25) . "C"; }',
+            '<?php class Foo { public const BAR = "A" . 1 . ("B" . 0.25) . "C"; }',
+        ];
+
+        yield 'string as result of concatenation with other constant' => [
+            '<?php class Foo { public const string BAR = "A" . Baz::C; }',
+            '<?php class Foo { public const BAR = "A" . Baz::C; }',
+        ];
+
+        yield 'multiple constants' => [
+            <<<'PHP'
+                <?php
+                class Foo {
+                    public const int ONE = 1;
+                    protected const bool|float ALREADY_TYPED = true;
+                    private const string NAME = 'name';
+                }
+                const NOT_CLASS = true;
+                class Bar {
+                    const array ARRAY_LONG_SYNTAX = array();
+                    const array ARRAY_SHORT_SYNTAX = [];
+                    const string lowercased_name = 'lowercased_name';
+                }
+                PHP,
+            <<<'PHP'
+                <?php
+                class Foo {
+                    public const ONE = 1;
+                    protected const bool|float ALREADY_TYPED = true;
+                    private const NAME = 'name';
+                }
+                const NOT_CLASS = true;
+                class Bar {
+                    const ARRAY_LONG_SYNTAX = array();
+                    const ARRAY_SHORT_SYNTAX = [];
+                    const lowercased_name = 'lowercased_name';
+                }
+                PHP,
+        ];
+
+        yield 'anonymous class' => [
+            '<?php new class () { public const int BAR = 0; };',
+            '<?php new class () { public const BAR = 0; };',
+        ];
+
+        yield 'unknown other constant' => [
+            '<?php class Foo { public const mixed BAR = CONSTANT_FROM_FAR_AWAY; }',
+            '<?php class Foo { public const BAR = CONSTANT_FROM_FAR_AWAY; }',
+        ];
+
+        yield 'expression of unknown type' => [
+            '<?php class Foo { public const mixed BAR = 10 * FLOAT_OR_INTEGER + 3; }',
+            '<?php class Foo { public const BAR = 10 * FLOAT_OR_INTEGER + 3; }',
+        ];
+
+        yield 'constants that can be of different types' => [
+            <<<'PHP'
+                <?php class Foo {
+                    public const mixed BAR = SHOULD_BE_INT ? 1 : ["one"];
+                    public const mixed BAZ = NAME === 'A' . 'b' ? 1 : ["one"];
+                }
+                PHP,
+            <<<'PHP'
+                <?php class Foo {
+                    public const BAR = SHOULD_BE_INT ? 1 : ["one"];
+                    public const BAZ = NAME === 'A' . 'b' ? 1 : ["one"];
+                }
+                PHP,
+        ];
+
+        yield 'constant that can be of different types - more complex case' => [
+            <<<'PHP'
+                <?php
+                class HellCoreServiceManagerHelper
+                {
+                    const mixed OPTION_666__YES__1010011010_VALUE_4_1_3
+                        = IS_OVERRIDEN_BY_BEELZEBOSS
+                            ? "Hell yeah"
+                            : CIRCLES_MANAGER_ACCESS === [0o1232, 'super_manager', false, -66.6]
+                                ? true
+                                : HellComponent443556::SHOULDNT_NOT_BE_DIFFERENT_THAN_NULL
+                                    ? null
+                                    : 0.001;
+                }
+                PHP,
+            <<<'PHP'
+                <?php
+                class HellCoreServiceManagerHelper
+                {
+                    const OPTION_666__YES__1010011010_VALUE_4_1_3
+                        = IS_OVERRIDEN_BY_BEELZEBOSS
+                            ? "Hell yeah"
+                            : CIRCLES_MANAGER_ACCESS === [0o1232, 'super_manager', false, -66.6]
+                                ? true
+                                : HellComponent443556::SHOULDNT_NOT_BE_DIFFERENT_THAN_NULL
+                                    ? null
+                                    : 0.001;
+                }
+                PHP,
+        ];
+
+        yield 'make multiple constants definition statement mixed type even if of single type' => [
+            '<?php class Foo { public const mixed BAR = 1, BAZ = 2; }',
+            '<?php class Foo { public const BAR = 1, BAZ = 2; }',
+        ];
+    }
+}
diff --git a/tests/PriorityTest.php b/tests/PriorityTest.php
index 322bb6bb..19a15075 100644
--- a/tests/PriorityTest.php
+++ b/tests/PriorityTest.php
@@ -28,7 +28,7 @@
  *
  * @coversNothing
  *
- * @requires PHP >= 8.1
+ * @requires PHP >= 8.3
  */
 final class PriorityTest extends TestCase
 {
diff --git a/tests/priority_fixtures/single_class_element_per_statement,Custom_typed_class_constant.test b/tests/priority_fixtures/single_class_element_per_statement,Custom_typed_class_constant.test
new file mode 100644
index 00000000..fabde4a5
--- /dev/null
+++ b/tests/priority_fixtures/single_class_element_per_statement,Custom_typed_class_constant.test
@@ -0,0 +1,14 @@
+--CONFIGURATION--
+{ "single_class_element_per_statement": true, "PhpCsFixerCustomFixers/typed_class_constant": true }
+--EXPECTED--
+<?php
+class Foo {
+    const int BAR = 1;
+    const string BAZ = "two";
+}
+
+--INPUT--
+<?php
+class Foo {
+    const BAR = 1, BAZ = "two";
+}