User-Defined Type Guard is

function isT(x: unknown): x is T {
  // Actual validation logic (must return a boolean)
  return /* ... */;
}

interface User {
  id: number;
  name: string;
}

function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    typeof (value as User).id === 'number' &&
    typeof (value as User).name === 'string'
  );
}

const data: unknown = { id: 1, name: 'Ryomen Sukuna' };

if (isUser(data)) {
  // Inside this block, data is narrowed to: User
  console.log(data.name);
}

// Combining with array filtering
const values: (string | null | undefined)[] = ['a', null, 'b', undefined, 'c'];

function isString(v: unknown): v is string {
  return typeof v === 'string';
}

const strings: string[] = values.filter(isString);
// => ['a', 'b', 'c']  (typed as string[])

// Applying to discriminated unions
type Circle = { kind: 'circle'; radius: number };
type Square = { kind: 'square'; side: number };
type Shape = Circle | Square;

function isCircle(shape: Shape): shape is Circle {
  return shape.kind === 'circle';
}

Running the above produces the following output:

npx ts-node ts_is_guard.ts
Ryomen Sukuna

Using a type predicate (x is T) lets you extract complex validation logic into a function while still benefiting from TypeScript's type narrowing. The parameter name in the predicate must match the corresponding parameter name in the function signature.

One important caveat: TypeScript does not report a compile error if the implementation of a type guard function is incorrect. You are responsible for writing accurate validation logic. For example, simply writing return true will pass the type checker without any error, so it is essential to implement the actual validation correctly.

When you pass a type guard function to the array filter method, the type of the resulting array is narrowed accordingly. This is especially useful for cases like obtaining a string[] from a (string | null)[].