When to use satisfies.
Check without widening.

// ─── The setup ───────────────────────────────
type Route = 'home' | 'about' | 'blog';
type Routes = Recordstring>;

// ─── Annotation WIDENS (loses literal types) ─
const routes1: Routes = {
home: '/',
about: '/about',
blog: '/blog'
};
// routes1.home: string
// ↑ widened — can't use routes1 keys as a Route union downstream

// ─── satisfies KEEPS literal types ───────────
const routes2 = {
home: '/',
about: '/about',
blog: '/blog'
} satisfies Routes;

// routes2.home: '/' (literal, not string)
// keys: 'home' | 'about' | 'blog' (kept as literals)
// AND it's checked against Routes — missing key = error

// ─── What satisfies catches ───────────────────
const bad = {
home: '/',
about: '/about'
// ❌ missing 'blog' — satisfies Routes fails
} satisfies Routes;

// ─── Real use: discriminant lookup ───────────
type Status = 'idle' | 'loading' | 'success' | 'error';

const statusLabels = {
idle: 'Ready',
loading: 'Loading…',
success: 'Done',
error: 'Failed'
} satisfies Recordstring>;

// Now you can do:
// function getStatusLabel(s: Status): string {
// return statusLabels[s]; // s is Status, keys match
// }

console.log(routes2.home, statusLabels.success);

interface Config {
host: string;
port: number;
}

// ─── as lies — no checking ─────────────────
const bad = {
host: 'localhost',
port: 'not a number' // ⚠️ wrong type
} as Config;
// ✅ compiles — as trusts you
// ❌ runtime bugs — port is actually a string

// ─── satisfies checks — errors if wrong ────
const good = {
host: 'localhost',
port: 3000
} satisfies Config;

const wrong = {
host: 'localhost',
port: 'not a number'
// ❌ Type 'string' is not assignable to type 'number'
} satisfies Config;

// ─── When as is actually needed ────────────
// as is legitimate when you're converting a type
// that the compiler can't express — e.g. narrowing
// a widened JSON.parse result after a real check:

function parseConfig(json: string): Config {
const raw = JSON.parse(json) as unknown;
// ... validate with a type guard, then return ...
return raw as Config; // after the guard, this is safe
}

// ─── satisfies with generics ───────────────
type ConfigMap = Record<'dev' | 'prod', Config>;

const configs = {
dev: { host: 'localhost', port: 3000 },
prod: { host: 'api.example.com', port: 443 }
} satisfies ConfigMap;
// Both dev and prod checked against Config
// All keys preserved as literals

// ─── The rule ────────────────────────────────
// Want to check? → satisfies
// Want to force? → as (rarely)
// Want a type? → annotation (: Type)
//
// Prefer satisfies over as in almost every case.

console.log(good.port, configs.prod.port);

// ─── i18n dictionary ─────────────────────────
type Locale = 'en' | 'fr' | 'es';
type Messages = RecordRecord<'greeting' | 'farewell', string>>;

const messages = {
en: { greeting: 'Hello', farewell: 'Goodbye' },
fr: { greeting: 'Bonjour', farewell: 'Au revoir' },
es: { greeting: 'Hola', farewell: 'Adiós' }
} as const satisfies Messages;

// messages.en.greeting: 'Hello' (literal, not string)
// All locales present — checked by satisfies
// All message keys present — checked by satisfies

// ─── Config schemas ──────────────────────────
type Env = 'development' | 'production';
interface EnvConfig {
apiUrl: string;
debug: boolean;
logLevel: 'error' | 'warn' | 'info' | 'debug';
}

const envConfig = {
development: {
apiUrl: 'http://localhost:3000',
debug: true,
logLevel: 'debug'
},
production: {
apiUrl: 'https://api.example.com',
debug: false,
logLevel: 'error'
}
} as const satisfies Record;

// envConfig.development.apiUrl: 'http://localhost:3000' (literal)
// logLevel: 'debug' (not 'error' | 'warn' | ... — exactly what you wrote)

// ─── Typed event map ─────────────────────────
type EventName = 'click' | 'submit' | 'change';

const eventLabels = {
click: 'Clicked',
submit: 'Submitted',
change: 'Changed'
} as const satisfies Recordstring>;

function label(e: EventName): typeof eventLabels[EventName] {
return eventLabels[e];
}

// ─── The rule ────────────────────────────────
// as const → freeze literal types
// satisfies Type → check against shape
// combined → both, in one expression
//
// This is the modern idiom for config objects
// and lookup tables. Use it whenever you have
// a constant that needs both precision and safety.

console.log(messages.en.greeting);
console.log(envConfig.production.logLevel);
console.log(label('click'));