From f7e7a7e4b01dc5b6e2ed9eb662ac341cc037eebe Mon Sep 17 00:00:00 2001
From: Christian <christianpavilonis@outlook.com>
Date: Mon, 2 Mar 2026 13:09:40 +0000
Subject: [PATCH 1/3] wip on openrtb-full-implementation

---
 Cargo.lock                |   8 +
 Cargo.toml                |   1 +
 crates/openrtb/Cargo.toml |  14 +
 crates/openrtb/src/lib.rs | 847 ++++++++++++++++++++++++++++++++++++++
 openrtb.md                | 625 ++++++++++++++++++++++++++++
 5 files changed, 1495 insertions(+)
 create mode 100644 crates/openrtb/Cargo.toml
 create mode 100644 crates/openrtb/src/lib.rs
 create mode 100644 openrtb.md

diff --git a/Cargo.lock b/Cargo.lock
index 476fe08a..f7f4e359 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2438,6 +2438,14 @@ dependencies = [
  "which",
 ]
 
+[[package]]
+name = "trusted-server-openrtb"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "typeid"
 version = "1.0.3"
diff --git a/Cargo.toml b/Cargo.toml
index d2113599..914ab2c5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,6 +4,7 @@ members = [
     "crates/common",
     "crates/fastly", 
     "crates/js",
+    "crates/openrtb",
 ]
 
 # Build defaults exclude the web-only tsjs crate, which is compiled via wasm-pack.
diff --git a/crates/openrtb/Cargo.toml b/crates/openrtb/Cargo.toml
new file mode 100644
index 00000000..221cec15
--- /dev/null
+++ b/crates/openrtb/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "trusted-server-openrtb"
+version = "0.1.0"
+authors = []
+edition = "2021"
+publish = false
+license = "Apache-2.0"
+
+[lints]
+workspace = true
+
+[dependencies]
+serde = { workspace = true }
+serde_json = { workspace = true }
diff --git a/crates/openrtb/src/lib.rs b/crates/openrtb/src/lib.rs
new file mode 100644
index 00000000..69da7bf7
--- /dev/null
+++ b/crates/openrtb/src/lib.rs
@@ -0,0 +1,847 @@
+//! `OpenRTB` 2.6 request and response data model.
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+
+pub type Object = Map<String, Value>;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BidRequest {
+    pub id: String,
+    pub imp: Vec<Imp>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub site: Option<Site>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub app: Option<App>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub device: Option<Device>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user: Option<User>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub test: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub at: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tmax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wseat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bseat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub allimps: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cur: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wlang: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wlangb: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bcat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cattax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub badv: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bapp: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<Source>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub regs: Option<Regs>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Source {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fd: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pchain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub schain: Option<SupplyChain>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Regs {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub coppa: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gdpr: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub us_privacy: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Imp {
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metric: Option<Vec<Metric>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub banner: Option<Banner>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub video: Option<Video>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub audio: Option<Audio>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub native: Option<Native>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pmp: Option<Pmp>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub displaymanager: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub displaymanagerver: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub instl: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tagid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bidfloor: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bidfloorcur: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub clickbrowser: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub secure: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub iframebuster: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rwdd: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ssai: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub exp: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Metric {
+    #[serde(rename = "type")]
+    pub r#type: String,
+    pub value: f64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub vendor: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Banner {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub format: Option<Vec<Format>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub w: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub h: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub btype: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub battr: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pos: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mimes: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub topframe: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub expdir: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub api: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub vcm: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Video {
+    pub mimes: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub minduration: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxduration: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rqddurs: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub protocols: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub w: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub h: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub startdelay: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub placement: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub linearity: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub skip: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub skipmin: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub skipafter: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub battr: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxextended: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub minbitrate: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxbitrate: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub boxingallowed: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub playbackmethod: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub delivery: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pos: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub companionad: Option<Vec<Banner>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub companiontype: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub podid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub podseq: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub slotinpod: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxseq: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub poddur: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mincpmpersec: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sequence: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Audio {
+    pub mimes: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub minduration: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxduration: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rqddurs: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub protocols: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub startdelay: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub placement: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub linearity: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub skip: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub skipmin: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub skipafter: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub battr: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxextended: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub minbitrate: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxbitrate: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub delivery: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub companionad: Option<Vec<Banner>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub companiontype: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub podid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub podseq: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub slotinpod: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxseq: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub poddur: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mincpmpersec: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sequence: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Native {
+    pub request: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ver: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub api: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub battr: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Format {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub w: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub h: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wratio: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hratio: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wmin: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Pmp {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub private_auction: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub deals: Option<Vec<Deal>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Deal {
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bidfloor: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bidfloorcur: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub at: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wseat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wadomain: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Site {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cattax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sectioncat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pagecat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub page: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub r#ref: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub search: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mobile: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub privacypolicy: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<Publisher>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<Content>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keywords: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub kwarray: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct App {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bundle: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub storeurl: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cattax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sectioncat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pagecat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ver: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub privacypolicy: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub paid: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<Publisher>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<Content>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keywords: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub kwarray: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Publisher {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cattax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Content {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub episode: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub series: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub season: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub artist: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub genre: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub album: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keywords: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub kwarray: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cattax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prodq: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rating: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub userrating: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub qagmediarating: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub context: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub livestream: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sourcerel: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub len: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub langb: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub embeddable: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub producer: Option<Producer>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub channel: Option<Channel>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Producer {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cattax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Device {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub geo: Option<Geo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dnt: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lmt: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ua: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sua: Option<UserAgent>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ip: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub devicetype: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub make: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub os: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub osv: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hwv: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub h: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub w: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ppi: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pxratio: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub js: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub geofetch: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub flashver: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub langb: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub carrier: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mccmnc: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub connectiontype: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ifa: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub didsha1: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub didmd5: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dpidsha1: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dpidmd5: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub macsha1: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub macmd5: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Geo {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lat: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lon: Option<f64>,
+    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
+    pub r#type: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub accuracy: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lastfix: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ipservice: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub country: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub region: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metro: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub city: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub zip: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub utcoffset: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct User {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub buyeruid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub yob: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gender: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keywords: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub kwarray: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub customdata: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub geo: Option<Geo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<Vec<Data>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub consent: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub eids: Option<Vec<Eid>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Data {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub segment: Option<Vec<Segment>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Segment {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Channel {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SupplyChain {
+    pub complete: i32,
+    pub nodes: Vec<SupplyChainNode>,
+    pub ver: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SupplyChainNode {
+    pub asi: String,
+    pub sid: String,
+    pub hp: i32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Eid {
+    pub source: String,
+    pub uids: Vec<Uid>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Uid {
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub atype: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UserAgent {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub browsers: Option<Vec<BrandVersion>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub platform: Option<BrandVersion>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mobile: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub architecture: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bitness: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BrandVersion {
+    pub brand: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub version: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BidResponse {
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub seatbid: Option<Vec<SeatBid>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bidid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cur: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub customdata: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nbr: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SeatBid {
+    pub bid: Vec<Bid>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub seat: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub group: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Bid {
+    pub id: String,
+    pub impid: String,
+    pub price: f64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub nurl: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub burl: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lurl: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub adm: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub adid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub adomain: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bundle: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub iurl: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub crid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tactic: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cattax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub attr: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub apis: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub api: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub protocol: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub qagmediarating: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub langb: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dealid: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub w: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub h: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wratio: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hratio: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub exp: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dur: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mtype: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub slotinpod: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
diff --git a/openrtb.md b/openrtb.md
new file mode 100644
index 00000000..c07e9329
--- /dev/null
+++ b/openrtb.md
@@ -0,0 +1,625 @@
+Below is a **complete (non-verbatim) OpenRTB 2.6 schema cheat-sheet** in Markdown: **all objects + field names + types + required/default notes**, plus a few **JSON examples**. It’s meant to be copy/pasteable while you build a library.
+
+> Conventions used below
+>
+> * `object` = JSON object, `object[]` = array of objects
+> * “required / recommended / optional” follows the spec language
+> * “default X” means if omitted, interpret as X
+> * Many integer enums are defined in **AdCOM 1.0** lists (Device Types, APIs, etc.).
+> * `ext` exists on most objects as an `object` for exchange/bidder extensions.
+
+---
+
+## 1) Bid Request
+
+### 1.1 `BidRequest` (top-level)
+
+| field     | type     |        req? | default | notes                                                                   |
+| --------- | -------- | ----------: | ------: | ----------------------------------------------------------------------- |
+| `id`      | string   |    required |         | request/auction ID                                                      |
+| `imp`     | `Imp[]`  |    required |         | 1+ impressions                                                          |
+| `site`    | `Site`   | recommended |         | **mutually exclusive** with `app`                                       |
+| `app`     | `App`    | recommended |         | **mutually exclusive** with `site`                                      |
+| `device`  | `Device` | recommended |         | device info                                                             |
+| `user`    | `User`   | recommended |         | user/audience info                                                      |
+| `test`    | integer  |    optional |       0 | 1=test mode                                                             |
+| `at`      | integer  |    optional |       2 | auction type (1=FP, 2=SP+)                                              |
+| `tmax`    | integer  |    optional |         | max time (ms) for bids                                                  |
+| `wseat`   | string[] |    optional |         | allowlist seats (use wseat **or** bseat)                                |
+| `bseat`   | string[] |    optional |         | blocklist seats; “at most only one of wseat and bseat”                  |
+| `allimps` | integer  |    optional |       0 | 1=all imps in context (roadblocking)                                    |
+| `cur`     | string[] |    optional |         | allowed currencies (ISO-4217)                                           |
+| `wlang`   | string[] |    optional |         | allowlist creative languages (ISO-639-1); only one of `wlang`/`wlangb`  |
+| `wlangb`  | string[] |    optional |         | allowlist creative languages (BCP-47); only one of `wlang`/`wlangb`     |
+| `bcat`    | string[] |    optional |         | blocked categories (taxonomy per `cattax`)                              |
+| `cattax`  | integer  |    optional |       1 | category taxonomy id                                                    |
+| `badv`    | string[] |    optional |         | blocked advertiser domains                                              |
+| `bapp`    | string[] |    optional |         | blocked app store IDs                                                   |
+| `source`  | `Source` |    optional |         | supply source + decisioning entity                                      |
+| `regs`    | `Regs`   |    optional |         | regulations in force                                                    |
+| `ext`     | object   |    optional |         | extensions                                                              |
+
+---
+
+### 1.2 `Source`
+
+| field    | type          |     req? | default | notes                          |
+| -------- | ------------- | -------: | ------: | ------------------------------ |
+| `fd`     | integer       | optional |       0 | “final decision” on sale (0/1) |
+| `tid`    | string        | optional |         | transaction ID                 |
+| `pchain` | string        | optional |         | payment chain                  |
+| `schain` | `SupplyChain` | optional |         | supply chain object            |
+| `ext`    | object        | optional |         |                                |
+
+*(Schema listed here; field meanings above are per spec section 3.2.2, referenced by BidRequest.)*
+
+---
+
+### 1.3 `Regs`
+
+| field        | type    |     req? | default | notes             |
+| ------------ | ------- | -------: | ------: | ----------------- |
+| `coppa`      | integer | optional |         | COPPA flag        |
+| `gdpr`       | integer | optional |         | GDPR flag         |
+| `us_privacy` | string  | optional |         | US Privacy string |
+| `ext`        | object  | optional |         |                   |
+
+---
+
+### 1.4 `Imp`
+
+| field               | type       |     req? | default | notes                                   |
+| ------------------- | ---------- | -------: | ------: | --------------------------------------- |
+| `id`                | string     | required |         | imp ID                                  |
+| `metric`            | `Metric[]` | optional |         | metrics array                           |
+| `banner`            | `Banner`   | optional |         | banner opportunity                      |
+| `video`             | `Video`    | optional |         | video opportunity                       |
+| `audio`             | `Audio`    | optional |         | audio opportunity                       |
+| `native`            | `Native`   | optional |         | native opportunity                      |
+| `pmp`               | `Pmp`      | optional |         | PMP container                           |
+| `displaymanager`    | string     | optional |         | mediation/SDK/player name               |
+| `displaymanagerver` | string     | optional |         | version                                 |
+| `instl`             | integer    | optional |       0 | interstitial/fullscreen                 |
+| `tagid`             | string     | optional |         | placement/ad tag id                     |
+| `bidfloor`          | float      | optional |       0 | CPM floor                               |
+| `bidfloorcur`       | string     | optional |   "USD" | ISO-4217                                |
+| `clickbrowser`      | integer    | optional |         | in-app click browser type               |
+| `secure`            | integer    | optional |         | 1=HTTPS required                        |
+| `iframebuster`      | string[]   | optional |         | supported iframe busters                |
+| `rwdd`              | integer    | optional |       0 | reward viewing                          |
+| `ssai`              | integer    | optional |       0 | server-side ad insertion mode           |
+| `exp`               | integer    | optional |         | seconds between auction and impression  |
+| `ext`               | object     | optional |         |                                         |
+
+---
+
+### 1.5 `Metric`
+
+| field    | type   |        req? | default | notes                        |
+| -------- | ------ | ----------: | ------: | ---------------------------- |
+| `type`   | string |    required |         | metric name                  |
+| `value`  | float  |    required |         | probability metrics in 0..1  |
+| `vendor` | string | recommended |         | e.g. “EXCHANGE”              |
+| `ext`    | object |    optional |         |                              |
+
+---
+
+### 1.6 `Banner`
+
+| field      | type       |        req? | default | notes                        |
+| ---------- | ---------- | ----------: | ------: | ---------------------------- |
+| `format`   | `Format[]` | recommended |         | allowed sizes/flex sizes     |
+| `w`        | integer    | recommended |         | width if no `format`         |
+| `h`        | integer    | recommended |         | height if no `format`        |
+| `btype`    | integer[]  |    optional |         | blocked banner types         |
+| `battr`    | integer[]  |    optional |         | blocked creative attributes  |
+| `pos`      | integer    |    optional |         | placement position           |
+| `mimes`    | string[]   |    optional |         | supported MIME types         |
+| `topframe` | integer    |    optional |         | 1=in top frame               |
+| `expdir`   | integer[]  |    optional |         | expandable directions        |
+| `api`      | integer[]  |    optional |         | supported APIs               |
+| `id`       | string     |    optional |         | companion banner id          |
+| `vcm`      | integer    |    optional |         | companion render mode        |
+| `ext`      | object     |    optional |         |                              |
+
+---
+
+### 1.7 `Video`
+
+Core fields (most commonly implemented):
+
+| field            | type       |       req? | default | notes                                               |
+| ---------------- | ---------- | ---------: | ------: | --------------------------------------------------- |
+| `mimes`          | string[]   |   required |         | supported video MIME types (see examples)           |
+| `minduration`    | integer    |   optional |         | min seconds (mutually exclusive with `rqddurs`)     |
+| `maxduration`    | integer    |   optional |         | max seconds (mutually exclusive with `rqddurs`)     |
+| `rqddurs`        | integer[]  |   optional |         | exact acceptable durations; exclusive with min/max  |
+| `protocols`      | integer[]  |   optional |         | supported protocols (AdCOM)                         |
+| `w`              | integer    |   optional |         | player width (DIPS in examples)                     |
+| `h`              | integer    |   optional |         | player height                                       |
+| `startdelay`     | integer    |   optional |         | start delay                                         |
+| `placement`      | integer    |   optional |         | placement subtype                                   |
+| `linearity`      | integer    |   optional |         | linear/nonlinear                                    |
+| `skip`           | integer    |   optional |         | 1=skippable                                         |
+| `skipmin`        | integer    |   optional |       0 | duration threshold for skippable                    |
+| `skipafter`      | integer    |   optional |       0 | seconds before skip enabled                         |
+| `battr`          | integer[]  |   optional |         | blocked creative attrs                              |
+| `maxextended`    | integer    |   optional |         | max extension seconds, 0/blank=no extension         |
+| `minbitrate`     | integer    |   optional |         | kbps                                                |
+| `maxbitrate`     | integer    |   optional |         | kbps                                                |
+| `boxingallowed`  | integer    |   optional |         | letterboxing allowed (example shows 1)              |
+| `playbackmethod` | integer[]  |   optional |         | playback methods (example shows array)              |
+| `delivery`       | integer[]  |   optional |         | delivery methods (example shows array)              |
+| `pos`            | integer    |   optional |         | placement position (ATF, etc.)                      |
+| `companionad`    | `Banner[]` |   optional |         | companion ads in VAST sense                         |
+| `companiontype`  | integer[]  |   optional |         | companion types (example)                           |
+| `podid`          | string     |   optional |         | pod identifier (pod bidding)                        |
+| `podseq`         | integer    |   optional |       0 | sequence of pod in stream                           |
+| `slotinpod`      | integer    |   optional |       0 | seller-guaranteed slot position                     |
+| `maxseq`         | integer    |   optional |         | max ads in pod (examples)                           |
+| `poddur`         | integer    |   optional |         | pod duration seconds (examples)                     |
+| `mincpmpersec`   | float      |   optional |         | min CPM/sec for dynamic pod portion                 |
+| `sequence`       | integer    | deprecated |       0 | deprecated sequencing                               |
+| `ext`            | object     |   optional |         |                                                     |
+
+---
+
+### 1.8 `Audio`
+
+Same shape as Video for most fields (mimes/durations/protocols/startdelay/placement/linearity/skip/bitrates/delivery/companion* and pod-bidding fields).
+Additionally supports `podid`, `podseq`, `slotinpod`, `maxseq`, `poddur` like Video (see changelog note). 
+
+*(If you want, I can output Audio as a full table mirroring Video 1:1; it’s long but straightforward.)*
+
+---
+
+### 1.9 `Native`
+
+| field     | type      |        req? | default | notes                                           |
+| --------- | --------- | ----------: | ------: | ----------------------------------------------- |
+| `request` | string    |    required |         | JSON-encoded request payload (Native 1.0/1.1+)  |
+| `ver`     | string    | recommended |         | version of Dynamic Native Ads API               |
+| `api`     | integer[] |    optional |         | supported APIs                                  |
+| `battr`   | integer[] |    optional |         | blocked creative attrs                          |
+| `ext`     | object    |    optional |         |                                                 |
+
+---
+
+### 1.10 `Format`
+
+| field    | type    |     req? | notes               |
+| -------- | ------- | -------: | ------------------- |
+| `w`      | integer | optional | width DIPS          |
+| `h`      | integer | optional | height DIPS         |
+| `wratio` | integer | optional | flex ratio width    |
+| `hratio` | integer | optional | flex ratio height   |
+| `wmin`   | integer | optional | min width for flex  |
+| `ext`    | object  | optional |                     |
+
+---
+
+### 1.11 `Pmp`
+
+| field             | type     |     req? | default | notes                 |
+| ----------------- | -------- | -------: | ------: | --------------------- |
+| `private_auction` | integer  | optional |       0 | 1=only deals allowed  |
+| `deals`           | `Deal[]` | optional |         | deals array           |
+| `ext`             | object   | optional |         |                       |
+
+### 1.12 `Deal`
+
+| field         | type     |     req? | default | notes                                                    |
+| ------------- | -------- | -------: | ------: | -------------------------------------------------------- |
+| `id`          | string   | required |         | deal id                                                  |
+| `bidfloor`    | float    | optional |       0 | CPM floor                                                |
+| `bidfloorcur` | string   | optional |   "USD" | ISO-4217                                                 |
+| `at`          | integer  | optional |         | auction override; includes “3 = bidfloor is deal price”  |
+| `wseat`       | string[] | optional |         | allowlist buyer seats                                    |
+| `wadomain`    | string[] | optional |         | allowlist advertiser domains                             |
+| `ext`         | object   | optional |         |                                                          |
+
+---
+
+### 1.13 `Site`
+
+| field           | type        |        req? | notes                          |
+| --------------- | ----------- | ----------: | ------------------------------ |
+| `id`            | string      | recommended | exchange site id               |
+| `name`          | string      |    optional |                                |
+| `domain`        | string      |    optional |                                |
+| `cattax`        | integer     |    optional | taxonomy                       |
+| `cat`           | string[]    |    optional | site categories                |
+| `sectioncat`    | string[]    |    optional | section categories             |
+| `pagecat`       | string[]    |    optional | page/view categories           |
+| `page`          | string      |    optional | page URL                       |
+| `ref`           | string      |    optional | referrer URL                   |
+| `search`        | string      |    optional | search string                  |
+| `mobile`        | integer     |    optional | 0/1 mobile optimized           |
+| `privacypolicy` | integer     |    optional | 0/1                            |
+| `publisher`     | `Publisher` |    optional |                                |
+| `content`       | `Content`   |    optional |                                |
+| `keywords`      | string      |    optional | CSV; exclusive with `kwarray`  |
+| `kwarray`       | string[]    |    optional | exclusive with `keywords`      |
+| `ext`           | object      |    optional |                                |
+
+---
+
+### 1.14 `App`
+
+| field           | type        |        req? | default | notes                            |
+| --------------- | ----------- | ----------: | ------: | -------------------------------- |
+| `id`            | string      | recommended |         | exchange app id                  |
+| `name`          | string      |    optional |         |                                  |
+| `bundle`        | string      |    optional |         | store id / package / numeric id  |
+| `domain`        | string      |    optional |         |                                  |
+| `storeurl`      | string      |    optional |         |                                  |
+| `cattax`        | integer     |    optional |       1 |                                  |
+| `cat`           | string[]    |    optional |         |                                  |
+| `sectioncat`    | string[]    |    optional |         |                                  |
+| `pagecat`       | string[]    |    optional |         |                                  |
+| `ver`           | string      |    optional |         |                                  |
+| `privacypolicy` | integer     |    optional |         |                                  |
+| `paid`          | integer     |    optional |         | 0 free / 1 paid                  |
+| `publisher`     | `Publisher` |    optional |         |                                  |
+| `content`       | `Content`   |    optional |         |                                  |
+| `keywords`      | string      |    optional |         | exclusive w/ `kwarray`           |
+| `kwarray`       | string[]    |    optional |         | exclusive w/ `keywords`          |
+| `ext`           | object      |    optional |         |                                  |
+
+---
+
+### 1.15 `Publisher`
+
+| field    | type     |     req? | notes                |
+| -------- | -------- | -------: | -------------------- |
+| `id`     | string   | optional | publisher id         |
+| `name`   | string   | optional |                      |
+| `cattax` | integer  | optional | taxonomy             |
+| `cat`    | string[] | optional | publisher categories |
+| `domain` | string   | optional |                      |
+| `ext`    | object   | optional |                      |
+
+---
+
+### 1.16 `Content`
+
+A large object; here’s the full field list (types) in one place (all optional unless noted):
+
+* IDs & naming: `id`(string), `episode`(integer), `title`(string), `series`(string), `season`(string)
+* Media metadata: `artist`(string), `genre`(string), `album`(string), `url`(string)
+* Keywords & categories: `keywords`(string), `kwarray`(string[]), `cattax`(integer), `cat`(string[])
+* Quality/ratings: `prodq`(integer), `rating`(string), `userrating`(string), `qagmediarating`(integer)
+* Context: `context`(integer), `livestream`(integer), `sourcerel`(integer), `len`(integer), `language`(string), `langb`(string), `embeddable`(integer)
+* Entity subobjects: `producer`(`Producer`), `network`(`Network`), `channel`(`Channel`)
+* `ext`(object)
+
+*(This list corresponds to the spec’s Content section 3.2.16 which also introduces Network/Channel in 2.6; see object definitions below.)*
+
+---
+
+### 1.17 `Producer`
+
+| field    | type     |     req? | default | notes |
+| -------- | -------- | -------: | ------: | ----- |
+| `id`     | string   | optional |         |       |
+| `name`   | string   | optional |         |       |
+| `cattax` | integer  | optional |       1 |       |
+| `cat`    | string[] | optional |         |       |
+| `domain` | string   | optional |         |       |
+| `ext`    | object   | optional |         |       |
+
+---
+
+### 1.18 `Device`
+
+| field            | type        |        req? | default | notes                                      |
+| ---------------- | ----------- | ----------: | ------: | ------------------------------------------ |
+| `geo`            | `Geo`       | recommended |         |                                            |
+| `dnt`            | integer     | recommended |         | do-not-track                               |
+| `lmt`            | integer     | recommended |         | limit-ad-tracking                          |
+| `ua`             | string      |    optional |         | raw UA string; see `sua` guidance          |
+| `sua`            | `UserAgent` |    optional |         | structured UA-CH data                      |
+| `ip`             | string      |    optional |         | IPv4                                       |
+| `ipv6`           | string      |    optional |         | IPv6                                       |
+| `devicetype`     | integer     |    optional |         | AdCOM device type                          |
+| `make`           | string      |    optional |         |                                            |
+| `model`          | string      |    optional |         |                                            |
+| `os`             | string      |    optional |         |                                            |
+| `osv`            | string      |    optional |         |                                            |
+| `hwv`            | string      |    optional |         |                                            |
+| `h`              | integer     |    optional |         | screen px height                           |
+| `w`              | integer     |    optional |         | screen px width                            |
+| `ppi`            | integer     |    optional |         |                                            |
+| `pxratio`        | float       |    optional |         |                                            |
+| `js`             | integer     |    optional |         |                                            |
+| `geofetch`       | integer     |    optional |         | geo API availability                       |
+| `flashver`       | string      |    optional |         |                                            |
+| `language`       | string      |    optional |         | ISO-639-1; only one of `language`/`langb`  |
+| `langb`          | string      |    optional |         | BCP-47; only one of `language`/`langb`     |
+| `carrier`        | string      |    optional |         |                                            |
+| `mccmnc`         | string      |    optional |         | MCC-MNC with dash                          |
+| `connectiontype` | integer     |    optional |         | AdCOM connection type                      |
+| `ifa`            | string      |    optional |         | ID for advertiser use                      |
+| `didsha1`        | string      |  deprecated |         |                                            |
+| `didmd5`         | string      |  deprecated |         |                                            |
+| `dpidsha1`       | string      |  deprecated |         |                                            |
+| `dpidmd5`        | string      |  deprecated |         |                                            |
+| `macsha1`        | string      |  deprecated |         |                                            |
+| `macmd5`         | string      |  deprecated |         |                                            |
+| `ext`            | object      |    optional |         |                                            |
+
+---
+
+### 1.19 `Geo`
+
+| field       | type    |     req? | notes                 |
+| ----------- | ------- | -------: | --------------------- |
+| `lat`       | float   | optional | latitude              |
+| `lon`       | float   | optional | longitude             |
+| `type`      | integer | optional | location source type  |
+| `accuracy`  | integer | optional | accuracy (meters)     |
+| `lastfix`   | integer | optional | time since last fix   |
+| `ipservice` | integer | optional | IP geo service        |
+| `country`   | string  | optional | country code          |
+| `region`    | string  | optional | region code           |
+| `metro`     | string  | optional | metro code            |
+| `city`      | string  | optional | city                  |
+| `zip`       | string  | optional | zip/postal            |
+| `utcoffset` | integer | optional | minutes offset        |
+| `ext`       | object  | optional |                       |
+
+---
+
+### 1.20 `User`
+
+| field        | type     |       req? | notes                                        |
+| ------------ | -------- | ---------: | -------------------------------------------- |
+| `id`         | string   |   optional | exchange user id                             |
+| `buyeruid`   | string   |   optional | buyer-specific id                            |
+| `yob`        | integer  | deprecated | year of birth (deprecated in 2.6 changelog)  |
+| `gender`     | string   | deprecated | deprecated in 2.6 changelog                  |
+| `keywords`   | string   |   optional | CSV; exclusive with kwarray                  |
+| `kwarray`    | string[] |   optional | exclusive with keywords                      |
+| `customdata` | string   |   optional | buyer data                                   |
+| `geo`        | `Geo`    |   optional | user home base (vs device current)           |
+| `data`       | `Data[]` |   optional | data segments                                |
+| `consent`    | string   |   optional | consent string                               |
+| `eids`       | `EID[]`  |   optional | external IDs                                 |
+| `ext`        | object   |   optional |                                              |
+
+---
+
+### 1.21 `Data`
+
+| field     | type        |     req? | notes              |
+| --------- | ----------- | -------: | ------------------ |
+| `id`      | string      | optional | data provider id   |
+| `name`    | string      | optional | data provider name |
+| `segment` | `Segment[]` | optional | segments           |
+| `ext`     | object      | optional |                    |
+
+### 1.22 `Segment`
+
+| field   | type   |     req? | notes         |
+| ------- | ------ | -------: | ------------- |
+| `id`    | string | optional | segment id    |
+| `name`  | string | optional | segment name  |
+| `value` | string | optional | segment value |
+| `ext`   | object | optional |               |
+
+---
+
+### 1.23 `Network` (added in 2.6)
+
+| field    | type   |     req? | notes        |
+| -------- | ------ | -------: | ------------ |
+| `id`     | string | optional | network id   |
+| `name`   | string | optional | network name |
+| `domain` | string | optional | domain       |
+| `ext`    | object | optional |              |
+
+### 1.24 `Channel` (added in 2.6)
+
+| field    | type   |     req? | notes        |
+| -------- | ------ | -------: | ------------ |
+| `id`     | string | optional | channel id   |
+| `name`   | string | optional | channel name |
+| `domain` | string | optional | domain       |
+| `ext`    | object | optional |              |
+
+---
+
+### 1.25 `SupplyChain` (SChain)
+
+| field      | type                |     req? | notes            |
+| ---------- | ------------------- | -------: | ---------------- |
+| `complete` | integer             | required | 0/1 completeness |
+| `nodes`    | `SupplyChainNode[]` | required | 1+ nodes         |
+| `ver`      | string              | required | schain version   |
+| `ext`      | object              | optional |                  |
+
+### 1.26 `SupplyChainNode`
+
+| field    | type    |     req? | notes                             |
+| -------- | ------- | -------: | --------------------------------- |
+| `asi`    | string  | required | ad system identifier              |
+| `sid`    | string  | required | seller ID within `asi`            |
+| `hp`     | integer | required | 1 if payment handled by this node |
+| `rid`    | string  | optional | request id                        |
+| `name`   | string  | optional | business name                     |
+| `domain` | string  | optional | business domain                   |
+| `ext`    | object  | optional |                                   |
+
+---
+
+### 1.27 `EID`
+
+| field    | type    |     req? | notes                  |
+| -------- | ------- | -------: | ---------------------- |
+| `source` | string  | required | identity source domain |
+| `uids`   | `UID[]` | required | 1+ uids                |
+| `ext`    | object  | optional |                        |
+
+### 1.28 `UID`
+
+| field   | type    |     req? | notes           |
+| ------- | ------- | -------: | --------------- |
+| `id`    | string  | required | the identifier  |
+| `atype` | integer | optional | ID type (AdCOM) |
+| `ext`   | object  | optional |                 |
+
+---
+
+### 1.29 `UserAgent` (UA-CH structured)
+
+| field          | type             |     req? | notes                         |
+| -------------- | ---------------- | -------: | ----------------------------- |
+| `browsers`     | `BrandVersion[]` | optional | browser brand/version list    |
+| `platform`     | `BrandVersion`   | optional | platform brand/version        |
+| `mobile`       | integer          | optional | 0/1/… (UA-CH Mobile guidance) |
+| `architecture` | string           | optional | e.g. “x86”, “arm”             |
+| `bitness`      | string           | optional | e.g. “64”                     |
+| `model`        | string           | optional | device model                  |
+| `source`       | integer          | optional | 0 default; UA source (AdCOM)  |
+| `ext`          | object           | optional |                               |
+
+### 1.30 `BrandVersion`
+
+| field     | type     |     req? | notes                     |
+| --------- | -------- | -------: | ------------------------- |
+| `brand`   | string   | required | brand identifier          |
+| `version` | string[] | optional | version components array  |
+| `ext`     | object   | optional |                           |
+
+---
+
+## 2) Bid Response
+
+### 2.1 `BidResponse` (top-level)
+
+| field        | type        |      req? | default | notes                            |
+| ------------ | ----------- | --------: | ------: | -------------------------------- |
+| `id`         | string      |  required |         | matches request id               |
+| `seatbid`    | `SeatBid[]` | optional* |         | 1+ if bidding; empty for no-bid  |
+| `bidid`      | string      |  optional |         | bidder response id               |
+| `cur`        | string      |  optional |   "USD" | ISO-4217                         |
+| `customdata` | string      |  optional |         | cookie data, base85-safe         |
+| `nbr`        | integer     |  optional |         | no-bid reason code reference     |
+| `ext`        | object      |  optional |         |                                  |
+
+*In practice: for no-bid you can return HTTP 204 or `{"id":"...","seatbid":[]}` (example patterns shown in spec). 
+
+---
+
+### 2.2 `SeatBid`
+
+| field   | type    |     req? | default | notes                  |
+| ------- | ------- | -------: | ------: | ---------------------- |
+| `bid`   | `Bid[]` | required |         | 1+ bids                |
+| `seat`  | string  | optional |         | buyer seat ID          |
+| `group` | integer | optional |       0 | 1=must win as a group  |
+| `ext`   | object  | optional |         |                        |
+
+---
+
+### 2.3 `Bid`
+
+Core transaction fields:
+
+| field   | type   |     req? | notes                |
+| ------- | ------ | -------: | -------------------- |
+| `id`    | string | required | bid id               |
+| `impid` | string | required | references `Imp.id`  |
+| `price` | float  | required | CPM price            |
+| `nurl`  | string | optional | win notice URL       |
+| `burl`  | string | optional | billing notice URL   |
+| `lurl`  | string | optional | loss notice URL      |
+| `adm`   | string | optional | ad markup inline     |
+
+Creative / policy / rendering metadata (common fields):
+
+| field            | type      |       req? | notes                                 |
+| ---------------- | --------- | ---------: | ------------------------------------- |
+| `adid`           | string    |   optional | preloaded ad id                       |
+| `adomain`        | string[]  |   optional | advertiser domains                    |
+| `bundle`         | string    |   optional | app store id                          |
+| `iurl`           | string    |   optional | representative image URL              |
+| `cid`            | string    |   optional | campaign id                           |
+| `crid`           | string    |   optional | creative id                           |
+| `tactic`         | string    |   optional | tactic id                             |
+| `cattax`         | integer   |   optional | default 1 taxonomy                    |
+| `cat`            | string[]  |   optional | creative categories                   |
+| `attr`           | integer[] |   optional | creative attributes                   |
+| `apis`           | integer[] |   optional | supported APIs                        |
+| `api`            | integer   | deprecated | deprecated in favor of `apis`         |
+| `protocol`       | integer   |   optional | video response protocol subtype       |
+| `qagmediarating` | integer   |   optional | media rating                          |
+| `language`       | string    |   optional | ISO-639-1; exclusive w/ `langb`       |
+| `langb`          | string    |   optional | BCP-47; exclusive w/ `language`       |
+| `dealid`         | string    |   optional | references `Deal.id`                  |
+| `w`              | integer   |   optional | width DIPS                            |
+| `h`              | integer   |   optional | height DIPS                           |
+| `wratio`         | integer   |   optional | flex width ratio                      |
+| `hratio`         | integer   |   optional | flex height ratio                     |
+| `exp`            | integer   |   optional | seconds bidder will wait              |
+| `dur`            | integer   |   optional | duration seconds (video/audio)        |
+| `mtype`          | integer   |   optional | 1 banner, 2 video, 3 audio, 4 native  |
+| `slotinpod`      | integer   |   optional | slot eligibility/position in pod      |
+| `ext`            | object    |   optional | extensions                            |
+
+---
+
+## 3) Minimal end-to-end JSON examples
+
+### 3.1 Banner request (skeleton)
+
+```json
+{
+  "id": "req-1",
+  "at": 2,
+  "tmax": 120,
+  "imp": [
+    {
+      "id": "1",
+      "banner": {
+        "format": [{"w": 300, "h": 250}],
+        "pos": 1
+      },
+      "bidfloor": 0.10,
+      "bidfloorcur": "USD"
+    }
+  ],
+  "site": { "page": "https://example.com" },
+  "device": { "ua": "Mozilla/5.0", "ip": "203.0.113.1", "js": 1 }
+}
+```
+
+### 3.2 Bid response (skeleton)
+
+```json
+{
+  "id": "req-1",
+  "cur": "USD",
+  "seatbid": [
+    {
+      "seat": "buyer-1",
+      "bid": [
+        {
+          "id": "bid-1",
+          "impid": "1",
+          "price": 1.23,
+          "adm": "<html>...</html>",
+          "adomain": ["advertiser.com"],
+          "crid": "creative-123"
+        }
+      ]
+    }
+  ]
+}
+```
+
+### 3.3 Pod-bidding style example (from the spec samples)
+
+The PDF includes full request/response examples for pod bidding; see the excerpted sample structure around `video.podid`, `slotinpod`, `maxseq`, `poddur` etc. 
+
+

From bc2e94abca635ad73c277f9127669f91e7f7aa6b Mon Sep 17 00:00:00 2001
From: Christian <christianpavilonis@outlook.com>
Date: Mon, 2 Mar 2026 09:02:47 -0500
Subject: [PATCH 2/3] review fixes

---
 crates/openrtb/src/lib.rs | 181 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 181 insertions(+)

diff --git a/crates/openrtb/src/lib.rs b/crates/openrtb/src/lib.rs
index 69da7bf7..e83604ae 100644
--- a/crates/openrtb/src/lib.rs
+++ b/crates/openrtb/src/lib.rs
@@ -14,6 +14,8 @@ pub struct BidRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub app: Option<App>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub dooh: Option<Dooh>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub device: Option<Device>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub user: Option<User>,
@@ -36,6 +38,8 @@ pub struct BidRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub wlangb: Option<Vec<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub acat: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub bcat: Option<Vec<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub cattax: Option<i32>,
@@ -74,6 +78,10 @@ pub struct Regs {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub us_privacy: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub gpp: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gpp_sid: Option<Vec<i32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub ext: Option<Object>,
 }
 
@@ -117,6 +125,12 @@ pub struct Imp {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub exp: Option<i32>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub qty: Option<Qty>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dt: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub refresh: Option<Refresh>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub ext: Option<Object>,
 }
 
@@ -221,6 +235,8 @@ pub struct Video {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub mincpmpersec: Option<f64>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub durfloors: Option<Vec<DurFloors>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub sequence: Option<i32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ext: Option<Object>,
@@ -276,6 +292,8 @@ pub struct Audio {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub mincpmpersec: Option<f64>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub durfloors: Option<Vec<DurFloors>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub sequence: Option<i32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ext: Option<Object>,
@@ -328,6 +346,8 @@ pub struct Deal {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub bidfloorcur: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub durfloors: Option<Vec<DurFloors>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub at: Option<i32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub wseat: Option<Vec<String>>,
@@ -413,6 +433,28 @@ pub struct App {
     pub ext: Option<Object>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Dooh {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub venuetype: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub venuetypetax: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<Publisher>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub domain: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub keywords: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub content: Option<Content>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Publisher {
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -751,6 +793,49 @@ pub struct BrandVersion {
     pub ext: Option<Object>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Qty {
+    pub multiplier: f64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sourcetype: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub vendor: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Refresh {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub refsettings: Option<Vec<RefSettings>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub count: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RefSettings {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reftype: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub minint: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DurFloors {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mindur: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub maxdur: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bidfloor: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ext: Option<Object>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BidResponse {
     pub id: String,
@@ -845,3 +930,99 @@ pub struct Bid {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ext: Option<Object>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::BidRequest;
+    use serde_json::json;
+
+    #[test]
+    fn preserves_openrtb_26_privacy_dooh_and_refresh_fields() {
+        let payload = json!({
+            "id": "request-1",
+            "imp": [
+                {
+                    "id": "imp-1",
+                    "banner": {
+                        "w": 300,
+                        "h": 250
+                    },
+                    "qty": {
+                        "multiplier": 14.2,
+                        "sourcetype": 1,
+                        "vendor": "measurement.example"
+                    },
+                    "dt": 1735689600000.0,
+                    "refresh": {
+                        "refsettings": [
+                            {
+                                "reftype": 1,
+                                "minint": 30
+                            }
+                        ],
+                        "count": 2
+                    },
+                    "video": {
+                        "mimes": ["video/mp4"],
+                        "durfloors": [
+                            {
+                                "mindur": 1,
+                                "bidfloor": 5.0
+                            }
+                        ]
+                    }
+                }
+            ],
+            "dooh": {
+                "id": "screen-group-1",
+                "venuetype": ["retail"],
+                "venuetypetax": 1,
+                "domain": "inventory.example"
+            },
+            "regs": {
+                "gpp": "DBABMA~CPXxRfAPXxRfAAfKABENB-CgAAAAAAAAAAYgAAAAAAAA",
+                "gpp_sid": [7],
+                "gdpr": 1
+            },
+            "acat": ["IAB1"]
+        });
+
+        let bid_request: BidRequest =
+            serde_json::from_value(payload.clone()).expect("should deserialize OpenRTB 2.6 fields");
+        let serialized =
+            serde_json::to_value(&bid_request).expect("should serialize OpenRTB 2.6 fields");
+
+        assert_eq!(
+            serialized["regs"]["gpp"], payload["regs"]["gpp"],
+            "should preserve regs.gpp"
+        );
+        assert_eq!(
+            serialized["regs"]["gpp_sid"], payload["regs"]["gpp_sid"],
+            "should preserve regs.gpp_sid"
+        );
+        assert_eq!(
+            serialized["acat"], payload["acat"],
+            "should preserve bidrequest.acat"
+        );
+        assert_eq!(
+            serialized["dooh"], payload["dooh"],
+            "should preserve bidrequest.dooh"
+        );
+        assert_eq!(
+            serialized["imp"][0]["qty"], payload["imp"][0]["qty"],
+            "should preserve imp.qty"
+        );
+        assert_eq!(
+            serialized["imp"][0]["dt"], payload["imp"][0]["dt"],
+            "should preserve imp.dt"
+        );
+        assert_eq!(
+            serialized["imp"][0]["refresh"], payload["imp"][0]["refresh"],
+            "should preserve imp.refresh"
+        );
+        assert_eq!(
+            serialized["imp"][0]["video"]["durfloors"], payload["imp"][0]["video"]["durfloors"],
+            "should preserve video.durfloors"
+        );
+    }
+}

From f2eee35075ff26e33bcf243427e751faae8b92a1 Mon Sep 17 00:00:00 2001
From: Christian <christianpavilonis@outlook.com>
Date: Mon, 2 Mar 2026 09:10:46 -0500
Subject: [PATCH 3/3] use new impl

---
 Cargo.lock                               |   1 +
 crates/common/Cargo.toml                 |   1 +
 crates/common/src/auction/formats.rs     |  28 +-
 crates/common/src/integrations/prebid.rs |  74 ++--
 crates/common/src/openrtb.rs             | 470 +++++++++++++++--------
 5 files changed, 354 insertions(+), 220 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f7f4e359..d207e8f8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2405,6 +2405,7 @@ dependencies = [
  "tokio-test",
  "toml",
  "trusted-server-js",
+ "trusted-server-openrtb",
  "url",
  "urlencoding",
  "uuid",
diff --git a/crates/common/Cargo.toml b/crates/common/Cargo.toml
index 17a0e04b..87cad591 100644
--- a/crates/common/Cargo.toml
+++ b/crates/common/Cargo.toml
@@ -42,6 +42,7 @@ serde_json = { workspace = true }
 sha2 = { workspace = true }
 tokio = { workspace = true }
 trusted-server-js = { path = "../js" }
+trusted-server-openrtb = { path = "../openrtb" }
 url = { workspace = true }
 urlencoding = { workspace = true }
 uuid = { workspace = true }
diff --git a/crates/common/src/auction/formats.rs b/crates/common/src/auction/formats.rs
index 71804e26..4db8bf7c 100644
--- a/crates/common/src/auction/formats.rs
+++ b/crates/common/src/auction/formats.rs
@@ -16,7 +16,10 @@ use crate::auction::types::OrchestratorExt;
 use crate::creative;
 use crate::error::TrustedServerError;
 use crate::geo::GeoInfo;
-use crate::openrtb::{OpenRtbBid, OpenRtbResponse, ResponseExt, SeatBid};
+use crate::openrtb::{
+    build_openrtb_bid, build_openrtb_response, build_seat_bid, maybe_object_from_serializable,
+    OpenRtbBidFields, ResponseExt,
+};
 use crate::settings::Settings;
 use crate::synthetic::{generate_synthetic_id, get_or_generate_synthetic_id};
 
@@ -206,21 +209,18 @@ pub fn convert_to_openrtb_response(
             String::new()
         };
 
-        let openrtb_bid = OpenRtbBid {
+        let openrtb_bid = build_openrtb_bid(OpenRtbBidFields {
             id: format!("{}-{}", bid.bidder, slot_id),
             impid: slot_id.to_string(),
             price,
             adm: Some(creative_html),
             crid: Some(format!("{}-creative", bid.bidder)),
-            w: Some(bid.width),
-            h: Some(bid.height),
+            width: Some(bid.width),
+            height: Some(bid.height),
             adomain: Some(bid.adomain.clone().unwrap_or_default()),
-        };
-
-        seatbids.push(SeatBid {
-            seat: Some(bid.bidder.clone()),
-            bid: vec![openrtb_bid],
         });
+
+        seatbids.push(build_seat_bid(Some(bid.bidder.clone()), vec![openrtb_bid]));
     }
 
     // Determine strategy name for response metadata
@@ -230,10 +230,10 @@ pub fn convert_to_openrtb_response(
         "parallel_only"
     };
 
-    let response_body = OpenRtbResponse {
-        id: auction_request.id.to_string(),
-        seatbid: seatbids,
-        ext: Some(ResponseExt {
+    let response_body = build_openrtb_response(
+        auction_request.id.to_string(),
+        seatbids,
+        maybe_object_from_serializable(&ResponseExt {
             orchestrator: OrchestratorExt {
                 strategy: strategy_name.to_string(),
                 providers: result.provider_responses.len(),
@@ -241,7 +241,7 @@ pub fn convert_to_openrtb_response(
                 time_ms: result.total_time_ms,
             },
         }),
-    };
+    );
 
     let body_bytes =
         serde_json::to_vec(&response_body).change_context(TrustedServerError::Auction {
diff --git a/crates/common/src/integrations/prebid.rs b/crates/common/src/integrations/prebid.rs
index 41e27a8a..1afbfed1 100644
--- a/crates/common/src/integrations/prebid.rs
+++ b/crates/common/src/integrations/prebid.rs
@@ -22,8 +22,9 @@ use crate::integrations::{
     IntegrationEndpoint, IntegrationProxy, IntegrationRegistration,
 };
 use crate::openrtb::{
-    Banner, Device, Format, Geo, Imp, ImpExt, OpenRtbRequest, PrebidExt, PrebidImpExt, Regs,
-    RegsExt, RequestExt, Site, TrustedServerExt, User, UserExt,
+    build_banner, build_device, build_format, build_geo, build_imp, build_openrtb_request,
+    build_regs, build_site, build_user, maybe_object_from_serializable, ImpExt, OpenRtbRequest,
+    PrebidExt, PrebidImpExt, RegsExt, RequestExt, TrustedServerExt, UserExt,
 };
 use crate::request_signing::RequestSigner;
 use crate::settings::{IntegrationConfig, Settings};
@@ -396,18 +397,15 @@ impl PrebidAuctionProvider {
         context: &AuctionContext<'_>,
         signer: Option<(&RequestSigner, String)>,
     ) -> OpenRtbRequest {
-        let imps: Vec<Imp> = request
+        let imps = request
             .slots
             .iter()
             .map(|slot| {
-                let formats: Vec<Format> = slot
+                let formats = slot
                     .formats
                     .iter()
                     .filter(|f| f.media_type == MediaType::Banner)
-                    .map(|f| Format {
-                        w: f.width,
-                        h: f.height,
-                    })
+                    .map(|f| build_format(f.width, f.height))
                     .collect();
 
                 // Use bidder params from the slot (passed through from the request)
@@ -424,13 +422,13 @@ impl PrebidAuctionProvider {
                     }
                 }
 
-                Imp {
-                    id: slot.id.clone(),
-                    banner: Some(Banner { format: formats }),
-                    ext: Some(ImpExt {
+                build_imp(
+                    slot.id.clone(),
+                    Some(build_banner(formats)),
+                    maybe_object_from_serializable(&ImpExt {
                         prebid: PrebidImpExt { bidder },
                     }),
-                }
+                )
             })
             .collect();
 
@@ -444,31 +442,32 @@ impl PrebidAuctionProvider {
         });
 
         // Build user object
-        let user = Some(User {
-            id: Some(request.user.id.clone()),
-            ext: Some(UserExt {
+        let user = Some(build_user(
+            Some(request.user.id.clone()),
+            maybe_object_from_serializable(&UserExt {
                 synthetic_fresh: Some(request.user.fresh_id.clone()),
             }),
-        });
+        ));
 
         // Build device object with user-agent and geo if available
-        let device = request.device.as_ref().map(|d| Device {
-            ua: d.user_agent.clone(),
-            geo: d.geo.as_ref().map(|geo| Geo {
-                geo_type: 2, // IP address per OpenRTB spec
-                country: Some(geo.country.clone()),
-                city: Some(geo.city.clone()),
-                region: geo.region.clone(),
-            }),
+        let device = request.device.as_ref().map(|d| {
+            build_device(
+                d.user_agent.clone(),
+                d.geo.as_ref().map(|geo| {
+                    build_geo(
+                        Some(geo.country.clone()),
+                        Some(geo.city.clone()),
+                        geo.region.clone(),
+                    )
+                }),
+            )
         });
 
         // Build regs object if Sec-GPC header is present
         let regs = if context.request.get_header("Sec-GPC").is_some() {
-            Some(Regs {
-                ext: Some(RegsExt {
-                    us_privacy: Some("1YYN".to_string()),
-                }),
-            })
+            Some(build_regs(maybe_object_from_serializable(&RegsExt {
+                us_privacy: Some("1YYN".to_string()),
+            })))
         } else {
             None
         };
@@ -479,7 +478,7 @@ impl PrebidAuctionProvider {
             .map(|(s, sig)| (Some(sig), Some(s.kid.clone())))
             .unwrap_or((None, None));
 
-        let ext = Some(RequestExt {
+        let ext = maybe_object_from_serializable(&RequestExt {
             prebid: if self.config.debug {
                 Some(PrebidExt { debug: Some(true) })
             } else {
@@ -493,18 +492,15 @@ impl PrebidAuctionProvider {
             }),
         });
 
-        OpenRtbRequest {
-            id: request.id.clone(),
-            imp: imps,
-            site: Some(Site {
-                domain: Some(request.publisher.domain.clone()),
-                page: page_url,
-            }),
+        build_openrtb_request(
+            request.id.clone(),
+            imps,
+            Some(build_site(Some(request.publisher.domain.clone()), page_url)),
             user,
             device,
             regs,
             ext,
-        }
+        )
     }
 
     /// Parse `OpenRTB` response into auction response.
diff --git a/crates/common/src/openrtb.rs b/crates/common/src/openrtb.rs
index 3b405209..be4d9d79 100644
--- a/crates/common/src/openrtb.rs
+++ b/crates/common/src/openrtb.rs
@@ -1,103 +1,334 @@
 use serde::Serialize;
-use serde_json::Value;
+use serde_json::{Map, Value};
 
 use crate::auction::types::OrchestratorExt;
 
-/// Minimal subset of `OpenRTB` 2.x bid request used by Trusted Server.
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub struct OpenRtbRequest {
-    /// Unique ID of the bid request, provided by the exchange.
-    pub id: String,
-    pub imp: Vec<Imp>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub site: Option<Site>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub user: Option<User>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub device: Option<Device>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub regs: Option<Regs>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ext: Option<RequestExt>,
+pub type Object = trusted_server_openrtb::Object;
+pub type OpenRtbRequest = trusted_server_openrtb::BidRequest;
+pub type OpenRtbResponse = trusted_server_openrtb::BidResponse;
+pub type OpenRtbBid = trusted_server_openrtb::Bid;
+
+pub use trusted_server_openrtb::{Banner, Device, Format, Geo, Imp, Regs, SeatBid, Site, User};
+
+fn clamp_u32_to_i32(value: u32) -> i32 {
+    value.min(i32::MAX as u32) as i32
 }
 
-#[derive(Debug, Serialize)]
-pub struct Imp {
-    pub id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub banner: Option<Banner>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ext: Option<ImpExt>,
+pub fn object_from_serializable<T: Serialize>(value: &T) -> Object {
+    match serde_json::to_value(value) {
+        Ok(Value::Object(map)) => map,
+        Ok(_) | Err(_) => Map::new(),
+    }
 }
 
-#[derive(Debug, Serialize)]
-pub struct Banner {
-    pub format: Vec<Format>,
+pub fn maybe_object_from_serializable<T: Serialize>(value: &T) -> Option<Object> {
+    let map = object_from_serializable(value);
+    if map.is_empty() {
+        None
+    } else {
+        Some(map)
+    }
 }
 
-#[derive(Debug, Serialize)]
-pub struct Format {
-    pub w: u32,
-    pub h: u32,
+#[must_use]
+pub fn build_format(width: u32, height: u32) -> Format {
+    Format {
+        w: Some(clamp_u32_to_i32(width)),
+        h: Some(clamp_u32_to_i32(height)),
+        wratio: None,
+        hratio: None,
+        wmin: None,
+        ext: None,
+    }
 }
 
-#[derive(Debug, Serialize)]
-pub struct Site {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub domain: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub page: Option<String>,
+#[must_use]
+pub fn build_banner(formats: Vec<Format>) -> Banner {
+    Banner {
+        format: Some(formats),
+        w: None,
+        h: None,
+        btype: None,
+        battr: None,
+        pos: None,
+        mimes: None,
+        topframe: None,
+        expdir: None,
+        api: None,
+        id: None,
+        vcm: None,
+        ext: None,
+    }
 }
 
-#[derive(Debug, Serialize, Default)]
-pub struct User {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ext: Option<UserExt>,
+#[must_use]
+pub fn build_imp(id: String, banner: Option<Banner>, ext: Option<Object>) -> Imp {
+    Imp {
+        id,
+        metric: None,
+        banner,
+        video: None,
+        audio: None,
+        native: None,
+        pmp: None,
+        displaymanager: None,
+        displaymanagerver: None,
+        instl: None,
+        tagid: None,
+        bidfloor: None,
+        bidfloorcur: None,
+        clickbrowser: None,
+        secure: None,
+        iframebuster: None,
+        rwdd: None,
+        ssai: None,
+        exp: None,
+        qty: None,
+        dt: None,
+        refresh: None,
+        ext,
+    }
 }
 
-#[derive(Debug, Serialize, Default)]
-pub struct UserExt {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub synthetic_fresh: Option<String>,
+#[must_use]
+pub fn build_site(domain: Option<String>, page: Option<String>) -> Site {
+    Site {
+        id: None,
+        name: None,
+        domain,
+        cattax: None,
+        cat: None,
+        sectioncat: None,
+        pagecat: None,
+        page,
+        r#ref: None,
+        search: None,
+        mobile: None,
+        privacypolicy: None,
+        publisher: None,
+        content: None,
+        keywords: None,
+        kwarray: None,
+        ext: None,
+    }
 }
 
-#[derive(Debug, Serialize, Default)]
-pub struct Device {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ua: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub geo: Option<Geo>,
+#[must_use]
+pub fn build_user(id: Option<String>, ext: Option<Object>) -> User {
+    User {
+        id,
+        buyeruid: None,
+        yob: None,
+        gender: None,
+        keywords: None,
+        kwarray: None,
+        customdata: None,
+        geo: None,
+        data: None,
+        consent: None,
+        eids: None,
+        ext,
+    }
 }
 
-#[derive(Debug, Serialize)]
-pub struct Geo {
-    /// Location type per `OpenRTB` spec (1=GPS, 2=IP address, 3=user provided)
-    #[serde(rename = "type")]
-    pub geo_type: u8,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub country: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub city: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub region: Option<String>,
+#[must_use]
+pub fn build_geo(country: Option<String>, city: Option<String>, region: Option<String>) -> Geo {
+    Geo {
+        lat: None,
+        lon: None,
+        r#type: Some(2),
+        accuracy: None,
+        lastfix: None,
+        ipservice: None,
+        country,
+        region,
+        metro: None,
+        city,
+        zip: None,
+        utcoffset: None,
+        ext: None,
+    }
+}
+
+#[must_use]
+pub fn build_device(ua: Option<String>, geo: Option<Geo>) -> Device {
+    Device {
+        geo,
+        dnt: None,
+        lmt: None,
+        ua,
+        sua: None,
+        ip: None,
+        ipv6: None,
+        devicetype: None,
+        make: None,
+        model: None,
+        os: None,
+        osv: None,
+        hwv: None,
+        h: None,
+        w: None,
+        ppi: None,
+        pxratio: None,
+        js: None,
+        geofetch: None,
+        flashver: None,
+        language: None,
+        langb: None,
+        carrier: None,
+        mccmnc: None,
+        connectiontype: None,
+        ifa: None,
+        didsha1: None,
+        didmd5: None,
+        dpidsha1: None,
+        dpidmd5: None,
+        macsha1: None,
+        macmd5: None,
+        ext: None,
+    }
+}
+
+#[must_use]
+pub fn build_regs(ext: Option<Object>) -> Regs {
+    Regs {
+        coppa: None,
+        gdpr: None,
+        us_privacy: None,
+        gpp: None,
+        gpp_sid: None,
+        ext,
+    }
+}
+
+#[must_use]
+pub fn build_openrtb_request(
+    id: String,
+    imp: Vec<Imp>,
+    site: Option<Site>,
+    user: Option<User>,
+    device: Option<Device>,
+    regs: Option<Regs>,
+    ext: Option<Object>,
+) -> OpenRtbRequest {
+    OpenRtbRequest {
+        id,
+        imp,
+        site,
+        app: None,
+        dooh: None,
+        device,
+        user,
+        test: None,
+        at: None,
+        tmax: None,
+        wseat: None,
+        bseat: None,
+        allimps: None,
+        cur: None,
+        wlang: None,
+        wlangb: None,
+        acat: None,
+        bcat: None,
+        cattax: None,
+        badv: None,
+        bapp: None,
+        source: None,
+        regs,
+        ext,
+    }
+}
+
+pub struct OpenRtbBidFields {
+    pub id: String,
+    pub impid: String,
+    pub price: f64,
+    pub adm: Option<String>,
+    pub crid: Option<String>,
+    pub width: Option<u32>,
+    pub height: Option<u32>,
+    pub adomain: Option<Vec<String>>,
+}
+
+#[must_use]
+pub fn build_openrtb_bid(fields: OpenRtbBidFields) -> OpenRtbBid {
+    OpenRtbBid {
+        id: fields.id,
+        impid: fields.impid,
+        price: fields.price,
+        nurl: None,
+        burl: None,
+        lurl: None,
+        adm: fields.adm,
+        adid: None,
+        adomain: fields.adomain,
+        bundle: None,
+        iurl: None,
+        cid: None,
+        crid: fields.crid,
+        tactic: None,
+        cattax: None,
+        cat: None,
+        attr: None,
+        apis: None,
+        api: None,
+        protocol: None,
+        qagmediarating: None,
+        language: None,
+        langb: None,
+        dealid: None,
+        w: fields.width.map(clamp_u32_to_i32),
+        h: fields.height.map(clamp_u32_to_i32),
+        wratio: None,
+        hratio: None,
+        exp: None,
+        dur: None,
+        mtype: None,
+        slotinpod: None,
+        ext: None,
+    }
+}
+
+#[must_use]
+pub fn build_seat_bid(seat: Option<String>, bid: Vec<OpenRtbBid>) -> SeatBid {
+    SeatBid {
+        bid,
+        seat,
+        group: None,
+        ext: None,
+    }
 }
 
-#[derive(Debug, Serialize, Default)]
-pub struct Regs {
+#[must_use]
+pub fn build_openrtb_response(
+    id: String,
+    seatbid: Vec<SeatBid>,
+    ext: Option<Object>,
+) -> OpenRtbResponse {
+    OpenRtbResponse {
+        id,
+        seatbid: Some(seatbid),
+        bidid: None,
+        cur: None,
+        customdata: None,
+        nbr: None,
+        ext,
+    }
+}
+
+#[derive(Debug, Serialize)]
+pub struct UserExt {
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub ext: Option<RegsExt>,
+    pub synthetic_fresh: Option<String>,
 }
 
-#[derive(Debug, Serialize, Default)]
+#[derive(Debug, Serialize)]
 pub struct RegsExt {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub us_privacy: Option<String>,
 }
 
-#[derive(Debug, Serialize, Default)]
+#[derive(Debug, Serialize)]
 pub struct RequestExt {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub prebid: Option<PrebidExt>,
@@ -105,13 +336,13 @@ pub struct RequestExt {
     pub trusted_server: Option<TrustedServerExt>,
 }
 
-#[derive(Debug, Serialize, Default)]
+#[derive(Debug, Serialize)]
 pub struct PrebidExt {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub debug: Option<bool>,
 }
 
-#[derive(Debug, Serialize, Default)]
+#[derive(Debug, Serialize)]
 pub struct TrustedServerExt {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub signature: Option<String>,
@@ -133,102 +364,7 @@ pub struct PrebidImpExt {
     pub bidder: std::collections::HashMap<String, Value>,
 }
 
-/// Minimal subset of `OpenRTB` 2.x bid response used by Trusted Server.
-#[derive(Debug, Serialize)]
-pub struct OpenRtbResponse {
-    pub id: String,
-    pub seatbid: Vec<SeatBid>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub ext: Option<ResponseExt>,
-}
-
-#[derive(Debug, Serialize)]
-pub struct SeatBid {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub seat: Option<String>,
-    pub bid: Vec<OpenRtbBid>,
-}
-
-#[derive(Debug, Serialize)]
-pub struct OpenRtbBid {
-    pub id: String,
-    pub impid: String,
-    pub price: f64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub adm: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub crid: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub w: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub h: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub adomain: Option<Vec<String>>,
-}
-
 #[derive(Debug, Serialize)]
 pub struct ResponseExt {
     pub orchestrator: OrchestratorExt,
 }
-
-#[cfg(test)]
-mod tests {
-    use super::{OpenRtbBid, OpenRtbResponse, ResponseExt, SeatBid};
-    use crate::auction::types::OrchestratorExt;
-
-    #[test]
-    fn openrtb_response_serializes_expected_fields() {
-        let response = OpenRtbResponse {
-            id: "auction-1".to_string(),
-            seatbid: vec![SeatBid {
-                seat: Some("bidder-a".to_string()),
-                bid: vec![OpenRtbBid {
-                    id: "bidder-a-slot-1".to_string(),
-                    impid: "slot-1".to_string(),
-                    price: 1.25,
-                    adm: Some("<div>Test Creative HTML</div>".to_string()),
-                    crid: Some("bidder-a-creative".to_string()),
-                    w: Some(300),
-                    h: Some(250),
-                    adomain: Some(vec!["example.com".to_string()]),
-                }],
-            }],
-            ext: Some(ResponseExt {
-                orchestrator: OrchestratorExt {
-                    strategy: "parallel_only".to_string(),
-                    providers: 2,
-                    total_bids: 3,
-                    time_ms: 12,
-                },
-            }),
-        };
-
-        let serialized = serde_json::to_value(&response).expect("should serialize");
-        let expected = serde_json::json!({
-            "id": "auction-1",
-            "seatbid": [{
-                "seat": "bidder-a",
-                "bid": [{
-                    "id": "bidder-a-slot-1",
-                    "impid": "slot-1",
-                    "price": 1.25,
-                    "adm": "<div>Test Creative HTML</div>",
-                    "crid": "bidder-a-creative",
-                    "w": 300,
-                    "h": 250,
-                    "adomain": ["example.com"]
-                }]
-            }],
-            "ext": {
-                "orchestrator": {
-                    "strategy": "parallel_only",
-                    "providers": 2,
-                    "total_bids": 3,
-                    "time_ms": 12
-                }
-            }
-        });
-
-        assert_eq!(serialized, expected);
-    }
-}