Forge production-ready SDKs
from OpenAPI specs

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"

    sdk "github.com/acme/widget-go"
)

func main() {
    c := sdk.NewClient().
        WithBaseURL("https://api.example.com").
        WithBearerToken(os.Getenv("API_TOKEN")).
        WithTimeout(10 * time.Second).
        WithMaxConcurrent(8).
        WithDedupe(true).
        WithIdempotency(true).
        WithRetry(sdk.DefaultRetryOptions())

    // Middleware for logging & tracing
    c.Use(func(ctx context.Context, req *sdk.MiddlewareRequest,
        next func(context.Context, *sdk.MiddlewareRequest) (*sdk.MiddlewareResponse, error),
    ) (*sdk.MiddlewareResponse, error) {
        start := time.Now()
        res, err := next(ctx, req)
        log.Printf("%s %s %v", req.Method, req.URL, time.Since(start))
        return res, err
    })

    pets, err := c.ListPets(context.Background(), 20)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(pets)
}

use std::time::Duration;
use widget_sdk::{api, Client};
use widget_sdk::streaming::SseStream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::builder()
        .base_url("https://api.example.com")
        .bearer_token(std::env::var("API_TOKEN")?)
        .timeout(Duration::from_secs(10))
        .max_concurrent(8)
        .dedupe(true)
        .idempotency(true)
        .build()?;

    // Fully typed request/response
    let pets = api::list_pets(&client, Some(20)).await?;

    // SSE streaming
    let res = client
        .request_stream(reqwest::Method::GET, "/events", &[], None)
        .await?;
    let mut sse = SseStream::new(res.bytes_stream());
    while let Some(ev) = sse.next_event().await? {
        println!("{}: {}", ev.event, ev.data);
    }

    Ok(())
}