TypeScript Advanced Type Utilities

A comprehensive collection of more than 150 high-performance TypeScript type utilities focused on type safety and developer experience.

Features

Zero Runtime Overhead - Pure type definitions
Type Safety - Advanced constraint utilities
Modular Design - Import only what you need
Rich Toolset - From basic to advanced type operations
IntelliSense Optimized - Great IDE support

Installation

npm install devtypes

Documentation

Read the full devtypes Documentation for detailed usage instructions, examples, and API references.

Quick Examples

Object Type Manipulation

import type { Merge } from 'devtypes/merge';
import type { RequireExactlyOne } from 'devtypes/constraint';

type UserBase = { id: number; name: string; email?: string };
type UserAuth = { email: string; password: string };

// Merge types (smart conflict resolution)
type User = Merge< UserBase, UserAuth >;
// { id: number; name: string; email: string; password: string }

// Require exactly one field
type LoginCredentials = RequireExactlyOne<
    { email?: string; phone?: string; username?: string; },
    'email' | 'phone' | 'username'
>;

Deep Utilities

import type { DeepPartial, DeepRequired } from 'devtypes/transform';

interface Config {
    server: {
        port: number;
        host: string;
        ssl?: {
            cert: string;
            key: string;
        };
    };
    database: {
        url: string;
        timeout?: number;
    };
}

// Make everything optional
type PartialConfig = DeepPartial< Config >;

// Make everything required
type FullConfig = DeepRequired< Config >;

Core Modules

Module	Purpose
assert	Assertion utilities for compile-time checks
class	Class-specific utilities: methods, properties, constructors
condition	Conditional type utilities (If and Equals)
constraint	Property requirement constraints and validation
functional	Functional type utilities: curry, compose, promisify
guard	Type guard utilities for runtime type checking
list	List-like structures (arrays, sets, maps, records, iterables)
merge	(Deep) merging and intersection of types
object	Object type manipulation and property utilities
primitive	Primitive type utilities and literal handling
transform	(Deep) transformations for objects, arrays, and nested structures
tuple	Tuple-specific utilities and manipulations
union	Union type utilities: exclusion, extraction, conversion
util	Generic utility types: branding, boxing, casting, simplification

Performance Tips

Import from specific modules for best IDE performance:

// Good - direct import
import type { Brand } from 'devtypes/util';
import type { MethodNames } from 'devtypes/class';

// Avoid - star imports slow down IntelliSense
import * as Types from 'devtypes';

Contributing

Contributions are welcome! Please feel free to submit a pull request.