oaspec/codegen/ir

Types

Declaration

opaque </>

A top-level declaration with optional doc comment.

Opaque: construct via declaration/2, read via declaration_doc/1 and declaration_type_def/1.

pub opaque type Declaration

Field

</>

A named, typed field in a record constructor.

pub type Field {
  Field(name: String, type_expr: String)
}

Constructors

```
Field(name: String, type_expr: String)
```

Module

opaque </>

A complete generated Gleam source file.

Opaque: construct via module/3, read via module_header/1, module_imports/1, and module_declarations/1. The internal shape can then evolve (e.g. to track file-level doc comments) without rippling into every renderer pass.

pub opaque type Module

ResponseHeaderRecord

</>

A typed record for response headers.

pub type ResponseHeaderRecord {
  ResponseHeaderRecord(name: String, fields: List(Field))
}

Constructors

ResponseHeaderRecord(name: String, fields: List(Field))

TypeDef

</>

The shapes of type definition that the OpenAPI generator produces.

pub type TypeDef {
  TypeAlias(name: String, target: String)
  RecordType(name: String, fields: List(Field))
  UnionType(name: String, variants: List(Variant))
  EnumType(name: String, variants: List(String))
}

Constructors

```
TypeAlias(name: String, target: String)
```
pub type Foo = Bar
```
RecordType(name: String, fields: List(Field))
```
pub type Foo { Foo(field1: Type1, field2: Type2) }

UnionType(name: String, variants: List(Variant))

pub type Foo { FooBar(Bar) FooBaz(Baz) }

EnumType(name: String, variants: List(String))

pub type Status { StatusActive StatusInactive }

Variant

</>

A variant in a union type.

pub type Variant {
  VariantWithType(name: String, inner_type: String)
  VariantEmpty(name: String)
}

Constructors

VariantWithType(name: String, inner_type: String)

Variant with a wrapped type: FooBar(Bar)

```
VariantEmpty(name: String)
```
Variant with no payload: FooNone

Values

declaration

</>

pub fn declaration(
  doc doc: option.Option(String),
  type_def type_def: TypeDef,
) -> Declaration

Construct a Declaration from its optional doc and type definition.

declaration_doc

</>

pub fn declaration_doc(d: Declaration) -> option.Option(String)

Optional doc comment attached to this declaration.

declaration_type_def

</>

pub fn declaration_type_def(d: Declaration) -> TypeDef

The type definition carried by this declaration.

module

</>

pub fn module(
  header header: String,
  imports imports: List(String),
  declarations declarations: List(Declaration),
) -> Module

Construct a Module from its three component pieces.

module_declarations

</>

pub fn module_declarations(m: Module) -> List(Declaration)

Top-level declarations inside the module.

module_header_records

</>

pub fn module_header_records(
  m: Module,
) -> List(ResponseHeaderRecord)

Response header records inside the module.

module_imports

</>

pub fn module_imports(m: Module) -> List(String)

Module imports, in the order they should be rendered.

module_with_header_records

</>

pub fn module_with_header_records(
  header header: String,
  imports imports: List(String),
  declarations declarations: List(Declaration),
  header_records header_records: List(ResponseHeaderRecord),
) -> Module

Construct a Module with header records.