> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript Protected Setter
A protected setter in TypeScript is a class mutator method defined with the `protected` access modifier. It restricts the assignment of a class property so that it can only be mutated from within the defining class itself or any of its derived subclasses, strictly preventing modification from external class instances.
```typescript theme={"dark"}
class BaseClass {
private _internalState: number = 0;
// The getter must share the exact same access modifier as the setter
protected get state(): number {
return this._internalState;
}
// The setter accepts a wider type than the getter returns (TypeScript 4.3+)
protected set state(value: number | string) {
this._internalState = typeof value === "string" ? parseInt(value, 10) : value;
}
}
class DerivedClass extends BaseClass {
public mutateState(newValue: number | string): void {
// Valid: Subclass has access to the protected setter
this.state = newValue;
}
}
const instance = new DerivedClass();
// Error: Property 'state' is protected and only accessible within class 'BaseClass' and its subclasses.
// instance.state = 42;
```
## Technical Mechanics and Rules
**1. Symmetric Access Modifiers**
TypeScript strictly enforces that a `get` and `set` accessor for the same property must share the exact same visibility modifier. If a setter is declared as `protected`, its corresponding getter (if defined) must also be declared as `protected`. Attempting to mix access modifiers (e.g., a `public` getter with a `protected` setter) will result in a compiler error: `A 'set' accessor must have the same visibility as the 'get' accessor.`
**2. Inheritance and Access Scope**
The `protected` keyword dictates lexical scoping for the assignment operator (`=`) when targeting the accessor.
* **Valid:** Invoking the setter via `this.propertyName = value` inside the base class.
* **Valid:** Invoking the setter via `this.propertyName = value` inside a class that `extends` the base class.
* **Invalid:** Invoking the setter via `instance.propertyName = value` in the global scope or unrelated functions.
**3. Signature Constraints and Separate Write Types**
Regardless of the access modifier, the TypeScript compiler enforces strict signature rules on the setter:
* It must accept exactly one parameter.
* It cannot have a return type annotation (not even `void`).
* **Separate Write Types (TypeScript 4.3+):** The setter's parameter type is permitted to be completely different from the getter's return type. The compiler only requires that the getter's return type is assignable to the setter's parameter type. If no type is explicitly provided to the setter parameter, TypeScript will infer it from the getter's return type.
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
