Model class:

@JsonSerializable()
class EmpVerifyEntity extends Equatable {
  @JsonKey(name: "access_token")
  final String accessToken;
  final EmpVerifyEmployee employee;

  const EmpVerifyEntity(this.accessToken, this.employee);

  factory EmpVerifyEntity.fromJson(Map<String, dynamic> json) =>
      _$EmpVerifyEntityFromJson(json);

  Map<String, dynamic> toJson() => _$EmpVerifyEntityToJson(this);
  static const empty = EmpVerifyEntity(
      '123',
      EmpVerifyEmployee(
          '1', 'avatar', 'sId', 'empName', 'empId', 'designation', 1));
  @override
  String toString() {
    return jsonEncode(this);
  }

  @override
  // TODO: implement props
  List<Object?> get props => [accessToken, employee];
}

@JsonSerializable()
class EmpVerifyEmployee extends Equatable {
  @JsonKey(name: "password")
  final String password;
  final String avatar;
  @JsonKey(name: "_id")
  final String sId;
  @JsonKey(name: "emp_name")
  final String empName;
  @JsonKey(name: "emp_id")
  final String empId;
  final String designation;
  @JsonKey(name: "__v")
  final int iV;

  const EmpVerifyEmployee(this.password, this.avatar, this.sId, this.empName,
      this.empId, this.designation, this.iV);

  factory EmpVerifyEmployee.fromJson(Map<String, dynamic> json) =>
      _$EmpVerifyEmployeeFromJson(json);

  Map<String, dynamic> toJson() => _$EmpVerifyEmployeeToJson(this);
  static const empty = const EmpVerifyEmployee(
      'password', 'avatar', 'sId', 'empName', 'empId', 'designation', 1);
  @override
  String toString() {
    return jsonEncode(this);
  }

  @override
  // TODO: implement props
  List<Object?> get props =>
      [password, avatar, sId, empName, empId, designation, iV];
}

auth repo:
class AuthenticationRepository {

  Future<void> logIn({   //login process
    required String username,
    required String password,
  }) async {
    print("------------------");
    print(username);
    var res = await http.post(
        Uri.parse("https://cots.com/api/v1/employee/login"),
        headers: {
          'Content-type': 'application/json',
          'Accept': 'application/json'
        },
        body: jsonEncode({"emp_id": username, "password": password}));
    dynamic data = json.decode(res.body);
    print(data);
    if (data['employee']["is_active"] == true) {
      _controller.add(AuthenticationStatus.authenticated);///here it shows authenticated
    }
 
  }

User Repo:

class UserRepository {
  EmpVerifyEntity? _empVerifyEntity;

  UserRepository(this._empVerifyEntity);

  Future<EmpVerifyEntity?> getUser() async {
    if (_empVerifyEntity != null) {
      return _empVerifyEntity;
    }
  }
}

Auth Bloc:

class AuthenticationBloc
    extends Bloc<AuthenticationEvent, AuthenticationState> {
  AuthenticationBloc({
    required AuthenticationRepository authenticationRepository,
    required UserRepository userRepository,
  })  : _authenticationRepository = authenticationRepository,
        _userRepository = userRepository,
        super(const AuthenticationState.unknown()) {
    on<AuthenticationStatusChanged>(_onAuthenticationStatusChanged);
    on<AuthenticationLogoutRequested>(_onAuthenticationLogoutRequested);
    _authenticationStatusSubscription = _authenticationRepository.status.listen(
      (status) => add(AuthenticationStatusChanged(status)),
    );
  }

  final AuthenticationRepository _authenticationRepository;
  final UserRepository _userRepository;
  late StreamSubscription<AuthenticationStatus>
      _authenticationStatusSubscription;

  @override
  Future<void> close() {
    _authenticationStatusSubscription.cancel();
    _authenticationRepository.dispose();
    return super.close();
  }

  void _onAuthenticationStatusChanged(
    AuthenticationStatusChanged event,
    Emitter<AuthenticationState> emit,
  ) async {
    switch (event.status) {
      case AuthenticationStatus.unauthenticated:
        return emit(const AuthenticationState.unauthenticated());
      case AuthenticationStatus.authenticated:
        final user = await _tryGetUser();
        return emit(user != null
            ? AuthenticationState.authenticated(user)
            : AuthenticationState.unauthenticated());
      default:
        return emit(const AuthenticationState.unknown());
    }
  }

  void _onAuthenticationLogoutRequested(
    AuthenticationLogoutRequested event,
    Emitter<AuthenticationState> emit,
  ) {
    _authenticationRepository.logOut();
  }

  Future<EmpVerifyEntity?> _tryGetUser() async {
    try {
      final user = await _userRepository.getUser();
      return user; /////----------------Here I'm getting null as a user 
    } catch (e) {
      print(e);
    }
  }
}

I can able to do login but can't able to fetch data because it shows null, In login method I should return data so that I can able to fetch. It is authenticated but user data is null, how to pass the return data to userRepo so that I can fetch in authBloc. -------------------------------------THank you--------------------------