Utility Types

import { 
  // Flow-style utilities
  $Keys, $Values, $ReadOnly, $Diff, $PropertyType, $ElementType, 
  $Call, $Shape, $NonMaybeType, Class,
  
  // Advanced mapped types
  SetIntersection, SetDifference, Diff, Omit, Optional, Required,
  DeepReadonly, DeepRequired, DeepPartial, DeepNonNullable,
  PickByValue, FunctionKeys, NonFunctionKeys, Mutable, Brand,
  
  // Type aliases and guards
  Primitive, Falsy, Nullish, isPrimitive, isFalsy, isNullish,
  
  // Deprecated (do not use in new code)
  getReturnOfExpression
} from 'utility-types';

import { Omit, DeepReadonly, $Keys } from 'utility-types';

import { Omit, DeepReadonly, $Keys, Optional, PickByValue } from 'utility-types';

// Basic object manipulation
interface User {
  id: number;
  name: string;
  email: string;
  password: string;
}

// Remove sensitive fields
type PublicUser = Omit<User, 'password'>;
// Result: { id: number; name: string; email: string; }

// Make some fields optional
type UserUpdate = Optional<User, 'id' | 'email'>;
// Result: { id?: number; name: string; email?: string; password: string; }

// Extract keys as union type
type UserKeys = $Keys<User>;
// Result: "id" | "name" | "email" | "password"

// Deep readonly for nested objects
interface Settings {
  theme: { mode: 'light' | 'dark'; colors: string[] };
  preferences: { notifications: boolean; autoSave: boolean };
}

type ReadonlySettings = DeepReadonly<Settings>;
// Result: All properties and nested properties become readonly

// Pick properties by value type
interface Mixed {
  id: number;
  name: string;
  count: number;
  active: boolean;
}

type NumberFields = PickByValue<Mixed, number>;
// Result: { id: number; count: number; }

type $Keys<T extends object> = keyof T;
type $Values<T extends object> = T[keyof T];
type $ReadOnly<T extends object> = DeepReadonly<T>;
type $Diff<T extends U, U extends object> = Pick<T, SetComplement<keyof T, keyof U>>;
type $PropertyType<T extends object, K extends keyof T> = T[K];
type $ElementType<T, K extends keyof T | number> = T[K];
type $Call<Fn extends (...args: any[]) => any> = Fn extends (arg: any) => infer RT ? RT : never;
type $Shape<T extends object> = Partial<T>;
type $NonMaybeType<T> = NonNullable<T>;
type Class<T> = new (...args: any[]) => T;

// Set operations
type SetIntersection<A, B> = A extends B ? A : never;
type SetDifference<A, B> = A extends B ? never : A;
type SetComplement<A, A1 extends A> = SetDifference<A, A1>;

// Object manipulation
type Omit<T, K extends keyof any> = Pick<T, SetDifference<keyof T, K>>;
type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
type Required<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Required<Pick<T, K>>;

// Key selection
type FunctionKeys<T extends object> = {
  [K in keyof T]-?: NonUndefined<T[K]> extends Function ? K : never;
}[keyof T];
type OptionalKeys<T> = {
  [K in keyof T]: {} extends Pick<T, K> ? K : never;
}[keyof T];

// Value-based selection
type PickByValue<T, ValueType> = Pick<T, {
  [Key in keyof T]: T[Key] extends ValueType ? Key : never;
}[keyof T]>;

type Primitive = string | number | bigint | boolean | symbol | null | undefined;
type Falsy = false | '' | 0 | null | undefined;
type Nullish = null | undefined;

function isPrimitive(val: unknown): val is Primitive;
function isFalsy(val: unknown): val is Falsy;  
function isNullish(val: unknown): val is Nullish;

type DeepReadonly<T> = T extends ((...args: any[]) => any) | Primitive
  ? T
  : T extends _DeepReadonlyArray<infer U>
  ? _DeepReadonlyArray<U>
  : T extends _DeepReadonlyObject<infer V>
  ? _DeepReadonlyObject<V>
  : T;

type DeepRequired<T> = T extends (...args: any[]) => any
  ? T
  : T extends any[]
  ? _DeepRequiredArray<T[number]>
  : T extends object
  ? _DeepRequiredObject<T>
  : T;

type DeepPartial<T> = { [P in keyof T]?: _DeepPartial<T[P]> };

type DeepNonNullable<T> = T extends (...args: any[]) => any
  ? T
  : T extends any[]
  ? _DeepNonNullableArray<T[number]>
  : T extends object
  ? _DeepNonNullableObject<T>
  : T;

type NonUndefined<A> = A extends undefined ? never : A;

type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

type Brand<T, U> = T & { __brand: U };

type PromiseType<T extends Promise<any>> = T extends Promise<infer U> ? U : never;

type ValuesType<T extends ReadonlyArray<any> | ArrayLike<any> | Record<any, any>> = 
  T extends ReadonlyArray<any>
    ? T[number]
    : T extends ArrayLike<any>
    ? T[number]
    : T extends object
    ? T[keyof T]
    : never;

// Deep transformation helper types
interface _DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {}
type _DeepReadonlyObject<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> };

type _DeepRequiredArray<T> = Array<DeepRequired<NonUndefined<T>>>;
type _DeepRequiredObject<T> = { [P in keyof T]-?: DeepRequired<NonUndefined<T[P]>> };

type _DeepNonNullableArray<T> = Array<DeepNonNullable<NonNullable<T>>>;
type _DeepNonNullableObject<T> = { [P in keyof T]-?: DeepNonNullable<NonNullable<T[P]>> };

type _DeepPartial<T> = T extends Function
  ? T
  : T extends ReadonlyArray<infer U>
  ? _DeepPartialArray<U>
  : T extends object
  ? DeepPartial<T>
  : T;

type _DeepPartialArray<T> = Array<_DeepPartial<T>>;