openapi-to-rust 0.4.0

Generate strongly-typed Rust structs, HTTP clients, and SSE streaming clients from OpenAPI 3.1 specifications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

use openapi_to_rust::SchemaAnalyzer;
use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Read the anthropic spec
    let content = fs::read_to_string("../anthropic/anthropic.json")?;
    let spec: serde_json::Value = serde_json::from_str(&content)?;

    println!("Creating analyzer...");
    let mut analyzer = SchemaAnalyzer::new(spec)?;

    println!("Analyzing schemas...");
    let analysis = analyzer.analyze()?;

    // Check BetaInputContentBlock
    if let Some(schema) = analysis.schemas.get("BetaInputContentBlock") {
        println!("✅ Found BetaInputContentBlock schema!");
        println!("Schema type: {:#?}", schema.schema_type);

        // Print the variants if it's a discriminated union
        if let openapi_to_rust::analysis::SchemaType::DiscriminatedUnion {
            discriminator_field,
            variants,
        } = &schema.schema_type
        {
            println!("\nDiscriminator field: {discriminator_field}");
            println!("Variants ({}):", variants.len());
            for (i, variant) in variants.iter().enumerate() {
                println!(
                    "  {}. rust_name: {}, type_name: {}, discriminator_value: {}",
                    i + 1,
                    variant.rust_name,
                    variant.type_name,
                    variant.discriminator_value
                );
            }
        }
    } else {
        println!("❌ BetaInputContentBlock schema NOT found!");
    }

    Ok(())
}