How to fix 'noImplicitOverride' requires 'noImplicitThis' in TypeScript

TypeScriptINTERMEDIATEMEDIUMUpdated Dec 11, 2025· 91 views

This TypeScript configuration error occurs when you enable the noImplicitOverride compiler option without also enabling noImplicitThis. The error prevents compilation until you fix the tsconfig.json settings to ensure proper type safety for both inheritance and this context checking.

Quick fix

Fixes 'noImplicitOverride' requires 'noImplicitThis'

{
  "compilerOptions": {
    "noImplicitOverride": true,
    // ... other options
  }
}
  1. Check your current tsconfig.json configuration
  2. Enable noImplicitThis in your tsconfig.json
  3. Consider using strict mode instead
  4. Fix any new type errors that appear
typescript — error
{
  "compilerOptions": {
    "noImplicitOverride": true,
    // ... other options
  }
}
'noImplicitOverride' requires 'noImplicitThis'

What this error means

The error "'noImplicitOverride' requires 'noImplicitThis'" occurs because TypeScript's compiler options have interdependencies for ensuring comprehensive type safety. noImplicitOverride is a strict mode option that requires the override keyword when a method in a subclass intentionally overrides a method from its parent class. This helps prevent bugs when base class methods are renamed but subclass methods aren't updated accordingly. noImplicitThis is another strict mode option that raises errors when the this keyword is used without proper type annotation, preventing runtime errors where this might refer to unexpected contexts. TypeScript requires both options to be enabled together because they work in tandem: when checking override relationships, the compiler needs to understand the this context to properly validate method signatures and ensure type safety throughout the inheritance chain. Without noImplicitThis enabled, TypeScript cannot guarantee that this references in overridden methods are type-safe, potentially leading to runtime errors despite the override checking.

Typical symptoms

  • TypeScript compilation fails with error: "'noImplicitOverride' requires 'noImplicitThis'"
  • Build process stops when using strict TypeScript configuration
  • CI/CD pipelines fail during TypeScript compilation step
  • IDE shows red squiggly lines under compilerOptions in tsconfig.json

Common causes

  1. Enabling noImplicitOverride in tsconfig.json without also enabling noImplicitThis
  2. Using strict: true which enables noImplicitOverride but not necessarily noImplicitThis in some configurations
  3. Migrating from older TypeScript versions where these options had different dependencies
  4. Copying tsconfig.json from another project without understanding the option dependencies

How to fix "'noImplicitOverride' requires 'noImplicitThis'"

1Check your current tsconfig.json configuration

Open your tsconfig.json file and examine the compilerOptions section. Look for the noImplicitOverride setting:

json
{
  "compilerOptions": {
    "noImplicitOverride": true,
    // ... other options
  }
}

If you see noImplicitOverride: true but no noImplicitThis setting, this is causing the error.

2Enable noImplicitThis in your tsconfig.json

Add noImplicitThis: true to your compilerOptions:

json
{
  "compilerOptions": {
    "noImplicitOverride": true,
    "noImplicitThis": true,
    // ... other options
  }
}

This satisfies TypeScript's requirement that both options be enabled together.

3Consider using strict mode instead

If you want comprehensive type safety, consider enabling strict mode which includes both options:

json
{
  "compilerOptions": {
    "strict": true,
    // ... other options
  }
}

The strict: true option enables noImplicitOverride, noImplicitThis, and all other strict type-checking options. This is the recommended approach for new projects.

4Fix any new type errors that appear

After enabling noImplicitThis, you may see new type errors related to this usage. Fix these by:

1. Adding explicit this parameter types to functions:

typescript
function example(this: MyClass) {
  // this is now properly typed
}

2. Using arrow functions to preserve this context:

typescript
class MyClass {
  method = () => {
    // this is correctly bound to the instance
  }
}

3. Adding type annotations to class methods where this is used.

5Verify the fix compiles correctly

Run TypeScript compilation to ensure the error is resolved:

bash
npx tsc --noEmit
# or
npm run build

The "'noImplicitOverride' requires 'noImplicitThis'" error should no longer appear. If you still see errors, check that your tsconfig.json is being read correctly and that there are no conflicting configurations in extended config files.

6Update your build configuration if needed

If you're using build tools like webpack, vite, or esbuild, ensure they're using the updated tsconfig.json:

- For webpack: Check ts-loader or babel-loader configuration
- For vite: The tsconfig.json in project root is automatically used
- For esbuild: Pass the --tsconfig flag with your config path

Also update any CI/CD configuration files to ensure they use the correct TypeScript compiler options.

Advanced notes

The relationship between noImplicitOverride and noImplicitThis exists because TypeScript's type system needs to understand this context to properly validate method overrides. When a subclass method overrides a parent method, TypeScript must check that the this parameter (if present) is compatible between the two signatures.

Without noImplicitThis, TypeScript allows this to have type any in methods, which means it can't guarantee type safety when checking override compatibility. Enabling both options ensures that:

1. Override relationships are explicitly marked with the override keyword
2. The this context is properly typed in all methods
3. Override compatibility includes this parameter type checking

This is particularly important for:
- Library authors maintaining public APIs
- Large codebases with complex inheritance hierarchies
- Teams adopting TypeScript gradually where explicit type safety is crucial

If you encounter performance issues with these strict options enabled, consider:
- Using incremental compilation (incremental: true)
- Isolating strict checking to specific directories
- Gradually enabling options rather than all at once

Frequently asked questions

What does "'noImplicitOverride' requires 'noImplicitThis'" mean?
The error "'noImplicitOverride' requires 'noImplicitThis'" occurs because TypeScript's compiler options have interdependencies for ensuring comprehensive type safety. noImplicitOverride is a strict mode option that requires the override keyword when a method in a subclass intentionally overrides a method from its parent class. This helps prevent bugs when base class methods are renamed but subclass methods aren't updated accordingly.
How do I fix "'noImplicitOverride' requires 'noImplicitThis'"?
This TypeScript configuration error occurs when you enable the noImplicitOverride compiler option without also enabling noImplicitThis. The error prevents compilation until you fix the tsconfig.json settings to ensure proper type safety for both inheritance and this context checking.
What causes "'noImplicitOverride' requires 'noImplicitThis'"?
Enabling noImplicitOverride in tsconfig.json without also enabling noImplicitThis Using strict: true which enables noImplicitOverride but not necessarily noImplicitThis in some configurations Migrating from older TypeScript versions where these options had different dependencies
Is the "'noImplicitOverride' requires 'noImplicitThis'" error serious?
It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Official resources & further reading