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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

// Copyright 2022 Oxide Computer Company

//! Typify lets you convert JSON Schema documents into Rust types. It can be
//! used via a macro [`import_types!`] or a `build.rs` file.
//!
//! A typical use looks like this:
//! ```
//! # use typify_macro::import_types;
//! # use serde::{Deserialize,Serialize};
//! import_types!("../example.json");
//! ```
//!
//! This expands to type definitions corresponding to the types from the file
//! `example.json`. The types are `pub` and have a number of useful associated
//! `impl`s including [Debug], [Clone],
//! [Serialize](https://docs.rs/serde/latest/serde/trait.Serialize.html), and
//! [Deserialize](https://docs.rs/serde/latest/serde/trait.Deserialize.html).
//!
//! Alternatively, you may use the expanded form:
//! ```
//! # use typify_macro::import_types;
//! # use serde::{Deserialize,Serialize};
//! import_types!(schema = "../example.json");
//! ```
//!
//! If you want to add additional derives for the generated types, you can
//! specify them with the `derives` property of the expanded form:
//! ```
//! # use typify_macro::import_types;
//! # use serde::{Deserialize,Serialize};
//! import_types!(
//!     schema = "../example.json",
//!     derives = [schemars::JsonSchema],
//! );
//! ```
//!
//! Generated structs can optionally include a builder-style interface:
//! ```
//! # mod x {
//! # use typify_macro::import_types;
//! # use serde::{Deserialize,Serialize};
//! import_types!(
//!     schema = "../example.json",
//!     struct_builder = true,
//! );
//! # }
//! ```
//!
//! With this set, consumers can construct a struct `Veggie` as follows:
//! ```
//! # mod x {
//! # use typify_macro::import_types;
//! # use serde::{Deserialize,Serialize};
//! # import_types!(
//! #    schema = "../example.json",
//! #    struct_builder = true,
//! # );
//! # fn _x() {
//! let veggie: Veggie = Veggie::builder()
//!     .veggie_name("radish")
//!     .veggie_like(true)
//!     .try_into()
//!     .unwrap();
//! # }
//! # }
//! ```
//!
//! #### Macro vs. `build.rs`
//!
//! While using the [`import_types!`] macro is quite a bit simpler, you can
//! also construct output in a `build.rs` script. Doing so requires a little
//! more work do process the JSON Schema document and write out the file to
//! your intended location. The significant benefit is that the generated type
//! definitions are significantly easier to inspect. The macro-generated types
//! can be viewed with `cargo expand` and they (like `build.rs`-derived types)
//! have generated documentation, but if you find that you'd like to see the
//! actual code generated you may prefer a `build.rs`.
//!
//! ## Builder interface
//!
//! Typify exports a [TypeSpace] interface that is intended for programmatic
//! construction of types. This can be for something simple like a `build.rs`
//! script or something more complex like a generator whose input includes JSON
//! schema type definitions.
//!
//! # Mapping JSON Schema to Rust
//!
//! JSON Schema allows for extreme flexibility. As such, there are some schemas
//! that Typify isn't able to interpret (please file an issue!). In general,
//! though, Typify does a pretty job of mapping JSON Schema types to Rust. For
//! more information, see the project's
//! [README.md](https://github.com/oxidecomputer/typify).

pub use typify_impl::Error;
pub use typify_impl::Type;
pub use typify_impl::TypeDetails;
pub use typify_impl::TypeEnum;
pub use typify_impl::TypeEnumVariant;
pub use typify_impl::TypeId;
pub use typify_impl::TypeNewtype;
pub use typify_impl::TypeSpace;
pub use typify_impl::TypeSpaceSettings;
pub use typify_impl::TypeStruct;
pub use typify_macro::import_types;