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

interface Admin extends User {
  role: 'admin';
  permissions: string[];
}

function isAdmin(user: User | Admin): user is Admin {
  return 'role' in user && user.role === 'admin';
}

type Result\<T\> =
  | { status: 'success'; data: T }
  | { status: 'error'; error: Error }
  | { status: 'loading' };

function isSuccess\<T\>(result: Result\<T\>): result is { status: 'success'; data: T } {
  return result.status === 'success';
}

function processResult\<T\>(result: Result\<T\>) {
  if (isSuccess(result)) {
    // TypeScript knows result.data exists here
    console.log(result.data);
  }
}

interface TreeNode {
  value: string;
  children?: TreeNode[];
}

function isValidTreeNode(node: unknown): node is TreeNode {
  if (typeof node !== 'object' || node === null) return false;

  const candidate = node as TreeNode;
  if (typeof candidate.value !== 'string') return false;

  if (candidate.children !== undefined) {
    if (!Array.isArray(candidate.children)) return false;
    return candidate.children.every(isValidTreeNode);
  }

  return true;
}

type Validator\<T\> = (value: unknown) => value is T;

function validate\<T\>(value: unknown, validator: Validator\<T\>): T {
  if (validator(value)) {
    return value;
  }
  throw new Error('Validation failed');
}

// Example usage
const isString = (value: unknown): value is string => typeof value === 'string';
const validatedString = validate('hello', isString); // type is string