Enum TsType 

pub enum TsType {
    Named {
        name: String,
        type_args: Vec<TsType>,
    },
    Array {
        element: Box<TsType>,
        readonly: bool,
    },
    Object(Vec<TsTypeMember>),
    Fn {
        params: Vec<TsType>,
        ret: Box<TsType>,
    },
    Union {
        members: Vec<TsType>,
        multiline: bool,
    },
    Intersection(Vec<TsType>),
}

A type-position node. Named (extended with type arguments — a real gap the reference sketch left unaddressed: Record<string, Array<{...}>>/Promise<Response> both need one, and a bare Named with no type-argument slot cannot represent either), Array (extended with a readonly modifier — P7.9’s own real gap: every List/Query element type bynk-emit’s ts_type_ref*/ts_ty families build is readonly T[], not plain T[]), Object, and Fn (P7.9’s own second real gap — the query-thunk wrapper (() => readonly T[]) and a real parametered function type (a0: T0, …) => Ret both need one) — not the sketch’s Union/Intersection/Literal/TypeParam/Readonly (still unused; readonly here is a modifier on Array, not the sketch’s own separate Readonly wrapper variant).

Variants

Named

A named type, optionally generic — string/unknown (no type arguments) or Record<string, T>/Promise<Response> (some).

Fields

name: String

type_args: Vec<TsType>

Array

T[] (readonly: false) or readonly T[] (readonly: true) — TypeScript’s own postfix array-type syntax (not the equivalent Array<T>/ReadonlyArray<T> generic spelling either family uses).

Hazard (review of #1315/#1316, not yet closed): the printer does not parenthesise element when it is itself a TsType::Union or TsType::Fn — Array { element: Union(..), .. } prints as A | B[], which TypeScript reads as A | (B[]), not the intended (A | B)[]; likewise a Fn element’s own [] binds to its return type, not the whole function type. Not a P7.9 regression — every bynk-emit call site building this exact malformed shape (Ty::List of an Ty::ActorSum) produced the identical bytes before this slice too, so the zero-diff bar is genuinely met. Fixing it is a real output change, out of this slice’s own behaviour- preserving scope — a caller building Array over Union/Fn today must not trust the printer to parenthesise correctly.

Fields

element: Box<TsType>

readonly: bool

Object(Vec<TsTypeMember>)

A type-position object shape, e.g. { type: string; payload: unknown } — semicolon-separated, always printed on one line (see TsExpr::Object’s own doc for the value-position contrast). An interface’s own members are each printed on their own line by TsDecl::Interface’s printer, independent of this variant’s own (always-inline) rendering — the two only look different because TsDecl::Interface is the thing choosing to put each member on its own line, not because Object has two rendering modes.

#1323 replaced the plain Vec<(String, TsType, bool)> (optional only, #1321) with TsTypeMember — workers_entry.rs’s own real gap needed both a readonly modifier (every structural type this file builds is readonly-qualified, e.g. { readonly cron: string; readonly scheduledTime: number }) and a method-signature member (ack(): void, retry(): void, waitUntil(promise: Promise< unknown>): void), neither representable by one more anonymous tuple bool — a fourth positional bool next to optional would be genuinely ambiguous at call sites (readonly vs. optional, ordered how?), the same reasoning TsObjectEntry already used over a raw tuple for the value-position sibling.

Fn

(a0: T0, a1: T1, …) => Ret — a function type. Parameters carry no name of their own (just their type); the printer numbers them positionally (a0, a1, …), matching the exact convention bynk-emit’s own pre-P7.9 ts_type_ref_with/ts_ty already used (TypeScript requires some name in function-type syntax, and nothing about a TypeRef::Fn/Ty::Fn parameter carries a real one to use instead). A zero-params Fn is the query-thunk wrapper shape, () => Ret. See TsType::Array’s own doc for a real, unclosed parenthesisation hazard when a Fn sits inside one.

Fields

params: Vec<TsType>

ret: Box<TsType>

Union

A | B | C — a type-position union. Added in review of #1315: bynk-emit’s ts_ty builds a real union type for a resolved multi-actor sum (Ty::ActorSum, discriminated-union members tagged by actor name), a shape none of Named/Array/Object/Fn can represent — a real, grounded gap the same way readonly/Fn themselves were (P7.9’s own accepted proposal), not a speculative addition. Each member prints through the ordinary render_type recursion; a member that is itself a Union is legal to construct but nothing in bynk-emit builds one today. See TsType::Array’s own doc for a real, unclosed parenthesisation hazard when a Union sits inside one.

multiline (#1339): false (via TsType::union) is this variant’s original single-line A | B | C form, unchanged. true (via TsType::multiline_union) is emit_sum_type’s own real discriminated-union shape — one variant per line, a leading | on every line except the first (which gets equivalent spacing instead), the closing ; appended directly to the last variant’s own line. Mirrors TsExpr::Object’s own multiline field precedent (#1317), but — unlike that one — needs no depth-aware wrapper: the pre-conversion writeln! code this reproduces always used a fixed two-space indent regardless of nesting (this shape is only ever a top-level export type alias body, never nested inside another type), so render_type stays entirely depth-unaware here too. Only rendered correctly from TsDecl::TypeAlias’s own top-level render — not reachable, and not given a defined rendering, from any nested position (an array element, a type argument, …), the same named boundary TsExpr::Object’s own multiline doc already draws for its own nested case.

Fields

members: Vec<TsType>

multiline: bool

Intersection(Vec<TsType>)

A & B — a type-position intersection. #1339’s own real gap: emit_refined_type’s own branded-type alias, {base} & { readonly __brand: "..." }, has no representation among Named/Array/Object/Fn/Union — mirrors Union’s own shape/precedent exactly (a flat Vec, each member printed through the ordinary render_type recursion, joined by &), single-line only (nothing in bynk-emit builds a multi-line intersection).

Implementations

impl TsType

pub fn named(name: impl Into<String>) -> Self

A plain named type with no type arguments — string, unknown, Request, …

pub fn named_with_args(name: impl Into<String>, type_args: Vec<TsType>) -> Self

A generic named type — Record<K, V>, Promise<T>, …

pub fn array(element: TsType) -> Self

T[] — the non-readonly array shape.

pub fn readonly_array(element: TsType) -> Self

readonly T[].

pub fn union(members: Vec<TsType>) -> Self

A | B | C — the original single-line union form, unchanged.

pub fn multiline_union(members: Vec<TsType>) -> Self

emit_sum_type’s own real multi-line discriminated-union shape — see TsType::Union’s own doc for the exact rendering rules and why this needs no depth parameter.

pub fn intersection(members: Vec<TsType>) -> Self

A & B — an intersection type.

Trait Implementations

impl Clone for TsType

fn clone(&self) -> TsType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TsType

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

Formats the value using the given formatter.