home / skills / pluginagentmarketplace / custom-plugin-typescript / advanced-types

advanced-types skill

safe

This skill helps you master advanced TypeScript types including generics, conditionals, and mapped types to build robust type-safe code.

npx playbooks add skill pluginagentmarketplace/custom-plugin-typescript --skill advanced-types

Review the files below or copy the command above to add this skill to your agents.

Files (6)

SKILL.md

1.2 KB

---
name: advanced-types
description: Advanced TypeScript types including generics, conditionals, and mapped types
sasmp_version: "1.3.0"
bonded_agent: 01-typescript-fundamentals
bond_type: PRIMARY_BOND
---

# Advanced TypeScript Types Skill

## Overview
Master advanced TypeScript type features including generics, conditional types, mapped types, and utility types.

## Topics Covered

### Generics
- Generic functions
- Generic interfaces
- Generic classes
- Generic constraints
- Default type parameters

### Conditional Types
- Conditional type syntax
- Inferring within conditionals
- Distributive conditionals
- Type filtering
- Never in conditionals

### Mapped Types
- Basic mapped types
- Key remapping
- Modifiers (+/-)
- Template literal types
- Recursive types

### Utility Types
- Partial, Required, Readonly
- Pick, Omit, Record
- Extract, Exclude
- ReturnType, Parameters
- Awaited, NonNullable

### Advanced Patterns
- Type guards
- Branded types
- Opaque types
- Variadic tuple types
- Type-level programming

## Prerequisites
- TypeScript fundamentals
- Basic generics understanding

## Learning Outcomes
- Create complex generic types
- Use conditional types effectively
- Build custom utility types
- Apply type-level patterns

Overview

This skill teaches advanced TypeScript type features including generics, conditional types, mapped types, and utility types. It focuses on practical patterns for building robust, type-safe APIs and libraries. You will learn how to model complex data, infer types, and perform type-level computation to reduce runtime errors.

How this skill works

The skill inspects and explains advanced type constructs with examples and patterns: generic functions and classes, conditional and distributive types, key remapping in mapped types, and built-in utility types. It shows how to compose and extend types, create custom utilities, and apply type-level programming techniques such as branded or opaque types. Each concept includes constraints, common pitfalls, and idiomatic usage.

When to use it

When you need precise compile-time modeling of complex data structures
When building reusable libraries or public APIs that require strong type guarantees
When reducing runtime checks by moving validation to the type system
When creating helper utility types to simplify repetitive typings
When optimizing developer DX with better autocompletion and error messages

Best practices

Prefer simple, readable types; only escalate to complex conditional or recursive types when necessary
Use constraints and default type parameters to guide generic usage and provide sensible fallbacks
Favor built-in utility types (Partial, Pick, Record) before reinventing equivalents
Document nontrivial type-level behavior and provide runtime guards for safety when types are complex
Limit deeply recursive or highly distributive types to avoid compiler performance regressions

Example use cases

Create a typed API client that infers response shapes and maps endpoints to return types
Build a form library that derives input props from a schema using mapped and conditional types
Define branded or opaque types to prevent accidental mixing of distinct ID types (e.g., UserId vs OrderId)
Implement advanced helpers like DeepReadonly, Merge, or PickByValue for library utilities
Write variadic tuple utilities to type-safe middleware chains or argument transforms

FAQ

Do I need deep TypeScript experience to use this skill?

You should know TypeScript basics and basic generics; the skill builds on those foundations to teach advanced techniques.

Will complex types affect compile performance?

Yes—very deep recursion, heavy distribution, or excessive conditional nesting can slow compilation. Use best practices to mitigate.

Are runtime checks still necessary?

Yes. Types catch many errors at compile time, but runtime validation is still recommended for external inputs.