Enum TypeDef 

pub enum TypeDef {
    Primitive(Primitive),
    Array(Box<TypeDef>),
    Tuple(Vec<TypeDef>),
    Object(Vec<Field>),
    Union(Vec<TypeDef>),
    Intersection(Vec<TypeDef>),
    Record {
        key: Box<TypeDef>,
        value: Box<TypeDef>,
    },
    Named {
        namespace: Vec<String>,
        name: String,
        def: Box<TypeDef>,
        module: Option<String>,
        wrapper: Option<String>,
    },
    Ref(String),
    Literal(Literal),
    Function {
        params: Vec<Field>,
        return_type: Box<TypeDef>,
    },
    Generic {
        base: String,
        args: Vec<TypeDef>,
    },
    IndexedAccess {
        base: String,
        key: String,
    },
    TemplateLiteral {
        strings: Vec<String>,
        types: Vec<Box<TypeDef>>,
    },
    GenericDef {
        name: String,
        type_params: Vec<TypeParam>,
        def: Box<TypeDef>,
    },
    TypeParamRef(String),
}

Intermediate representation for TypeScript types.

This enum represents all TypeScript types that ferrotype can generate. It serves as the IR between Rust types and TypeScript output, enabling analysis and transformation before rendering.

Type Categories

• Primitives: string, number, boolean, null, etc.
• Compounds: Arrays, tuples, objects, unions, intersections
• References: Named types and type references
• Literals: Specific string, number, or boolean values

Variants

Primitive(Primitive)

A primitive TypeScript type.

Array(Box<TypeDef>)

An array type: T[]

Tuple(Vec<TypeDef>)

A tuple type: [T1, T2, ...]

Object(Vec<Field>)

An object type with named fields: { field1: T1; field2?: T2; }

Union(Vec<TypeDef>)

A union type: T1 | T2 | ...

Intersection(Vec<TypeDef>)

An intersection type: T1 & T2 & ...

Record

A record/dictionary type: Record<K, V> or { [key: K]: V }

Fields

key: Box<TypeDef>

value: Box<TypeDef>

Named

A named type definition that should be emitted as a separate declaration. This is the primary mechanism for type deduplication.

The optional namespace field allows placing types in TypeScript namespaces:

• namespace: vec![] → type State = ...
• namespace: vec!["VM".into(), "Git".into()] → namespace VM { namespace Git { type State = ... } }

The optional wrapper field allows wrapping the type in utility types:

• wrapper: None → type Name = Definition;
• wrapper: Some("Prettify") → type Name = Prettify<Definition>;
• wrapper: Some("Prettify<Required<") → type Name = Prettify<Required<Definition>>;

Fields

namespace: Vec<String>

Optional namespace path, e.g., [“VM”, “Git”] for namespace VM { namespace Git { ... } }

name: String

The type name

def: Box<TypeDef>

The type definition

module: Option<String>

Optional module path for multi-file export (e.g., “models::user”)

wrapper: Option<String>

Optional utility type wrapper (e.g., “Prettify” or “Prettify<Required<”)

Ref(String)

A reference to a named type. Used to avoid infinite recursion and to generate cleaner output by referencing previously-defined types.

Literal(Literal)

A literal type with a specific value.

Function

A function type: (arg1: T1, arg2: T2) => R

Fields

params: Vec<Field>

return_type: Box<TypeDef>

Generic

A generic type application: Generic<T1, T2>

Fields

base: String

args: Vec<TypeDef>

IndexedAccess

An indexed access type: T["K"]

Indexed access types allow extracting a property type from another type. This is commonly used for type-safe property access patterns.

Example

// Profile["login"] extracts the type of the "login" property from Profile
let login_type = TypeDef::IndexedAccess {
    base: "Profile".into(),
    key: "login".into(),
};
assert_eq!(login_type.render(), "Profile[\"login\"]");

Fields

base: String

The base type to index into (e.g., “Profile”)

key: String

The property key to access (e.g., “login”)

TemplateLiteral

A template literal type: `prefix${Type}suffix`

Template literal types enable compile-time string pattern validation in TypeScript. They’re commonly used for branded IDs like vm-${string} or version patterns.

Example

// `vm-${string}` validates that strings start with "vm-"
let vm_id = TypeDef::TemplateLiteral {
    strings: vec!["vm-".into(), "".into()],
    types: vec![Box::new(TypeDef::Primitive(Primitive::String))],
};
assert_eq!(vm_id.render(), "`vm-${string}`");

Fields

strings: Vec<String>

String parts interspersed with type placeholders. Always has one more element than types. e.g., “vm-” + ${string} + “” becomes [“vm-”, “”]

types: Vec<Box<TypeDef>>

Types to interpolate (one fewer than strings).

GenericDef

A generic type definition with type parameters.

This is for defining a generic type with parameters. For example: type Core<T extends { type: string }> = { id: string; data: T }

The Core Pattern

A common pattern for rich discriminated unions wraps variants in a generic:

// Generic wrapper for common metadata
interface Core<T extends { type: string }> {
    id: string;
    timestamp: Date;
    data: T;
}

// Variant types
interface TextData { type: "text"; content: string }
interface ImageData { type: "image"; url: string }

// Full message types
type TextMessage = Core<TextData>;
type ImageMessage = Core<ImageData>;
type Message = TextMessage | ImageMessage;

Example

use ferrotype::{TypeDef, TypeParam, Field, Primitive};

// Define: type Core<T extends { type: string }> = { id: string; data: T }
let core_def = TypeDef::GenericDef {
    name: "Core".into(),
    type_params: vec![
        TypeParam::new("T").with_constraint(TypeDef::Object(vec![
            Field::new("type", TypeDef::Primitive(Primitive::String)),
        ])),
    ],
    def: Box::new(TypeDef::Object(vec![
        Field::new("id", TypeDef::Primitive(Primitive::String)),
        Field::new("data", TypeDef::TypeParamRef("T".into())),
    ])),
};

Fields

name: String

The name of the generic type

type_params: Vec<TypeParam>

Type parameters with optional constraints and defaults

def: Box<TypeDef>

The type definition body (may reference type params via TypeParamRef)

TypeParamRef(String)

A reference to a type parameter within a generic definition.

This is used inside a GenericDef to reference one of its type parameters. For example, in type Core<T> = { data: T }, the T in data: T is a TypeParamRef.

Implementations

impl TypeDef

pub fn render(&self) -> String

Renders this TypeDef to TypeScript syntax.

pub fn render_declaration(&self) -> String

Renders a full type declaration for named types.

For Named types, this returns type Name = Definition; For GenericDef types, this returns type Name<T, ...> = Definition; If the type has a namespace, it wraps in namespace X { ... }. If the type has a wrapper, wraps in utility type: type Name = Wrapper<Definition>; For other types, this just returns the rendered type.

Trait Implementations

impl Clone for TypeDef

fn clone(&self) -> TypeDef

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypeDef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for TypeDef

fn eq(&self, other: &TypeDef) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for TypeDef