ts-types

Generate and refine TypeScript types from various sources:

1. Identify Type Source

   • Determine what needs types:
     • JavaScript code to be typed
     • API response to model
     • JSON data to type
     • Database schema to represent
     • External library without @types
     • Props interface from usage
   • Source can be from: $ARGUMENTS, current file, or clipboard

2. Generate Types from Different Sources

   From JavaScript Code:

   • Analyze JS function/class structure
   • Infer parameter types from usage
   • Determine return types
   • Generate interfaces for objects

   From Runtime Data:

   // Input: JSON response
   const response = {
     user: { id: 1, name: "Alice", email: "[email protected]" },
     posts: [{ id: 1, title: "Hello", published: true }]
   };
   
   // Generated:
   interface User {
     id: number;
     name: string;
     email: string;
   }
   
   interface Post {
     id: number;
     title: string;
     published: boolean;
   }
   
   interface Response {
     user: User;
     posts: Post[];
   }
   

   From API Documentation:

   • Parse OpenAPI/Swagger schemas
   • Generate types with proper optionality
   • Handle union types and discriminated unions
   • Create type-safe API client

   From Database Schema:

   • Convert SQL schema to TypeScript
   • Map SQL types to TS types
   • Handle nullable columns
   • Generate query result types

3. Refine Existing Types

   • Make types more specific (string → literal union)
   • Add utility type usage (Partial, Pick, Omit)
   • Convert any to proper types
   • Add JSDoc documentation
   • Improve generic constraints
   • Use discriminated unions for state

4. Generate Derived Types

   • Create input/output variants (CreateUser vs User)
   • Generate partial types for updates
   • Create picker types for specific use cases
   • Build form field types from domain types

5. Add Type Guards

   • Generate runtime validation functions
   • Create is predicates for type narrowing
   • Add exhaustive checks for unions
   • Validate external data at boundaries

6. Type Optimization

   • Simplify overly complex types
   • Extract reusable type aliases
   • Remove redundant type annotations
   • Use const assertions where appropriate

7. Documentation

   • Add JSDoc comments to generated types
   • Document complex type parameters
   • Provide usage examples
   • Explain non-obvious type decisions

8. Validation Integration

   • Suggest zod/yup schemas alongside types
   • Generate runtime validators from types
   • Ensure types and validators stay in sync

Examples:

• /ts-types - Generate types for current file
• /ts-types api-response.json - Generate from JSON file
• /ts-types https://api.example.com/users - From API response
• /ts-types refine - Improve existing types

The generated types will be type-safe, well-documented, and follow TypeScript best practices.