- Abstract class
- Annotations
- Array
- Asserts
- Casting
- Class
- Conditional types
- Const
- Date object
- Decorators
- Default parameter
- Dictionary
- Enum
- Exclude type
- Extract type
- For loop
- forEach()
- Function
- Generics
- Index signature
- Infer
- Inheritance
- Interface
- Keyof type operator
- Let
- Map type
- Mixin
- Module
- Namespace
- Never
- Object type
- Omit type
- Operator
- Optional parameter
- Partial type
- Pick type
- Promise
- Property
- Readonly type
- Record type
- Required type
- Satisfies operator
- Tuples
- Type alias
- Type assertion
- Type guard
- Type narrowing
- typeof Type Operator
- Union
- Utility types
- Var
- Void
TYPESCRIPT
TypeScript satisfies
Operator: Purpose, Usage, and Examples
The TypeScript satisfies
operator is a relatively new feature introduced in TypeScript 4.9. It provides a powerful way to ensure that a value conforms to a specific type without widening the type of the variable itself. This is particularly useful for type checking while preserving the most specific inferred type available for the value.
Using satisfies TypeScript
allows developers to gain stronger type safety, clearer intent, and better tooling support. Unlike using a simple type annotation, the satisfies
keyword doesn't affect the inferred type—it only checks compatibility. This leads to more robust and flexible code, especially when working with constants, objects, or utility types.
This guide explains how satisfies
works, how it compares to annotations and type assertions, and how to use it in practical TypeScript codebases.
What Is the satisfies
Operator in TypeScript?
The satisfies
operator checks that an expression matches a given type while keeping the inferred type intact.
Basic Syntax:
const value = expression satisfies Type;
This allows the compiler to enforce that expression
meets all the requirements of Type
, but value
will still retain its specific inferred type instead of being upcasted.
Example: Type Preservation
Using TypeScript satisfies
preserves narrow types, unlike annotations that force widening.
const directions = ["north", "south", "east", "west"] as const;
// Without `satisfies`
const obj1: Record<string, string> = {
north: "up",
south: "down",
east: "right",
west: "left",
};
// With `satisfies`
const obj2 = {
north: "up",
south: "down",
east: "right",
west: "left",
} satisfies Record<(typeof directions)[number], string>;
In this example, obj2
is fully checked against the type, but its own type remains literal, allowing better inference and stricter type safety.
How to Use satisfies
in TypeScript
You can use satisfies
in various places where type safety is important but you don’t want to lose type inference.
Use Case: Validating Object Shape
type User = {
id: number;
name: string;
};
const user = {
id: 1,
name: "Alice",
} satisfies User;
The object must fully match the User
interface. If a property is missing or mistyped, TypeScript will throw an error.
Enforcing Exhaustive Object Keys
One of the most common uses of satisfies TypeScript
is to ensure that all expected keys are covered without losing key-specific information.
const statuses = {
idle: "Not started",
loading: "Fetching data",
success: "Done",
error: "Failed",
} satisfies Record<"idle" | "loading" | "success" | "error", string>;
If you miss a key or add an unexpected one, the compiler will alert you.
Combining with as const
The satisfies
operator pairs extremely well with as const
to maintain literal types.
const colors = {
primary: "#000",
secondary: "#FFF",
} as const satisfies Record<string, string>;
This keeps the colors
object's values as literal strings ("#000"
and "#FFF"
) while checking them against the broader Record<string, string>
structure.
Working with Arrays
You can also use satisfies
to validate that an array matches a certain type without losing tuple information.
const roles = ["admin", "editor", "viewer"] as const;
const permissions = {
admin: true,
editor: true,
viewer: false,
} satisfies Record<(typeof roles)[number], boolean>;
In this how to use satisfies TypeScript
pattern, you're dynamically constructing types based on array contents and ensuring the object respects that structure.
Differences from Type Assertions
Type assertions (as Type
) tell the compiler to trust you, while satisfies
checks the value's validity at compile time.
const obj1 = { x: 10 } as { x: number; y: number }; // No error, but y is missing
const obj2 = { x: 10 } satisfies { x: number; y: number }; // Error: y is missing
Using satisfies
avoids the silent failure risks of assertions by verifying the type constraints during development.
Differences from Type Annotations
Annotations like const x: Type = value
assign the type to x
and override what TypeScript would have inferred. satisfies
only checks but doesn’t override.
const value = {
role: "admin",
} satisfies { role: string }; // `role` stays "admin"
const typed: { role: string } = {
role: "admin",
}; // `role` becomes type string, losing literal "admin"
This distinction is critical for maintaining precise type information while ensuring conformity.
Practical Use Cases
1. Validating Config Files
const config = {
apiUrl: "https://example.com",
timeout: 5000,
} satisfies {
apiUrl: string;
timeout: number;
};
This guarantees structure adherence without sacrificing the specificity of the values.
2. Static Maps with Enum Keys
enum Status {
Open = "open",
Closed = "closed",
}
const labels = {
open: "Open case",
closed: "Closed case",
} satisfies Record<Status, string>;
This is useful in prettier TypeScript satisfies
configurations, linters, or strongly typed design tokens.
Benefits of Using satisfies
in TypeScript
- Improved Type Safety: Ensures that values meet expected structure without silently failing.
- Better Inference: Maintains literal or tuple types, unlike annotations.
- Great for Constants: Works best with objects, arrays, or enums where shape matters.
- Safe for Validation: Eliminates unsafe type assertions and improves reliability of internal tooling.
Limitations
- Only Works with Assignable Types: If the value isn’t assignable to the target type, compilation will fail.
- Not a Runtime Feature: The
satisfies
operator is compile-time only and has no output in JavaScript. - Can’t Be Used for Runtime Checks: Use it purely for development-time guarantees.
Tips for Using satisfies
Effectively
- Use with
as const
for best results. - Prefer over type assertions when validating shape.
- Combine with generics to validate derived structures.
- Avoid using in dynamic or computed properties—it's most effective for static objects.
Summary
The TypeScript satisfies
operator is a highly useful tool for validating that a value matches a certain type while maintaining precise inferred types. Unlike annotations or assertions, satisfies TypeScript
introduces stricter compile-time checks that improve reliability without sacrificing flexibility.
You can use it to ensure config structures, map objects to enums, preserve literal values, and validate array patterns.
Sign up or download Mimo from the App Store or Google Play to enhance your programming skills and prepare for a career in tech.