Enum SchemaType 

pub enum SchemaType {
    Primitive {
        rust_type: String,
        serde_with: Option<String>,
    },
    Object {
        properties: BTreeMap<String, PropertyInfo>,
        required: HashSet<String>,
        additional_properties: ObjectAdditionalProperties,
        variant: Option<SchemaRef>,
    },
    DiscriminatedUnion {
        discriminator_field: String,
        variants: Vec<UnionVariant>,
        exclusive: bool,
    },
    Union {
        variants: Vec<SchemaRef>,
        exclusive: bool,
    },
    Array {
        item_type: Box<SchemaType>,
    },
    Nullable {
        inner_type: Box<SchemaType>,
    },
    Tuple {
        element_types: Vec<SchemaType>,
    },
    StringEnum {
        values: Vec<String>,
    },
    ExtensibleEnum {
        known_values: Vec<String>,
    },
    Composition {
        schemas: Vec<SchemaRef>,
    },
    Reference {
        target: String,
    },
    Untyped {
        shape: UntypedShape,
        reason: UntypedReason,
    },
}

Variants

Primitive

Simple primitive type. serde_with carries an optional #[serde(with = "<path>")] codec hint produced by the TypeMapper for typed scalars (e.g. format: byte → Vec<u8> + base64_serde); the generator wraps this in a field-level with = ... attribute.

Fields

rust_type: String

serde_with: Option<String>

Object

Object with properties

Fields

properties: BTreeMap<String, PropertyInfo>

required: HashSet<String>

additional_properties: ObjectAdditionalProperties

variant: Option<SchemaRef>

A union the schema declares alongside its own properties — {properties: {...}, anyOf: [...]} — meaning “these fields, and one of these shapes”. Held in a #[serde(flatten)] field so both halves survive; None for a plain object.

DiscriminatedUnion

Discriminated union (oneOf/anyOf + discriminator).

Fields

discriminator_field: String

variants: Vec<UnionVariant>

exclusive: bool

oneOf requires a unique structural match; anyOf permits a deterministic first match when the discriminator is absent or its preferred branch does not fit.

Union

Simple union. Exclusive unions originate from oneOf and require exactly one branch to preserve the complete input shape; non-exclusive unions retain anyOf/multi-type first-match semantics.

Fields

variants: Vec<SchemaRef>

exclusive: bool

Array

Array type

Fields

item_type: Box<SchemaType>

Nullable

A nullable value in a container position. Object properties carry nullability separately because their Option<T> also participates in required-vs-missing serde behavior; array items, tuple positions, and typed additional-property values need an inline wrapper instead.

Fields

inner_type: Box<SchemaType>

Tuple

Fixed-arity array — one schema per position, no extras — rendered as a Rust tuple. Only emitted when the spec proves the length (see SchemaDetails::positional_items_are_exact); an open prefixItems stays an Array, because serde would reject the extra elements the spec allows.

Fields

element_types: Vec<SchemaType>

StringEnum

String enum

Fields

values: Vec<String>

ExtensibleEnum

Extensible enum with known values and custom variant

Fields

known_values: Vec<String>

Composition

Schema composition (allOf)

Fields

schemas: Vec<SchemaRef>

Reference

Reference to another schema

Fields

target: String

Untyped

A value the generator could not type, rendered as serde_json::Value.

The reason travels with the type rather than in a side table, so the census counts what is actually generated: a schema analyzed once but referenced by fifty properties yields fifty untyped fields, and one that is pruned yields none.

Fields

shape: UntypedShape

reason: UntypedReason

Implementations

impl SchemaType

pub fn renders_inline(&self) -> bool

Whether the generator can render this type directly in a field or element position.

The other variants name something that must be generated as its own item — a struct, an enum, a union — so a field can only hold them by reference. Analysis hoists those and leaves a SchemaType::Reference; anything that reaches the generator un-hoisted is rendered as serde_json::Value, losing the type the schema had. UntypedReason::inline_drop names those cases so the census can count them.

Trait Implementations

impl Clone for SchemaType

fn clone(&self) -> SchemaType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SchemaType

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

Formats the value using the given formatter.