dans le cadre d'une création d'une library "PlayerManagement" j'ai une erreur que je ne m'explique pas "GameStatus" "Identifier not found or not unique.(7920)
State Variable: status". GameStatus est aussi dans la contrat principal, est-ce pour cela ? voici le code de la librairie : "/ SPDX-License-Identifier: UNLICENSED
 
pragma solidity 0.8.17;

library PlayerManagement {

   
    address public player1;
    address public player2;
    address activePlayer;
    uint256 public gameId = 0;
    uint public pot;
    GameStatus public status;

    struct Game {
        address player1;
        address player2;
        uint256 gameId;
        uint256 turn; 
    }


    event GameCreated(uint256 indexed gameId, address indexed player1, address indexed player2);
    event GameJoined(uint256 indexed _gameId, address indexed player2, address indexed player1);
    event PlayerSwitched(uint256 gameId, address indexed player1, address indexed player2);

   /**
     * @notice  permet au joueur 1 de créer une nouvelle partie en effectuant une mise
     * @dev     elle met à jour le joueur 1, la mise, l'ID de la partie et l'état de la partie
     * @dev     elle crée un nouvel objet Game en mémoire avec les informations pertinentes et ajoute la partie au mapping games
     * @dev     msg.sender L'adresse de l'émetteur de la transaction (joueur 1)
     * @dev     msg.value La valeur (en wei) transférée lors de l'appel de la fonction  
     * @dev     émet un événement pour la création du jeu (identifiant de la partie, adresse du joueur1 et adresse vide du joueur 2)
     * @return  identifiant unique de la partie créée
     */
    function createGame() external payable returns (uint256) {
        require(status == GameStatus.waitingForPlayers, "Le jeu est en cours de creation");
        require(msg.sender != player1, "Vous etes le createur de la partie");
        require(pot > 0, "Le montant de la mise doit etre > a 0");
        player1 = msg.sender;
        pot = msg.value;
        gameId++;
        status = GameStatus.waitingForRandomWord; 

        Game memory newGame;
        newGame.player1 = player1;
        newGame.gameId = gameId;
        games[gameId] = newGame;

        gameBalances[gameId][player1] = pot;

        emit GameCreated(gameId, player1, address(0));
        emit BalanceDeposited(player1, msg.value);
        return gameId;
    }
    /** 
     * @notice  permet au joueur 2 de rejoindre une partie existante identifié par gameId en effectuant une mise égale au montant de la mise
     * @dev     elle récupère les références de jeu, elle vérifie si la partie existe, est en attente de joueur et n'est pas déjà rejointe 
     * @dev     par un joueur, vérifie si le montant est égal à la mise...
     * @dev     si le montant envoyé par le joueur 2 dépasse la mise du jeu, le montant excédentaire lui est remboursé et la balance est mise à jour 
     * @dev     Mise à jour du solde du jeu en ajoutant le montant envoyé par le joueur 2 et enregistrement de l'adresse du joueur 2 dans le jeu 
     * @dev     et mise à jour du joueur 2 dans le contrat principal - changement du statut de la partie pour indiquer qu'elle attend un mot aléatoire
     * @dev     ajout du montant envoyé par le joueur 2 au solde du jeu
     * @dev     inversement des rôles pour que le joueur 2 puisse jouer en premier
     * @dev     mise à jour des adresses player 1 et player 2 et du mapping balances d'une partie spécifiée
     * @param   _gameId l'identifiant du jeu auquel le joueur 2 souhaite se joindre
     */
    function joinGame(uint256 _gameId) external payable returns (bool) {
        Game storage game = games[_gameId];
        require(game.player1 != address(0), "l'adresse du joueur 1 n'est pas valide");
        require(status == GameStatus.waitingForPlayers, "La partie n'attend pas de joueurs");
        require(msg.sender != game.player1, "Vous etes deja inscrit");
   
        uint256 refundAmount = 0;
        if (msg.value > gameBalances[_gameId][game.player1]) {
            refundAmount = msg.value - gameBalances[_gameId][game.player1];
            gameBalances[_gameId][game.player2] = msg.value - refundAmount;
            payable(msg.sender).transfer(refundAmount);
        } else {
            require(msg.value == gameBalances[_gameId][game.player1], "Le montant envoye doit etre = a la mise ");
            gameBalances[_gameId][game.player2] = msg.value; // mise du joueur 2
        }
        require(game.player2 == address(0), "La partie a deja un joueur");
        // Mettre à jour les adresses des joueurs
        game.player2 = msg.sender;
        gameBalances[_gameId][game.player2] += msg.value;

        status = GameStatus.waitingForRandomWord;

        emit PlayerSwitched(_gameId, player1, player2);
        emit GameJoined(_gameId, player2, player1);

        return true;
    }
    /**
     * @notice  permet d'échanger les rôles des joueurs dans un jeu spécifié
     * @dev     la fonction est utilisée pour échanger les rôles des joueurs dans le jeu identifié par l'identifiant _gameId
     * @param   _gameId identifiant du jeu dans lequel les rôles des joueurs doivent être échangés
     */
    function playersSwitched(uint256 _gameId) internal {
        Game storage game = games[_gameId];
        require(msg.sender == game.player1 || msg.sender == game.player2, "Vous n'etes pas un joueur dans ce jeu");

        address player1Address = game.player1;
        game.player1 = game.player2;
        game.player2 = player1Address;
        
        emit PlayerSwitched(_gameId, game.player1, game.player2);
    }
     /**
     * @notice  permet d'obtenir l'adresse du joueur actif dans un jeu spécifique
     * @dev     elle est utilisée en interne par les fonctions setLetterGuess, setWordGuess
     * @dev     et endGame pour obtenir l'adresse du joueur actif en fonction de l'état du jeu
     * @dev     Si le nombre de mouvements est pair, cela signifie que le joueur 1 a déjà joué et 
     * @dev     c'est maintenant au tour du joueur 2. Si le nombre de mouvements est impair, c'est le tour du joueur 1
     * @param   _gameId identifiant du jeu pour lequel récupérer le joueur actif
     * @return  adresse du joueur actif. Si aucun joueur actif n'est trouvé ou si l'identifiant du jeu 
     *           est invalide, renvoie address(0).
     */
    function getActivePlayer(uint256 _gameId) internal view returns (address) {
        Game storage game = games[_gameId];

        if (game.player1 != address(0) && game.player2 == address(0)) {
            return game.player1;
        } else if (game.player1 != address(0) && game.player2 != address(0)) {
            if (status == GameStatus.waitingForRandomWord) {
                return address(this);
            } else if (status == GameStatus.inProgress) {
                if (game.turn % 2 == 0) {
                    require(msg.sender == game.player1, "Vous n'etes pas le joueur dans ce jeu");
                    return game.player1;
                } else {
                    require(msg.sender == game.player2, "Vous n'etes pas le joueur dans ce jeu");
                    return game.player2;
                }
            }
        }
        return address(0);
    }
     /**
     * @notice  permet de récupérer le nombre de mouvements effectués dans un jeu spécifié
     * @dev     elle renvoie le nombre de mouvements effectués dans le jeu spécifié, permettant
     * @dev     ainsi de suivre l'avancement du jeu et de déterminer quel joueur est censé jouer ensuite
     * @dev     elle est utilisée en interne par la fonction getActivePlayer 
     * @param   _gameId identifiant du jeu pour lequel récupérer le nombre de mouvements
     * @return  nombre de mouvements effectués dans le jeu spécifié
     */
    function turnPlayer(uint256 _gameId) internal view returns (uint256) {
        Game memory game = games[_gameId];
        return game.turn;
    }

}"