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>,
    },
    Ref(String),
    Literal(Literal),
    Function {
        params: Vec<Field>,
        return_type: Box<TypeDef>,
    },
    Generic {
        base: String,
        args: Vec<TypeDef>,
    },
    TemplateLiteral {
        strings: Vec<String>,
        types: Vec<Box<TypeDef>>,
    },
}

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 = ... } }

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”)

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>

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).

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; If the type has a namespace, it wraps in namespace X { ... }. 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